---

yaml
---
r: 274264
b: refs/heads/stable
c: 70d4f26
h: refs/heads/master

Author: SimonSapin

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: c0221c8897db309a79990367476177b1230bb264
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: 43c1a173a874f5513db58b2f5321489a00087484
+refs/heads/stable: 70d4f263ba3d1db40f246ebe600992abb1ac85be
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/src/libcore/iter.rs

@@ -4252,13 +4252,15 @@ impl<A: Step> RangeFrom<A> {
     ///
     /// # Examples
     ///
-    /// ```ignore
-    /// for i in (0u8..).step_by(2) {
+    /// ```
+    /// # #![feature(step_by)]
+    ///
+    /// for i in (0u8..).step_by(2).take(10) {
     ///     println!("{}", i);
     /// }
     /// ```
     ///
-    /// This prints all even `u8` values.
+    /// This prints the first ten even natural integers (0 to 18).
     #[unstable(feature = "step_by", reason = "recent addition",
                issue = "27741")]
     pub fn step_by(self, by: A) -> StepBy<A, Self> {

branches/stable/src/librustc_resolve/lib.rs

@@ -723,7 +723,7 @@ enum FallbackSuggestion {
 }
 
 #[derive(Copy, Clone)]
-enum TypeParameters<'tcx, 'a> {
+enum TypeParameters<'a> {
     NoTypeParameters,
     HasTypeParameters(// Type parameters.
                       &'a Generics,
@@ -733,13 +733,13 @@ enum TypeParameters<'tcx, 'a> {
                       ParamSpace,
 
                       // The kind of the rib used for type parameters.
-                      RibKind<'tcx>),
+                      RibKind),
 }
 
 // The rib kind controls the translation of local
 // definitions (`Def::Local`) to upvars (`Def::Upvar`).
 #[derive(Copy, Clone, Debug)]
-enum RibKind<'a> {
+enum RibKind {
     // No translation needs to be applied.
     NormalRibKind,
 
@@ -758,9 +758,6 @@ enum RibKind<'a> {
 
     // We're in a constant item. Can't refer to dynamic stuff.
     ConstantItemRibKind,
-
-    // We passed through an anonymous module.
-    AnonymousModuleRibKind(Module<'a>),
 }
 
 #[derive(Copy, Clone)]
@@ -802,13 +799,13 @@ enum BareIdentifierPatternResolution {
 
 /// One local scope.
 #[derive(Debug)]
-struct Rib<'a> {
+struct Rib {
     bindings: HashMap<Name, DefLike>,
-    kind: RibKind<'a>,
+    kind: RibKind,
 }
 
-impl<'a> Rib<'a> {
-    fn new(kind: RibKind<'a>) -> Rib<'a> {
+impl Rib {
+    fn new(kind: RibKind) -> Rib {
         Rib {
             bindings: HashMap::new(),
             kind: kind,
@@ -1183,13 +1180,13 @@ pub struct Resolver<'a, 'tcx: 'a> {
 
     // The current set of local scopes, for values.
     // FIXME #4948: Reuse ribs to avoid allocation.
-    value_ribs: Vec<Rib<'a>>,
+    value_ribs: Vec<Rib>,
 
     // The current set of local scopes, for types.
-    type_ribs: Vec<Rib<'a>>,
+    type_ribs: Vec<Rib>,
 
     // The current set of local scopes, for labels.
-    label_ribs: Vec<Rib<'a>>,
+    label_ribs: Vec<Rib>,
 
     // The trait that the current context can refer to.
     current_trait_ref: Option<(DefId, TraitRef)>,
@@ -1307,10 +1304,6 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
         self.arenas.modules.alloc(ModuleS::new(parent_link, def, external, is_public))
     }
 
-    fn get_ribs<'b>(&'b mut self, ns: Namespace) -> &'b mut Vec<Rib<'a>> {
-        match ns { ValueNS => &mut self.value_ribs, TypeNS => &mut self.type_ribs }
-    }
-
     #[inline]
     fn record_import_use(&mut self, import_id: NodeId, name: Name) {
         if !self.make_glob_map {
@@ -2129,7 +2122,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
         }
     }
 
-    fn with_type_parameter_rib<'b, F>(&'b mut self, type_parameters: TypeParameters<'a, 'b>, f: F)
+    fn with_type_parameter_rib<F>(&mut self, type_parameters: TypeParameters, f: F)
         where F: FnOnce(&mut Resolver)
     {
         match type_parameters {
@@ -2198,7 +2191,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
         }
     }
 
-    fn resolve_function(&mut self, rib_kind: RibKind<'a>, declaration: &FnDecl, block: &Block) {
+    fn resolve_function(&mut self, rib_kind: RibKind, declaration: &FnDecl, block: &Block) {
         // Create a value rib for the function.
         self.value_ribs.push(Rib::new(rib_kind));
 
@@ -2501,18 +2494,18 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
 
     fn resolve_block(&mut self, block: &Block) {
         debug!("(resolving block) entering block");
+        self.value_ribs.push(Rib::new(NormalRibKind));
+
         // Move down in the graph, if there's an anonymous module rooted here.
         let orig_module = self.current_module;
-        let anonymous_module =
-            orig_module.anonymous_children.borrow().get(&block.id).map(|module| *module);
-
-        if let Some(anonymous_module) = anonymous_module {
-            debug!("(resolving block) found anonymous module, moving down");
-            self.value_ribs.push(Rib::new(AnonymousModuleRibKind(anonymous_module)));
-            self.type_ribs.push(Rib::new(AnonymousModuleRibKind(anonymous_module)));
-            self.current_module = anonymous_module;
-        } else {
-            self.value_ribs.push(Rib::new(NormalRibKind));
+        match orig_module.anonymous_children.borrow().get(&block.id) {
+            None => {
+                // Nothing to do.
+            }
+            Some(anonymous_module) => {
+                debug!("(resolving block) found anonymous module, moving down");
+                self.current_module = anonymous_module;
+            }
         }
 
         // Check for imports appearing after non-item statements.
@@ -2545,9 +2538,6 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
         if !self.resolved {
             self.current_module = orig_module;
             self.value_ribs.pop();
-            if let Some(_) = anonymous_module {
-                self.type_ribs.pop();
-            }
         }
         debug!("(resolving block) leaving block");
     }
@@ -3086,7 +3076,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
             Def::Local(_, node_id) => {
                 for rib in ribs {
                     match rib.kind {
-                        NormalRibKind | AnonymousModuleRibKind(..) => {
+                        NormalRibKind => {
                             // Nothing to do. Continue.
                         }
                         ClosureRibKind(function_id) => {
@@ -3134,8 +3124,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
             Def::TyParam(..) | Def::SelfTy(..) => {
                 for rib in ribs {
                     match rib.kind {
-                        NormalRibKind | MethodRibKind | ClosureRibKind(..) |
-                        AnonymousModuleRibKind(..) => {
+                        NormalRibKind | MethodRibKind | ClosureRibKind(..) => {
                             // Nothing to do. Continue.
                         }
                         ItemRibKind => {
@@ -3286,10 +3275,13 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                                         namespace: Namespace)
                                         -> Option<LocalDef> {
         // Check the local set of ribs.
-        let name = match namespace { ValueNS => ident.name, TypeNS => ident.unhygienic_name };
+        let (name, ribs) = match namespace {
+            ValueNS => (ident.name, &self.value_ribs),
+            TypeNS => (ident.unhygienic_name, &self.type_ribs),
+        };
 
-        for i in (0 .. self.get_ribs(namespace).len()).rev() {
-            if let Some(def_like) = self.get_ribs(namespace)[i].bindings.get(&name).cloned() {
+        for (i, rib) in ribs.iter().enumerate().rev() {
+            if let Some(def_like) = rib.bindings.get(&name).cloned() {
                 match def_like {
                     DlDef(def) => {
                         debug!("(resolving path in local ribs) resolved `{}` to {:?} at {}",
@@ -3309,18 +3301,6 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                     }
                 }
             }
-
-            if let AnonymousModuleRibKind(module) = self.get_ribs(namespace)[i].kind {
-                if let Success((target, _)) = self.resolve_name_in_module(module,
-                                                                          ident.unhygienic_name,
-                                                                          namespace,
-                                                                          PathSearch,
-                                                                          true) {
-                    if let Some(def) = target.binding.def() {
-                        return Some(LocalDef::from_def(def));
-                    }
-                }
-            }
         }
 
         None