---

yaml
---
r: 276820
b: refs/heads/try
c: e17c48b
h: refs/heads/master

Author: eddyb

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 6dbb0e86aec11050480beb76eade6fb805010ba7
 refs/heads/snap-stage3: 235d77457d80b549dad3ac36d94f235208a1eafb
-refs/heads/try: 7ded11a58cf2f8037a511a8d340161c59fba9913
+refs/heads/try: e17c48bb243163e22f4d5a3b42499c642ae41dec
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/src/librustc/ty/fold.rs

@@ -116,9 +116,21 @@ pub trait TypeFoldable<'tcx>: fmt::Debug + Clone {
 pub trait TypeFolder<'tcx> : Sized {
     fn tcx<'a>(&'a self) -> &'a TyCtxt<'tcx>;
 
+    /// Invoked by the `super_*` routines when we enter a region
+    /// binding level (for example, when entering a function
+    /// signature). This is used by clients that want to track the
+    /// Debruijn index nesting level.
+    fn enter_region_binder(&mut self) { }
+
+    /// Invoked by the `super_*` routines when we exit a region
+    /// binding level. This is used by clients that want to
+    /// track the Debruijn index nesting level.
+    fn exit_region_binder(&mut self) { }
+
     fn fold_binder<T>(&mut self, t: &Binder<T>) -> Binder<T>
         where T : TypeFoldable<'tcx>
     {
+        // FIXME(#20526) this should replace `enter_region_binder`/`exit_region_binder`.
         t.super_fold_with(self)
     }
 
@@ -185,9 +197,8 @@ pub trait TypeFolder<'tcx> : Sized {
 }
 
 pub trait TypeVisitor<'tcx> : Sized {
-    fn visit_binder<T: TypeFoldable<'tcx>>(&mut self, t: &Binder<T>) -> bool {
-        t.super_visit_with(self)
-    }
+    fn enter_region_binder(&mut self) { }
+    fn exit_region_binder(&mut self) { }
 
     fn visit_ty(&mut self, t: Ty<'tcx>) -> bool {
         t.super_visit_with(self)
@@ -285,11 +296,12 @@ impl<'a, 'tcx> TypeFolder<'tcx> for RegionFolder<'a, 'tcx>
 {
     fn tcx(&self) -> &TyCtxt<'tcx> { self.tcx }
 
-    fn fold_binder<T: TypeFoldable<'tcx>>(&mut self, t: &ty::Binder<T>) -> ty::Binder<T> {
+    fn enter_region_binder(&mut self) {
         self.current_depth += 1;
-        let t = t.super_fold_with(self);
+    }
+
+    fn exit_region_binder(&mut self) {
         self.current_depth -= 1;
-        t
     }
 
     fn fold_region(&mut self, r: ty::Region) -> ty::Region {
@@ -426,11 +438,12 @@ impl<'a, 'tcx> TypeFolder<'tcx> for RegionReplacer<'a, 'tcx>
 {
     fn tcx(&self) -> &TyCtxt<'tcx> { self.tcx }
 
-    fn fold_binder<T: TypeFoldable<'tcx>>(&mut self, t: &ty::Binder<T>) -> ty::Binder<T> {
+    fn enter_region_binder(&mut self) {
         self.current_depth += 1;
-        let t = t.super_fold_with(self);
+    }
+
+    fn exit_region_binder(&mut self) {
         self.current_depth -= 1;
-        t
     }
 
     fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
@@ -583,11 +596,12 @@ struct HasEscapingRegionsVisitor {
 }
 
 impl<'tcx> TypeVisitor<'tcx> for HasEscapingRegionsVisitor {
-    fn visit_binder<T: TypeFoldable<'tcx>>(&mut self, t: &Binder<T>) -> bool {
+    fn enter_region_binder(&mut self) {
         self.depth += 1;
-        let result = t.super_visit_with(self);
+    }
+
+    fn exit_region_binder(&mut self) {
         self.depth -= 1;
-        result
     }
 
     fn visit_ty(&mut self, t: Ty<'tcx>) -> bool {

branches/try/src/librustc/ty/structural_impls.rs

@@ -190,19 +190,21 @@ impl<'tcx, T: TypeFoldable<'tcx>> TypeFoldable<'tcx> for Vec<T> {
 
 impl<'tcx, T:TypeFoldable<'tcx>> TypeFoldable<'tcx> for ty::Binder<T> {
     fn super_fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
-        ty::Binder(self.0.fold_with(folder))
+        folder.enter_region_binder();
+        let result = ty::Binder(self.0.fold_with(folder));
+        folder.exit_region_binder();
+        result
     }
 
     fn fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
         folder.fold_binder(self)
     }
 
     fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
-        self.0.visit_with(visitor)
-    }
-
-    fn visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
-        visitor.visit_binder(self)
+        visitor.enter_region_binder();
+        if self.0.visit_with(visitor) { return true }
+        visitor.exit_region_binder();
+        false
     }
 }
 
@@ -218,11 +220,39 @@ impl<'tcx, T: TypeFoldable<'tcx>> TypeFoldable<'tcx> for P<[T]> {
 
 impl<'tcx, T: TypeFoldable<'tcx>> TypeFoldable<'tcx> for VecPerParamSpace<T> {
     fn super_fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
-        self.map(|elem| elem.fold_with(folder))
+
+        // Things in the Fn space take place under an additional level
+        // of region binding relative to the other spaces. This is
+        // because those entries are attached to a method, and methods
+        // always introduce a level of region binding.
+
+        let result = self.map_enumerated(|(space, index, elem)| {
+            if space == subst::FnSpace && index == 0 {
+                // enter new level when/if we reach the first thing in fn space
+                folder.enter_region_binder();
+            }
+            elem.fold_with(folder)
+        });
+        if result.len(subst::FnSpace) > 0 {
+            // if there was anything in fn space, exit the region binding level
+            folder.exit_region_binder();
+        }
+        result
     }
 
     fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
-        self.iter().any(|elem| elem.visit_with(visitor))
+        let mut entered_region_binder = false;
+        let result = self.iter_enumerated().any(|(space, index, t)| {
+            if space == subst::FnSpace && index == 0 {
+                visitor.enter_region_binder();
+                entered_region_binder = true;
+            }
+            t.visit_with(visitor)
+        });
+        if entered_region_binder {
+            visitor.exit_region_binder();
+        }
+        result
     }
 }
 

branches/try/src/librustc/ty/subst.rs

@@ -582,11 +582,12 @@ struct SubstFolder<'a, 'tcx: 'a> {
 impl<'a, 'tcx> TypeFolder<'tcx> for SubstFolder<'a, 'tcx> {
     fn tcx(&self) -> &TyCtxt<'tcx> { self.tcx }
 
-    fn fold_binder<T: TypeFoldable<'tcx>>(&mut self, t: &ty::Binder<T>) -> ty::Binder<T> {
+    fn enter_region_binder(&mut self) {
         self.region_binders_passed += 1;
-        let t = t.super_fold_with(self);
+    }
+
+    fn exit_region_binder(&mut self) {
         self.region_binders_passed -= 1;
-        t
     }
 
     fn fold_region(&mut self, r: ty::Region) -> ty::Region {

branches/try/src/librustc_resolve/build_reduced_graph.rs

@@ -14,7 +14,8 @@
 //! any imports resolved.
 
 use DefModifiers;
-use resolve_imports::ImportDirectiveSubclass::{self, GlobImport};
+use resolve_imports::ImportDirective;
+use resolve_imports::ImportDirectiveSubclass::{self, SingleImport, GlobImport};
 use Module;
 use Namespace::{self, TypeNS, ValueNS};
 use {NameBinding, NameBindingKind};
@@ -27,7 +28,7 @@ use rustc::middle::def::*;
 use rustc::middle::def_id::{CRATE_DEF_INDEX, DefId};
 use rustc::ty::VariantKind;
 
-use syntax::ast::Name;
+use syntax::ast::{Name, NodeId};
 use syntax::attr::AttrMetaMethods;
 use syntax::parse::token::special_idents;
 use syntax::codemap::{Span, DUMMY_SP};
@@ -151,8 +152,8 @@ impl<'b, 'tcx:'b> Resolver<'b, 'tcx> {
                         }
 
                         let subclass = ImportDirectiveSubclass::single(binding, source_name);
-                        self.unresolved_imports += 1;
-                        parent.add_import_directive(module_path,
+                        self.build_import_directive(parent,
+                                                    module_path,
                                                     subclass,
                                                     view_path.span,
                                                     item.id,
@@ -202,8 +203,8 @@ impl<'b, 'tcx:'b> Resolver<'b, 'tcx> {
                                 }
                             };
                             let subclass = ImportDirectiveSubclass::single(rename, name);
-                            self.unresolved_imports += 1;
-                            parent.add_import_directive(module_path,
+                            self.build_import_directive(parent,
+                                                        module_path,
                                                         subclass,
                                                         source_item.span,
                                                         source_item.node.id(),
@@ -212,8 +213,8 @@ impl<'b, 'tcx:'b> Resolver<'b, 'tcx> {
                         }
                     }
                     ViewPathGlob(_) => {
-                        self.unresolved_imports += 1;
-                        parent.add_import_directive(module_path,
+                        self.build_import_directive(parent,
+                                                    module_path,
                                                     GlobImport,
                                                     view_path.span,
                                                     item.id,
@@ -520,6 +521,39 @@ impl<'b, 'tcx:'b> Resolver<'b, 'tcx> {
         }
     }
 
+    /// Creates and adds an import directive to the given module.
+    fn build_import_directive(&mut self,
+                              module_: Module<'b>,
+                              module_path: Vec<Name>,
+                              subclass: ImportDirectiveSubclass,
+                              span: Span,
+                              id: NodeId,
+                              is_public: bool,
+                              is_prelude: bool) {
+        // Bump the reference count on the name. Or, if this is a glob, set
+        // the appropriate flag.
+
+        match subclass {
+            SingleImport { target, .. } => {
+                module_.increment_outstanding_references_for(target, ValueNS, is_public);
+                module_.increment_outstanding_references_for(target, TypeNS, is_public);
+            }
+            GlobImport if !is_prelude => {
+                // Set the glob flag. This tells us that we don't know the
+                // module's exports ahead of time.
+                module_.inc_glob_count(is_public)
+            }
+            // Prelude imports are not included in the glob counts since they do not get added to
+            // `resolved_globs` -- they are handled separately in `resolve_imports`.
+            GlobImport => {}
+        }
+
+        let directive =
+            ImportDirective::new(module_path, subclass, span, id, is_public, is_prelude);
+        module_.add_import_directive(directive);
+        self.unresolved_imports += 1;
+    }
+
     /// Ensures that the reduced graph rooted at the given external module
     /// is built, building it if it is not.
     pub fn populate_module_if_necessary(&mut self, module: Module<'b>) {

branches/try/src/librustc_resolve/lib.rs

@@ -828,8 +828,8 @@ pub struct ModuleS<'a> {
     // is the NodeId of the local `extern crate` item (otherwise, `extern_crate_id` is None).
     extern_crate_id: Option<NodeId>,
 
-    resolutions: RefCell<HashMap<(Name, Namespace), &'a RefCell<NameResolution<'a>>>>,
-    unresolved_imports: RefCell<Vec<&'a ImportDirective<'a>>>,
+    resolutions: RefCell<HashMap<(Name, Namespace), NameResolution<'a>>>,
+    unresolved_imports: RefCell<Vec<&'a ImportDirective>>,
 
     // The module children of this node, including normal modules and anonymous modules.
     // Anonymous children are pseudo-modules that are implicitly created around items
@@ -849,8 +849,14 @@ pub struct ModuleS<'a> {
 
     prelude: RefCell<Option<Module<'a>>>,
 
-    glob_importers: RefCell<Vec<(Module<'a>, &'a ImportDirective<'a>)>>,
-    globs: RefCell<Vec<&'a ImportDirective<'a>>>,
+    glob_importers: RefCell<Vec<(Module<'a>, &'a ImportDirective)>>,
+    resolved_globs: RefCell<(Vec<Module<'a>> /* public */, Vec<Module<'a>> /* private */)>,
+
+    // The number of public glob imports in this module.
+    public_glob_count: Cell<usize>,
+
+    // The number of private glob imports in this module.
+    private_glob_count: Cell<usize>,
 
     // Whether this module is populated. If not populated, any attempt to
     // access the children must be preceded with a
@@ -878,15 +884,22 @@ impl<'a> ModuleS<'a> {
             module_children: RefCell::new(NodeMap()),
             prelude: RefCell::new(None),
             glob_importers: RefCell::new(Vec::new()),
-            globs: RefCell::new((Vec::new())),
+            resolved_globs: RefCell::new((Vec::new(), Vec::new())),
+            public_glob_count: Cell::new(0),
+            private_glob_count: Cell::new(0),
             populated: Cell::new(!external),
             arenas: arenas
         }
     }
 
+    fn add_import_directive(&self, import_directive: ImportDirective) {
+        let import_directive = self.arenas.alloc_import_directive(import_directive);
+        self.unresolved_imports.borrow_mut().push(import_directive);
+    }
+
     fn for_each_child<F: FnMut(Name, Namespace, &'a NameBinding<'a>)>(&self, mut f: F) {
         for (&(name, ns), name_resolution) in self.resolutions.borrow().iter() {
-            name_resolution.borrow().binding.map(|binding| f(name, ns, binding));
+            name_resolution.binding.map(|binding| f(name, ns, binding));
         }
     }
 
@@ -916,6 +929,11 @@ impl<'a> ModuleS<'a> {
             _ => false,
         }
     }
+
+    fn inc_glob_count(&self, is_public: bool) {
+        let glob_count = if is_public { &self.public_glob_count } else { &self.private_glob_count };
+        glob_count.set(glob_count.get() + 1);
+    }
 }
 
 impl<'a> fmt::Debug for ModuleS<'a> {
@@ -1117,8 +1135,7 @@ pub struct Resolver<'a, 'tcx: 'a> {
 struct ResolverArenas<'a> {
     modules: arena::TypedArena<ModuleS<'a>>,
     name_bindings: arena::TypedArena<NameBinding<'a>>,
-    import_directives: arena::TypedArena<ImportDirective<'a>>,
-    name_resolutions: arena::TypedArena<RefCell<NameResolution<'a>>>,
+    import_directives: arena::TypedArena<ImportDirective>,
 }
 
 impl<'a> ResolverArenas<'a> {
@@ -1128,13 +1145,9 @@ impl<'a> ResolverArenas<'a> {
     fn alloc_name_binding(&'a self, name_binding: NameBinding<'a>) -> &'a NameBinding<'a> {
         self.name_bindings.alloc(name_binding)
     }
-    fn alloc_import_directive(&'a self, import_directive: ImportDirective<'a>)
-                              -> &'a ImportDirective {
+    fn alloc_import_directive(&'a self, import_directive: ImportDirective) -> &'a ImportDirective {
         self.import_directives.alloc(import_directive)
     }
-    fn alloc_name_resolution(&'a self) -> &'a RefCell<NameResolution<'a>> {
-        self.name_resolutions.alloc(Default::default())
-    }
 }
 
 #[derive(PartialEq)]
@@ -1203,7 +1216,6 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
             modules: arena::TypedArena::new(),
             name_bindings: arena::TypedArena::new(),
             import_directives: arena::TypedArena::new(),
-            name_resolutions: arena::TypedArena::new(),
         }
     }