---

yaml
---
r: 219763
b: refs/heads/snap-stage3
c: c9c5ea7
h: refs/heads/master
i:
  219761: 61418b4
  219759: c4caf62
v: v3

Author: Nick Hamann

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: c044791d80ea0dc5c4b57b6030a67b69f8510239
-refs/heads/snap-stage3: dd8fee0ae6dd6304a7ad2d5fc9cd9eda27af33f8
+refs/heads/snap-stage3: c9c5ea7c138af6c57da0da53517a4b5f6ccf4915
 refs/heads/try: b53c0f93eedcdedd4fd89bccc5a3a09d1c5cd23e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/snap-stage3/src/libcollections/bit.rs

@@ -8,11 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![deprecated(reason = "BitVec and BitSet have been migrated to cargo as bit-vec and bit-set",
-              since = "1.3.0")]
-#![unstable(feature = "collections", reason = "deprecated")]
-#![allow(deprecated)]
-
 // FIXME(Gankro): BitVec and BitSet are very tightly coupled. Ideally (for
 // maintenance), they should be in separate files/modules, with BitSet only
 // using BitVec's public API. This will be hard for performance though, because

branches/snap-stage3/src/libcollections/lib.rs

@@ -77,9 +77,7 @@ extern crate alloc;
 #[cfg(test)] extern crate test;
 
 pub use binary_heap::BinaryHeap;
-#[allow(deprecated)]
 pub use bit_vec::BitVec;
-#[allow(deprecated)]
 pub use bit_set::BitSet;
 pub use btree_map::BTreeMap;
 pub use btree_set::BTreeSet;
@@ -113,13 +111,11 @@ pub mod vec_map;
 
 #[unstable(feature = "bitvec", reason = "RFC 509")]
 pub mod bit_vec {
-    #![allow(deprecated)]
     pub use bit::{BitVec, Iter};
 }
 
 #[unstable(feature = "bitset", reason = "RFC 509")]
 pub mod bit_set {
-    #![allow(deprecated)]
     pub use bit::{BitSet, Union, Intersection, Difference, SymmetricDifference};
     pub use bit::SetIter as Iter;
 }

branches/snap-stage3/src/librustc/ast_map/mod.rs

@@ -121,7 +121,7 @@ pub enum Node<'ast> {
     NodeLifetime(&'ast Lifetime),
 }
 
-/// Represents an entry and its parent NodeID.
+/// Represents an entry and its parent Node ID
 /// The odd layout is to bring down the total size.
 #[derive(Copy, Debug)]
 enum MapEntry<'ast> {
@@ -179,7 +179,7 @@ impl<'ast> MapEntry<'ast> {
         }
     }
 
-    fn parent_node(self) -> Option<NodeId> {
+    fn parent(self) -> Option<NodeId> {
         Some(match self {
             EntryItem(id, _) => id,
             EntryForeignItem(id, _) => id,
@@ -283,88 +283,10 @@ impl<'ast> Map<'ast> {
         self.find_entry(id).and_then(|x| x.to_node())
     }
 
-    /// Similar to get_parent, returns the parent node id or id if there is no
-    /// parent.
-    /// This function returns the immediate parent in the AST, whereas get_parent
-    /// returns the enclosing item. Note that this might not be the actual parent
-    /// node in the AST - some kinds of nodes are not in the map and these will
-    /// never appear as the parent_node. So you can always walk the parent_nodes
-    /// from a node to the root of the ast (unless you get the same id back here
-    /// that can happen if the id is not in the map itself or is just weird).
-    pub fn get_parent_node(&self, id: NodeId) -> NodeId {
-        self.find_entry(id).and_then(|x| x.parent_node()).unwrap_or(id)
-    }
-
-    /// If there is some error when walking the parents (e.g., a node does not
-    /// have a parent in the map or a node can't be found), then we return the
-    /// last good node id we found. Note that reaching the crate root (id == 0),
-    /// is not an error, since items in the crate module have the crate root as
-    /// parent.
-    fn walk_parent_nodes<F>(&self, start_id: NodeId, found: F) -> Result<NodeId, NodeId>
-        where F: Fn(&Node<'ast>) -> bool
-    {
-        let mut id = start_id;
-        loop {
-            let parent_node = self.get_parent_node(id);
-            if parent_node == 0 {
-                return Ok(0);
-            }
-            if parent_node == id {
-                return Err(id);
-            }
-
-            let node = self.find_entry(parent_node);
-            if node.is_none() {
-                return Err(id);
-            }
-            let node = node.unwrap().to_node();
-            match node {
-                Some(ref node) => {
-                    if found(node) {
-                        return Ok(parent_node);
-                    }
-                }
-                None => {
-                    return Err(parent_node);
-                }
-            }
-            id = parent_node;
-        }
-    }
-
-    /// Retrieve the NodeId for `id`'s parent item, or `id` itself if no
-    /// parent item is in this map. The "parent item" is the closest parent node
-    /// in the AST which is recorded by the map and is an item, either an item
-    /// in a module, trait, or impl.
+    /// Retrieve the parent NodeId for `id`, or `id` itself if no
+    /// parent is registered in this map.
     pub fn get_parent(&self, id: NodeId) -> NodeId {
-        match self.walk_parent_nodes(id, |node| match *node {
-            NodeItem(_) |
-            NodeForeignItem(_) |
-            NodeTraitItem(_) |
-            NodeImplItem(_) => true,
-            _ => false,
-        }) {
-            Ok(id) => id,
-            Err(id) => id,
-        }
-    }
-
-    /// Returns the nearest enclosing scope. A scope is an item or block.
-    /// FIXME it is not clear to me that all items qualify as scopes - statics
-    /// and associated types probably shouldn't, for example. Behaviour in this
-    /// regard should be expected to be highly unstable.
-    pub fn get_enclosing_scope(&self, id: NodeId) -> Option<NodeId> {
-        match self.walk_parent_nodes(id, |node| match *node {
-            NodeItem(_) |
-            NodeForeignItem(_) |
-            NodeTraitItem(_) |
-            NodeImplItem(_) |
-            NodeBlock(_) => true,
-            _ => false,
-        }) {
-            Ok(id) => Some(id),
-            Err(_) => None,
-        }
+        self.find_entry(id).and_then(|x| x.parent()).unwrap_or(id)
     }
 
     pub fn get_parent_did(&self, id: NodeId) -> DefId {
@@ -668,15 +590,15 @@ impl<'a, 'ast> Iterator for NodesMatchingSuffix<'a, 'ast> {
                 return None;
             }
             self.idx += 1;
-            let name = match self.map.find_entry(idx) {
-                Some(EntryItem(_, n))       => n.name(),
-                Some(EntryForeignItem(_, n))=> n.name(),
-                Some(EntryTraitItem(_, n))  => n.name(),
-                Some(EntryImplItem(_, n))   => n.name(),
-                Some(EntryVariant(_, n))    => n.name(),
+            let (p, name) = match self.map.find_entry(idx) {
+                Some(EntryItem(p, n))       => (p, n.name()),
+                Some(EntryForeignItem(p, n))=> (p, n.name()),
+                Some(EntryTraitItem(p, n))  => (p, n.name()),
+                Some(EntryImplItem(p, n))   => (p, n.name()),
+                Some(EntryVariant(p, n))    => (p, n.name()),
                 _ => continue,
             };
-            if self.matches_names(self.map.get_parent(idx), name) {
+            if self.matches_names(p, name) {
                 return Some(idx)
             }
         }
@@ -725,7 +647,8 @@ impl<F: FoldOps> Folder for IdAndSpanUpdater<F> {
 /// A Visitor that walks over an AST and collects Node's into an AST Map.
 struct NodeCollector<'ast> {
     map: Vec<MapEntry<'ast>>,
-    parent_node: NodeId,
+    /// The node in which we are currently mapping (an item or a method).
+    parent: NodeId
 }
 
 impl<'ast> NodeCollector<'ast> {
@@ -739,7 +662,7 @@ impl<'ast> NodeCollector<'ast> {
     }
 
     fn insert(&mut self, id: NodeId, node: Node<'ast>) {
-        let entry = MapEntry::from_node(self.parent_node, node);
+        let entry = MapEntry::from_node(self.parent, node);
         self.insert_entry(id, entry);
     }
 
@@ -753,10 +676,8 @@ impl<'ast> NodeCollector<'ast> {
 impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
     fn visit_item(&mut self, i: &'ast Item) {
         self.insert(i.id, NodeItem(i));
-
-        let parent_node = self.parent_node;
-        self.parent_node = i.id;
-
+        let parent = self.parent;
+        self.parent = i.id;
         match i.node {
             ItemImpl(_, _, _, _, _, ref impl_items) => {
                 for ii in impl_items {
@@ -806,23 +727,21 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
             _ => {}
         }
         visit::walk_item(self, i);
-        self.parent_node = parent_node;
+        self.parent = parent;
     }
 
     fn visit_trait_item(&mut self, ti: &'ast TraitItem) {
-        let parent_node = self.parent_node;
-        self.parent_node = ti.id;
+        let parent = self.parent;
+        self.parent = ti.id;
         visit::walk_trait_item(self, ti);
-        self.parent_node = parent_node;
+        self.parent = parent;
     }
 
     fn visit_impl_item(&mut self, ii: &'ast ImplItem) {
-        let parent_node = self.parent_node;
-        self.parent_node = ii.id;
-
+        let parent = self.parent;
+        self.parent = ii.id;
         visit::walk_impl_item(self, ii);
-
-        self.parent_node = parent_node;
+        self.parent = parent;
     }
 
     fn visit_pat(&mut self, pat: &'ast Pat) {
@@ -831,58 +750,38 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
             PatIdent(..) => NodeLocal(pat),
             _ => NodePat(pat)
         });
-
-        let parent_node = self.parent_node;
-        self.parent_node = pat.id;
         visit::walk_pat(self, pat);
-        self.parent_node = parent_node;
     }
 
     fn visit_expr(&mut self, expr: &'ast Expr) {
         self.insert(expr.id, NodeExpr(expr));
-        let parent_node = self.parent_node;
-        self.parent_node = expr.id;
         visit::walk_expr(self, expr);
-        self.parent_node = parent_node;
     }
 
     fn visit_stmt(&mut self, stmt: &'ast Stmt) {
-        let id = ast_util::stmt_id(stmt);
-        self.insert(id, NodeStmt(stmt));
-        let parent_node = self.parent_node;
-        self.parent_node = id;
+        self.insert(ast_util::stmt_id(stmt), NodeStmt(stmt));
         visit::walk_stmt(self, stmt);
-        self.parent_node = parent_node;
     }
 
     fn visit_fn(&mut self, fk: visit::FnKind<'ast>, fd: &'ast FnDecl,
-                b: &'ast Block, s: Span, id: NodeId) {
-        let parent_node = self.parent_node;
-        self.parent_node = id;
+                b: &'ast Block, s: Span, _: NodeId) {
         self.visit_fn_decl(fd);
         visit::walk_fn(self, fk, fd, b, s);
-        self.parent_node = parent_node;
     }
 
     fn visit_ty(&mut self, ty: &'ast Ty) {
-        let parent_node = self.parent_node;
-        self.parent_node = ty.id;
         match ty.node {
             TyBareFn(ref fd) => {
                 self.visit_fn_decl(&*fd.decl);
             }
             _ => {}
         }
         visit::walk_ty(self, ty);
-        self.parent_node = parent_node;
     }
 
     fn visit_block(&mut self, block: &'ast Block) {
         self.insert(block.id, NodeBlock(block));
-        let parent_node = self.parent_node;
-        self.parent_node = block.id;
         visit::walk_block(self, block);
-        self.parent_node = parent_node;
     }
 
     fn visit_lifetime_ref(&mut self, lifetime: &'ast Lifetime) {
@@ -910,7 +809,7 @@ pub fn map_crate<'ast, F: FoldOps>(forest: &'ast mut Forest, fold_ops: F) -> Map
 
     let mut collector = NodeCollector {
         map: vec![],
-        parent_node: CRATE_NODE_ID,
+        parent: CRATE_NODE_ID
     };
     collector.insert_entry(CRATE_NODE_ID, RootCrate);
     visit::walk_crate(&mut collector, &forest.krate);
@@ -965,11 +864,11 @@ pub fn map_decoded_item<'ast, F: FoldOps>(map: &Map<'ast>,
         ii: ii
     });
 
-    let ii_parent_id = fld.new_id(DUMMY_NODE_ID);
     let mut collector = NodeCollector {
         map: mem::replace(&mut *map.map.borrow_mut(), vec![]),
-        parent_node: ii_parent_id,
+        parent: fld.new_id(DUMMY_NODE_ID)
     };
+    let ii_parent_id = collector.parent;
     collector.insert_entry(ii_parent_id, RootInlinedParent(ii_parent));
     visit::walk_inlined_item(&mut collector, &ii_parent.ii);
 

branches/snap-stage3/src/librustc/lib.rs

@@ -62,7 +62,6 @@
 #![feature(vec_push_all)]
 #![feature(wrapping)]
 #![feature(cell_extras)]
-#![feature(page_size)]
 #![cfg_attr(test, feature(test))]
 
 #![allow(trivial_casts)]

branches/snap-stage3/src/librustc/middle/astencode.rs

@@ -26,6 +26,7 @@ use metadata::tydecode::{RegionParameter, ClosureSource};
 use metadata::tyencode;
 use middle::cast;
 use middle::check_const::ConstQualif;
+use middle::mem_categorization::Typer;
 use middle::privacy::{AllPublic, LastMod};
 use middle::subst;
 use middle::subst::VecPerParamSpace;

branches/snap-stage3/src/librustc/middle/check_const.rs

@@ -110,16 +110,14 @@ impl<'a, 'tcx> CheckCrateVisitor<'a, 'tcx> {
     }
 
     fn with_euv<'b, F, R>(&'b mut self, item_id: Option<ast::NodeId>, f: F) -> R where
-        F: for<'t> FnOnce(&mut euv::ExprUseVisitor<'b, 't, 'b, 'tcx>) -> R,
+        F: for<'t> FnOnce(&mut euv::ExprUseVisitor<'b, 't, 'tcx,
+                                    ty::ParameterEnvironment<'a, 'tcx>>) -> R,
     {
         let param_env = match item_id {
             Some(item_id) => ty::ParameterEnvironment::for_item(self.tcx, item_id),
             None => self.tcx.empty_parameter_environment()
         };
-
-        let infcx = infer::new_infer_ctxt(self.tcx, &self.tcx.tables, Some(param_env), false);
-
-        f(&mut euv::ExprUseVisitor::new(self, &infcx))
+        f(&mut euv::ExprUseVisitor::new(self, &param_env))
     }
 
     fn global_expr(&mut self, mode: Mode, expr: &ast::Expr) -> ConstQualif {
@@ -285,11 +283,11 @@ impl<'a, 'tcx> CheckCrateVisitor<'a, 'tcx> {
 
     fn check_static_type(&self, e: &ast::Expr) {
         let ty = self.tcx.node_id_to_type(e.id);
-        let infcx = infer::new_infer_ctxt(self.tcx, &self.tcx.tables, None, false);
+        let infcx = infer::new_infer_ctxt(self.tcx, &self.tcx.tables, None);
+        let mut fulfill_cx = traits::FulfillmentContext::new(false);
         let cause = traits::ObligationCause::new(e.span, e.id, traits::SharedStatic);
-        let mut fulfill_cx = infcx.fulfillment_cx.borrow_mut();
         fulfill_cx.register_builtin_bound(&infcx, ty, ty::BoundSync, cause);
-        match fulfill_cx.select_all_or_error(&infcx) {
+        match fulfill_cx.select_all_or_error(&infcx, &infcx.parameter_environment) {
             Ok(()) => { },
             Err(ref errors) => {
                 traits::report_fulfillment_errors(&infcx, errors);