---

yaml
---
r: 148197
b: refs/heads/try2
c: d578ecc
h: refs/heads/master
i:
  148195: 2dcb62c
v: v3

Author: klutzy

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 01794cc993a1f00ca2bc82498b256a88556a4e83
+refs/heads/try2: d578ecc4072a0e0fade7d564f0ae6dac31c3fb45
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/docs.mk

@@ -308,7 +308,6 @@ $(eval $(call libdoc,std,$(STDLIB_CRATE),$(CFG_BUILD)))
 $(eval $(call libdoc,extra,$(EXTRALIB_CRATE),$(CFG_BUILD)))
 $(eval $(call libdoc,native,$(LIBNATIVE_CRATE),$(CFG_BUILD)))
 $(eval $(call libdoc,green,$(LIBGREEN_CRATE),$(CFG_BUILD)))
-$(eval $(call libdoc,rustuv,$(LIBRUSTUV_CRATE),$(CFG_BUILD)))
 
 $(eval $(call compiledoc,rustc,$(COMPILER_CRATE),$(CFG_BUILD)))
 $(eval $(call compiledoc,syntax,$(LIBSYNTAX_CRATE),$(CFG_BUILD)))

branches/try2/mk/install.mk

@@ -194,7 +194,7 @@ uninstall:
         ; \
         do rm -f $$i ; \
         done
-	$(Q)rm -Rf $(PHL)/$(CFG_RUSTLIBDIR)
+	$(Q)rm -Rf $(PHL)/rustc
 	$(Q)rm -f $(CFG_MANDIR)/man1/rustc.1
 	$(Q)rm -f $(CFG_MANDIR)/man1/rustdoc.1
 	$(Q)rm -f $(CFG_MANDIR)/man1/rusti.1

branches/try2/src/libextra/workcache.rs

@@ -209,28 +209,11 @@ impl Drop for Database {
     }
 }
 
-pub struct Logger {
-    // FIXME #4432: Fill in
-    priv a: ()
-}
-
-impl Logger {
-
-    pub fn new() -> Logger {
-        Logger { a: () }
-    }
-
-    pub fn info(&self, i: &str) {
-        info!("workcache: {}", i);
-    }
-}
-
 pub type FreshnessMap = TreeMap<~str,extern fn(&str,&str)->bool>;
 
 #[deriving(Clone)]
 pub struct Context {
     db: RWArc<Database>,
-    priv logger: RWArc<Logger>,
     priv cfg: Arc<json::Object>,
     /// Map from kinds (source, exe, url, etc.) to a freshness function.
     /// The freshness function takes a name (e.g. file path) and value
@@ -275,18 +258,15 @@ fn json_decode<T:Decodable<json::Decoder>>(s: &str) -> T {
 impl Context {
 
     pub fn new(db: RWArc<Database>,
-               lg: RWArc<Logger>,
                cfg: Arc<json::Object>) -> Context {
-        Context::new_with_freshness(db, lg, cfg, Arc::new(TreeMap::new()))
+        Context::new_with_freshness(db, cfg, Arc::new(TreeMap::new()))
     }
 
     pub fn new_with_freshness(db: RWArc<Database>,
-                              lg: RWArc<Logger>,
                               cfg: Arc<json::Object>,
                               freshness: Arc<FreshnessMap>) -> Context {
         Context {
             db: db,
-            logger: lg,
             cfg: cfg,
             freshness: freshness
         }
@@ -378,15 +358,11 @@ impl<'a> Prep<'a> {
             None => fail!("missing freshness-function for '{}'", kind),
             Some(f) => (*f)(name, val)
         };
-        self.ctxt.logger.write(|lg| {
-            if fresh {
-                lg.info(format!("{} {}:{} is fresh",
-                             cat, kind, name));
-            } else {
-                lg.info(format!("{} {}:{} is not fresh",
-                             cat, kind, name))
-            }
-        });
+        if fresh {
+            info!("{} {}:{} is fresh", cat, kind, name);
+        } else {
+            info!("{} {}:{} is not fresh", cat, kind, name);
+        }
         fresh
     }
 
@@ -509,7 +485,6 @@ fn test() {
     let db_path = make_path(~"db.json");
 
     let cx = Context::new(RWArc::new(Database::new(db_path)),
-                          RWArc::new(Logger::new()),
                           Arc::new(TreeMap::new()));
 
     let s = cx.with_prep("test1", |prep| {

branches/try2/src/librustc/middle/borrowck/check_loans.rs

@@ -24,10 +24,8 @@ use middle::moves;
 use middle::ty;
 use syntax::ast::{MutImmutable, MutMutable};
 use syntax::ast;
-use syntax::ast_map;
 use syntax::ast_util;
 use syntax::codemap::Span;
-use syntax::parse::token;
 use syntax::visit::Visitor;
 use syntax::visit;
 use util::ppaux::Repr;
@@ -79,7 +77,6 @@ pub fn check_loans(bccx: &BorrowckCtxt,
     clcx.visit_block(body, ());
 }
 
-#[deriving(Eq)]
 enum MoveError {
     MoveOk,
     MoveWhileBorrowed(/*loan*/@LoanPath, /*loan*/Span)
@@ -128,9 +125,6 @@ impl<'a> CheckLoanCtxt<'a> {
         //! given `loan_path`
 
         self.each_in_scope_loan(scope_id, |loan| {
-            debug!("each_in_scope_restriction found loan: {:?}",
-                   loan.repr(self.tcx()));
-
             let mut ret = true;
             for restr in loan.restrictions.iter() {
                 if restr.loan_path == loan_path {
@@ -653,34 +647,22 @@ impl<'a> CheckLoanCtxt<'a> {
 
     pub fn analyze_move_out_from(&self,
                                  expr_id: ast::NodeId,
-                                 mut move_path: @LoanPath)
-                                 -> MoveError {
+                                 move_path: @LoanPath) -> MoveError {
         debug!("analyze_move_out_from(expr_id={:?}, move_path={})",
-               ast_map::node_id_to_str(self.tcx().items,
-                                       expr_id,
-                                       token::get_ident_interner()),
-               move_path.repr(self.tcx()));
-
-        // We must check every element of a move path. See
-        // `borrowck-move-subcomponent.rs` for a test case.
-        loop {
-            // check for a conflicting loan:
-            let mut ret = MoveOk;
-            self.each_in_scope_restriction(expr_id, move_path, |loan, _| {
-                // Any restriction prevents moves.
-                ret = MoveWhileBorrowed(loan.loan_path, loan.span);
-                false
-            });
+               expr_id, move_path.repr(self.tcx()));
 
-            if ret != MoveOk {
-                return ret
-            }
+        // FIXME(#4384) inadequare if/when we permit `move a.b`
 
-            match *move_path {
-                LpVar(_) => return MoveOk,
-                LpExtend(subpath, _, _) => move_path = subpath,
-            }
-        }
+        let mut ret = MoveOk;
+
+        // check for a conflicting loan:
+        self.each_in_scope_restriction(expr_id, move_path, |loan, _| {
+            // Any restriction prevents moves.
+            ret = MoveWhileBorrowed(loan.loan_path, loan.span);
+            false
+        });
+
+        ret
     }
 
     pub fn check_call(&self,

branches/try2/src/librustc/middle/borrowck/mod.rs

@@ -872,10 +872,7 @@ impl Repr for LoanPath {
     fn repr(&self, tcx: ty::ctxt) -> ~str {
         match self {
             &LpVar(id) => {
-                format!("$({})",
-                        ast_map::node_id_to_str(tcx.items,
-                                                id,
-                                                token::get_ident_interner()))
+                format!("$({:?})", id)
             }
 
             &LpExtend(lp, _, LpDeref(_)) => {

branches/try2/src/librustdoc/html/render.rs

@@ -157,7 +157,6 @@ pub struct Cache {
     priv stack: ~[~str],
     priv parent_stack: ~[ast::NodeId],
     priv search_index: ~[IndexItem],
-    priv privmod: bool,
 }
 
 /// Helper struct to render all source code to HTML pages
@@ -242,7 +241,6 @@ pub fn run(mut crate: clean::Crate, dst: Path) {
         parent_stack: ~[],
         search_index: ~[],
         extern_locations: HashMap::new(),
-        privmod: false,
     };
     cache.stack.push(crate.name.clone());
     crate = cache.fold_crate(crate);
@@ -457,16 +455,6 @@ impl<'a> SourceCollector<'a> {
 
 impl DocFolder for Cache {
     fn fold_item(&mut self, item: clean::Item) -> Option<clean::Item> {
-        // If this is a private module, we don't want it in the search index.
-        let orig_privmod = match item.inner {
-            clean::ModuleItem(..) => {
-                let prev = self.privmod;
-                self.privmod = prev || item.visibility != Some(ast::Public);
-                prev
-            }
-            _ => self.privmod,
-        };
-
         // Register any generics to their corresponding string. This is used
         // when pretty-printing types
         match item.inner {
@@ -542,7 +530,7 @@ impl DocFolder for Cache {
                     _ => Some((None, self.stack.as_slice()))
                 };
                 match parent {
-                    Some((parent, path)) if !self.privmod => {
+                    Some((parent, path)) => {
                         self.search_index.push(IndexItem {
                             ty: shortty(&item),
                             name: s.to_owned(),
@@ -551,7 +539,7 @@ impl DocFolder for Cache {
                             parent: parent,
                         });
                     }
-                    Some(..) | None => {}
+                    None => {}
                 }
             }
             None => {}
@@ -624,12 +612,8 @@ impl DocFolder for Cache {
                     // Private modules may survive the strip-private pass if
                     // they contain impls for public types, but those will get
                     // stripped here
-                    clean::Item { inner: clean::ModuleItem(ref m),
-                                  visibility, .. }
-                            if (m.items.len() == 0 &&
-                                item.doc_value().is_none()) ||
-                               visibility != Some(ast::Public) => None,
-
+                    clean::Item { inner: clean::ModuleItem(ref m), .. }
+                            if m.items.len() == 0 => None,
                     i => Some(i),
                 }
             }
@@ -638,7 +622,6 @@ impl DocFolder for Cache {
 
         if pushed { self.stack.pop(); }
         if parent_pushed { self.parent_stack.pop(); }
-        self.privmod = orig_privmod;
         return ret;
     }
 }
@@ -1203,7 +1186,7 @@ fn item_struct(w: &mut Writer, it: &clean::Item, s: &clean::Struct) {
 
     document(w, it);
     match s.struct_type {
-        doctree::Plain if s.fields.len() > 0 => {
+        doctree::Plain => {
             write!(w, "<h2 class='fields'>Fields</h2>\n<table>");
             for field in s.fields.iter() {
                 write!(w, "<tr><td id='structfield.{name}'>\

branches/try2/src/librustdoc/lib.rs

@@ -83,7 +83,6 @@ pub fn opts() -> ~[groups::OptGroup] {
     use extra::getopts::groups::*;
     ~[
         optflag("h", "help", "show this help message"),
-        optflag("", "version", "print rustdoc's version"),
         optopt("r", "input-format", "the input type of the specified file",
                "[rust|json]"),
         optopt("w", "output-format", "the output type to write",
@@ -120,9 +119,6 @@ pub fn main_args(args: &[~str]) -> int {
     if matches.opt_present("h") || matches.opt_present("help") {
         usage(args[0]);
         return 0;
-    } else if matches.opt_present("version") {
-        rustc::version(args[0]);
-        return 0;
     }
 
     if matches.free.len() == 0 {

branches/try2/src/librustdoc/passes.rs

@@ -136,9 +136,7 @@ impl<'a> fold::DocFolder for Stripper<'a> {
             Some(i) => {
                 match i.inner {
                     // emptied modules/impls have no need to exist
-                    clean::ModuleItem(ref m)
-                        if m.items.len() == 0 &&
-                           i.doc_value().is_none() => None,
+                    clean::ModuleItem(ref m) if m.items.len() == 0 => None,
                     clean::ImplItem(ref i) if i.methods.len() == 0 => None,
                     _ => {
                         self.retained.insert(i.id);

branches/try2/src/librustpkg/api.rs

@@ -25,7 +25,7 @@ pub use source_control::{safe_git_clone, git_clone_url};
 use std::run;
 use extra::arc::{Arc,RWArc};
 use extra::workcache;
-use extra::workcache::{Database, Logger, FreshnessMap};
+use extra::workcache::{Database, FreshnessMap};
 use extra::treemap::TreeMap;
 
 // A little sad -- duplicated from rustc::back::*
@@ -70,14 +70,13 @@ pub fn new_workcache_context(p: &Path) -> workcache::Context {
     let db_file = p.join("rustpkg_db.json"); // ??? probably wrong
     debug!("Workcache database file: {}", db_file.display());
     let db = RWArc::new(Database::new(db_file));
-    let lg = RWArc::new(Logger::new());
     let cfg = Arc::new(TreeMap::new());
     let mut freshness: FreshnessMap = TreeMap::new();
     // Set up freshness functions for every type of dependency rustpkg
     // knows about
     freshness.insert(~"file", file_is_fresh);
     freshness.insert(~"binary", binary_is_fresh);
-    workcache::Context::new_with_freshness(db, lg, cfg, Arc::new(freshness))
+    workcache::Context::new_with_freshness(db, cfg, Arc::new(freshness))
 }
 
 pub fn build_lib(sysroot: Path, root: Path, name: ~str, version: Version,

branches/try2/src/librustpkg/parse_args.rs

@@ -36,8 +36,7 @@ pub struct ParseResult {
 /// Parses command line arguments of rustpkg.
 /// Returns a triplet (command, remaining_args, context)
 pub fn parse_args(args: &[~str]) -> Result<ParseResult, int> {
-    let opts = ~[ getopts::optflag("h"), getopts::optflag("help"),
-                                        getopts::optflag("no-link"),
+    let opts = ~[ getopts::optflag("no-link"),
                                         getopts::optflag("no-trans"),
                  // n.b. Ignores different --pretty options for now
                                         getopts::optflag("pretty"),
@@ -72,12 +71,6 @@ pub fn parse_args(args: &[~str]) -> Result<ParseResult, int> {
     let pretty = matches.opt_present("pretty");
     let emit_llvm = matches.opt_present("emit-llvm");
 
-    if matches.opt_present("h") ||
-       matches.opt_present("help") {
-         usage::general();
-         return Err(0);
-    }
-
     if matches.opt_present("v") ||
        matches.opt_present("version") {
         version(args[0]);

branches/try2/src/librustpkg/tests.rs

@@ -20,7 +20,7 @@ use extra::arc::Arc;
 use extra::arc::RWArc;
 use extra::tempfile::TempDir;
 use extra::workcache;
-use extra::workcache::{Database, Logger};
+use extra::workcache::{Database};
 use extra::treemap::TreeMap;
 use extra::getopts::groups::getopts;
 use std::run::ProcessOutput;
@@ -46,7 +46,6 @@ use exit_codes::{BAD_FLAG_CODE, COPY_FAILED_CODE};
 fn fake_ctxt(sysroot: Path, workspace: &Path) -> BuildContext {
     let context = workcache::Context::new(
         RWArc::new(Database::new(workspace.join("rustpkg_db.json"))),
-        RWArc::new(Logger::new()),
         Arc::new(TreeMap::new()));
     BuildContext {
         workcache_context: context,