---

yaml
---
r: 149803
b: refs/heads/try2
c: 1c86179
h: refs/heads/master
i:
  149801: 4b6165c
  149799: 1c80022
v: v3

Author: liigo

[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: 3ade32145b41eaca9a66e716fc1eb868a32d9d75
+refs/heads/try2: 1c86179dba342857e782c97e9e9f53f0aa3bf8fc
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/RELEASES.txt

@@ -745,8 +745,8 @@ Version 0.2  (March 2012)
       * Merged per-platform std::{os*, fs*} to core::{libc, os}
       * Extensive cleanup, regularization in libstd, libcore
 
-Version 0.1  (January 2012)
----------------------------
+Version 0.1  (January 20, 2012)
+-------------------------------
 
    * Most language features work, including:
       * Unique pointers, unique closures, move semantics

branches/try2/src/librustc/front/feature_gate.rs

@@ -134,7 +134,7 @@ impl Visitor<()> for Context {
                     }
                 }
             }
-            ast::ViewItemExternCrate(..) => {
+            ast::ViewItemExternMod(..) => {
                 for attr in i.attrs.iter() {
                     if attr.name().get() == "phase"{
                         self.gate_feature("phase", attr.span,

branches/try2/src/librustc/front/std_inject.rs

@@ -74,7 +74,7 @@ pub fn with_version(krate: &str) -> Option<(InternedString, ast::StrStyle)> {
 impl fold::Folder for StandardLibraryInjector {
     fn fold_crate(&mut self, krate: ast::Crate) -> ast::Crate {
         let mut vis = vec!(ast::ViewItem {
-            node: ast::ViewItemExternCrate(token::str_to_ident("std"),
+            node: ast::ViewItemExternMod(token::str_to_ident("std"),
                                          with_version("std"),
                                          ast::DUMMY_NODE_ID),
             attrs: vec!(
@@ -90,15 +90,15 @@ impl fold::Folder for StandardLibraryInjector {
 
         if use_uv(&krate) && !self.sess.building_library.get() {
             vis.push(ast::ViewItem {
-                node: ast::ViewItemExternCrate(token::str_to_ident("green"),
+                node: ast::ViewItemExternMod(token::str_to_ident("green"),
                                              with_version("green"),
                                              ast::DUMMY_NODE_ID),
                 attrs: Vec::new(),
                 vis: ast::Inherited,
                 span: DUMMY_SP
             });
             vis.push(ast::ViewItem {
-                node: ast::ViewItemExternCrate(token::str_to_ident("rustuv"),
+                node: ast::ViewItemExternMod(token::str_to_ident("rustuv"),
                                              with_version("rustuv"),
                                              ast::DUMMY_NODE_ID),
                 attrs: Vec::new(),

branches/try2/src/librustc/front/test.rs

@@ -306,7 +306,7 @@ fn mk_std(cx: &TestCtxt) -> ast::ViewItem {
                                              path_node(~[id_test]),
                                              ast::DUMMY_NODE_ID))))
     } else {
-        ast::ViewItemExternCrate(id_test,
+        ast::ViewItemExternMod(id_test,
                                with_version("test"),
                                ast::DUMMY_NODE_ID)
     };

branches/try2/src/librustc/metadata/creader.rs

@@ -167,7 +167,7 @@ struct CrateInfo {
 
 fn extract_crate_info(e: &Env, i: &ast::ViewItem) -> Option<CrateInfo> {
     match i.node {
-        ast::ViewItemExternCrate(ident, ref path_opt, id) => {
+        ast::ViewItemExternMod(ident, ref path_opt, id) => {
             let ident = token::get_ident(ident);
             debug!("resolving extern crate stmt. ident: {:?} path_opt: {:?}",
                    ident, path_opt);

branches/try2/src/librustc/middle/privacy.rs

@@ -845,7 +845,7 @@ impl<'a> Visitor<()> for PrivacyVisitor<'a> {
 
     fn visit_view_item(&mut self, a: &ast::ViewItem, _: ()) {
         match a.node {
-            ast::ViewItemExternCrate(..) => {}
+            ast::ViewItemExternMod(..) => {}
             ast::ViewItemUse(ref uses) => {
                 for vpath in uses.iter() {
                     match vpath.node {
@@ -976,7 +976,7 @@ impl Visitor<()> for SanePrivacyVisitor {
                                                     reachable");
                 } else {
                     match i.node {
-                        ast::ViewItemExternCrate(..) => {
+                        ast::ViewItemExternMod(..) => {
                             self.tcx.sess.span_err(i.span, "`pub` visibility \
                                                             is not allowed");
                         }

branches/try2/src/librustc/middle/resolve.rs

@@ -1516,7 +1516,7 @@ impl Resolver {
                 }
             }
 
-            ViewItemExternCrate(name, _, node_id) => {
+            ViewItemExternMod(name, _, node_id) => {
                 // n.b. we don't need to look at the path option here, because cstore already did
                 match self.session.cstore.find_extern_mod_stmt_cnum(node_id) {
                     Some(crate_id) => {
@@ -5415,7 +5415,7 @@ impl Resolver {
         if vi.span == DUMMY_SP { return }
 
         match vi.node {
-            ViewItemExternCrate(..) => {} // ignore
+            ViewItemExternMod(..) => {} // ignore
             ViewItemUse(ref path) => {
                 for p in path.iter() {
                     match p.node {

branches/try2/src/librustc/util/nodemap.rs

@@ -118,8 +118,8 @@ impl Writer for FnvState {
     fn write(&mut self, bytes: &[u8]) -> io::IoResult<()> {
         let FnvState(mut hash) = *self;
         for byte in bytes.iter() {
-            hash = hash ^ (*byte as u64);
             hash = hash * 0x100000001b3;
+            hash = hash ^ (*byte as u64);
         }
         *self = FnvState(hash);
         Ok(())

branches/try2/src/librustdoc/clean.rs

@@ -1066,19 +1066,19 @@ impl Clean<Item> for ast::ViewItem {
 
 #[deriving(Clone, Encodable, Decodable)]
 pub enum ViewItemInner {
-    ExternCrate(~str, Option<~str>, ast::NodeId),
+    ExternMod(~str, Option<~str>, ast::NodeId),
     Import(~[ViewPath])
 }
 
 impl Clean<ViewItemInner> for ast::ViewItem_ {
     fn clean(&self) -> ViewItemInner {
         match self {
-            &ast::ViewItemExternCrate(ref i, ref p, ref id) => {
+            &ast::ViewItemExternMod(ref i, ref p, ref id) => {
                 let string = match *p {
                     None => None,
                     Some((ref x, _)) => Some(x.get().to_owned()),
                 };
-                ExternCrate(i.clean(), string, *id)
+                ExternMod(i.clean(), string, *id)
             }
             &ast::ViewItemUse(ref vp) => {
                 Import(vp.clean().move_iter().collect())

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

@@ -39,7 +39,6 @@ use std::io;
 use std::io::{fs, File, BufferedWriter};
 use std::str;
 use std::vec;
-use std::vec_ng::Vec;
 use collections::{HashMap, HashSet};
 
 use sync::Arc;
@@ -161,13 +160,6 @@ pub struct Cache {
     priv search_index: ~[IndexItem],
     priv privmod: bool,
     priv public_items: NodeSet,
-
-    // In rare case where a structure is defined in one module but implemented
-    // in another, if the implementing module is parsed before defining module,
-    // then the fully qualified name of the structure isn't presented in `paths`
-    // yet when its implementation methods are being indexed. Caches such methods
-    // and their parent id here and indexes them at the end of crate parsing.
-    priv orphan_methods: Vec<(ast::NodeId, clean::Item)>,
 }
 
 /// Helper struct to render all source code to HTML pages
@@ -257,31 +249,10 @@ pub fn run(mut krate: clean::Crate, dst: Path) -> io::IoResult<()> {
             extern_locations: HashMap::new(),
             privmod: false,
             public_items: public_items,
-            orphan_methods: Vec::new(),
         }
     });
     cache.stack.push(krate.name.clone());
     krate = cache.fold_crate(krate);
-    {
-        // Attach all orphan methods to the type's definition if the type
-        // has since been learned.
-        let Cache { search_index: ref mut index,
-                    orphan_methods: ref meths, paths: ref paths, ..} = cache;
-        for &(ref pid, ref item) in meths.iter() {
-            match paths.find(pid) {
-                Some(&(ref fqp, _)) => {
-                    index.push(IndexItem {
-                        ty: shortty(item),
-                        name: item.name.clone().unwrap(),
-                        path: fqp.slice_to(fqp.len() - 1).connect("::"),
-                        desc: shorter(item.doc_value()).to_owned(),
-                        parent: Some(*pid),
-                    });
-                },
-                None => {}
-            }
-        };
-    }
 
     // Add all the static files
     let mut dst = cx.dst.join(krate.name.as_slice());
@@ -556,33 +527,26 @@ impl DocFolder for Cache {
                     clean::TyMethodItem(..) |
                     clean::StructFieldItem(..) |
                     clean::VariantItem(..) => {
-                        (Some(*self.parent_stack.last().unwrap()),
-                         Some(self.stack.slice_to(self.stack.len() - 1)))
+                        Some((Some(*self.parent_stack.last().unwrap()),
+                              self.stack.slice_to(self.stack.len() - 1)))
 
                     }
                     clean::MethodItem(..) => {
                         if self.parent_stack.len() == 0 {
-                            (None, None)
+                            None
                         } else {
                             let last = self.parent_stack.last().unwrap();
-                            let path = match self.paths.find(last) {
-                                Some(&(_, "trait")) =>
-                                    Some(self.stack.slice_to(self.stack.len() - 1)),
-                                // The current stack not necessarily has correlation for
-                                // where the type was defined. On the other hand,
-                                // `paths` always has the right information if present.
-                                Some(&(ref fqp, "struct")) | Some(&(ref fqp, "enum")) =>
-                                    Some(fqp.slice_to(fqp.len() - 1)),
-                                Some(..) => Some(self.stack.as_slice()),
-                                None => None
+                            let amt = match self.paths.find(last) {
+                                Some(&(_, "trait")) => self.stack.len() - 1,
+                                Some(..) | None => self.stack.len(),
                             };
-                            (Some(*last), path)
+                            Some((Some(*last), self.stack.slice_to(amt)))
                         }
                     }
-                    _ => (None, Some(self.stack.as_slice()))
+                    _ => Some((None, self.stack.as_slice()))
                 };
                 match parent {
-                    (parent, Some(path)) if !self.privmod => {
+                    Some((parent, path)) if !self.privmod => {
                         self.search_index.push(IndexItem {
                             ty: shortty(&item),
                             name: s.to_owned(),
@@ -591,12 +555,7 @@ impl DocFolder for Cache {
                             parent: parent,
                         });
                     }
-                    (Some(parent), None) if !self.privmod => {
-                        // We have a parent, but we don't know where they're
-                        // defined yet. Wait for later to index this item.
-                        self.orphan_methods.push((parent, item.clone()))
-                    }
-                    _ => {}
+                    Some(..) | None => {}
                 }
             }
             None => {}
@@ -1001,8 +960,8 @@ fn item_module(w: &mut Writer, cx: &Context,
         match (&i1.inner, &i2.inner) {
             (&clean::ViewItemItem(ref a), &clean::ViewItemItem(ref b)) => {
                 match (&a.inner, &b.inner) {
-                    (&clean::ExternCrate(..), _) => Less,
-                    (_, &clean::ExternCrate(..)) => Greater,
+                    (&clean::ExternMod(..), _) => Less,
+                    (_, &clean::ExternMod(..)) => Greater,
                     _ => idx1.cmp(&idx2),
                 }
             }
@@ -1097,7 +1056,7 @@ fn item_module(w: &mut Writer, cx: &Context,
 
             clean::ViewItemItem(ref item) => {
                 match item.inner {
-                    clean::ExternCrate(ref name, ref src, _) => {
+                    clean::ExternMod(ref name, ref src, _) => {
                         try!(write!(w, "<tr><td><code>extern crate {}",
                                       name.as_slice()));
                         match *src {

branches/try2/src/librustdoc/visit_ast.rs

@@ -147,7 +147,7 @@ impl<'a> RustdocVisitor<'a> {
                     }
                 }
             }
-            ast::ViewItemExternCrate(..) => item.clone()
+            ast::ViewItemExternMod(..) => item.clone()
         };
         om.view_items.push(item);
     }

branches/try2/src/libstd/macros.rs

@@ -366,14 +366,12 @@ macro_rules! try(
     ($e:expr) => (match $e { Ok(e) => e, Err(e) => return Err(e) })
 )
 
-/// Create a `std::vec_ng::Vec` containing the arguments.
 #[macro_export]
 macro_rules! vec(
     ($($e:expr),*) => ({
-        // leading _ to allow empty construction without a warning.
-        let mut _temp = ::std::vec_ng::Vec::new();
-        $(_temp.push($e);)*
-        _temp
+        let mut temp = ::std::vec_ng::Vec::new();
+        $(temp.push($e);)*
+        temp
     })
 )
 

branches/try2/src/libsyntax/ast.rs

@@ -1019,7 +1019,7 @@ pub enum ViewItem_ {
     // optional (InternedString,StrStyle): if present, this is a location
     // (containing arbitrary characters) from which to fetch the crate sources
     // For example, extern crate whatever = "github.com/mozilla/rust"
-    ViewItemExternCrate(Ident, Option<(InternedString,StrStyle)>, NodeId),
+    ViewItemExternMod(Ident, Option<(InternedString,StrStyle)>, NodeId),
     ViewItemUse(Vec<@ViewPath> ),
 }
 

branches/try2/src/libsyntax/ast_util.rs

@@ -375,7 +375,7 @@ impl<'a, O: IdVisitingOperation> Visitor<()> for IdVisitor<'a, O> {
 
     fn visit_view_item(&mut self, view_item: &ViewItem, env: ()) {
         match view_item.node {
-            ViewItemExternCrate(_, _, node_id) => {
+            ViewItemExternMod(_, _, node_id) => {
                 self.operation.visit_id(node_id)
             }
             ViewItemUse(ref view_paths) => {

branches/try2/src/libsyntax/ext/expand.rs

@@ -424,7 +424,7 @@ pub fn expand_view_item(vi: &ast::ViewItem,
                         fld: &mut MacroExpander)
                         -> ast::ViewItem {
     match vi.node {
-        ast::ViewItemExternCrate(..) => {
+        ast::ViewItemExternMod(..) => {
             let should_load = vi.attrs.iter().any(|attr| {
                 attr.name().get() == "phase" &&
                     attr.meta_item_list().map_or(false, |phases| {
@@ -446,7 +446,7 @@ fn load_extern_macros(krate: &ast::ViewItem, fld: &mut MacroExpander) {
     let MacroCrate { lib, cnum } = fld.cx.ecfg.loader.load_crate(krate);
 
     let crate_name = match krate.node {
-        ast::ViewItemExternCrate(name, _, _) => name,
+        ast::ViewItemExternMod(name, _, _) => name,
         _ => unreachable!()
     };
     let name = format!("<{} macros>", token::get_ident(crate_name));

branches/try2/src/libsyntax/fold.rs

@@ -514,8 +514,8 @@ fn fold_variant_arg_<T: Folder>(va: &VariantArg, folder: &mut T) -> VariantArg {
 pub fn noop_fold_view_item<T: Folder>(vi: &ViewItem, folder: &mut T)
                                        -> ViewItem{
     let inner_view_item = match vi.node {
-        ViewItemExternCrate(ref ident, ref string, node_id) => {
-            ViewItemExternCrate(ident.clone(),
+        ViewItemExternMod(ref ident, ref string, node_id) => {
+            ViewItemExternMod(ident.clone(),
                               (*string).clone(),
                               folder.new_id(node_id))
         }

branches/try2/src/libsyntax/parse/parser.rs

@@ -55,7 +55,7 @@ use ast::{TyInfer, TypeMethod};
 use ast::{TyNil, TyParam, TyParamBound, TyPath, TyPtr, TyRptr};
 use ast::{TyTup, TyU32, TyUniq, TyVec, UnUniq};
 use ast::{UnnamedField, UnsafeBlock, UnsafeFn, ViewItem};
-use ast::{ViewItem_, ViewItemExternCrate, ViewItemUse};
+use ast::{ViewItem_, ViewItemExternMod, ViewItemUse};
 use ast::{ViewPath, ViewPathGlob, ViewPathList, ViewPathSimple};
 use ast::Visibility;
 use ast;
@@ -4361,7 +4361,7 @@ impl Parser {
         };
 
         IoviViewItem(ast::ViewItem {
-                node: ViewItemExternCrate(ident, maybe_path, ast::DUMMY_NODE_ID),
+                node: ViewItemExternMod(ident, maybe_path, ast::DUMMY_NODE_ID),
                 attrs: attrs,
                 vis: visibility,
                 span: mk_sp(lo, self.last_span.hi)
@@ -5017,11 +5017,11 @@ impl Parser {
                             // `extern crate` must precede `use`.
                             extern_mod_allowed = false;
                         }
-                        ViewItemExternCrate(..) if !extern_mod_allowed => {
+                        ViewItemExternMod(..) if !extern_mod_allowed => {
                             self.span_err(view_item.span,
                                           "\"extern crate\" declarations are not allowed here");
                         }
-                        ViewItemExternCrate(..) => {}
+                        ViewItemExternMod(..) => {}
                     }
                     view_items.push(view_item);
                 }

branches/try2/src/libsyntax/print/pprust.rs

@@ -2065,7 +2065,7 @@ pub fn print_view_item(s: &mut State, item: &ast::ViewItem) -> io::IoResult<()>
     try!(print_outer_attributes(s, item.attrs.as_slice()));
     try!(print_visibility(s, item.vis));
     match item.node {
-        ast::ViewItemExternCrate(id, ref optional_path, _) => {
+        ast::ViewItemExternMod(id, ref optional_path, _) => {
             try!(head(s, "extern crate"));
             try!(print_ident(s, id));
             for &(ref p, style) in optional_path.iter() {

branches/try2/src/libsyntax/visit.rs

@@ -148,7 +148,7 @@ pub fn walk_mod<E: Clone, V: Visitor<E>>(visitor: &mut V, module: &Mod, env: E)
 
 pub fn walk_view_item<E: Clone, V: Visitor<E>>(visitor: &mut V, vi: &ViewItem, env: E) {
     match vi.node {
-        ViewItemExternCrate(name, _, _) => {
+        ViewItemExternMod(name, _, _) => {
             visitor.visit_ident(vi.span, name, env)
         }
         ViewItemUse(ref paths) => {