Auto merge of #28364 - petrochenkov:usegate, r=alexcrichton

bors · bors · commit e9d2587766a3 · 2015-09-22T01:12:26.000Z
Closes #28075 Closes #28388 r? @eddyb cc @brson
diff --git a/src/liballoc/lib.rs b/src/liballoc/lib.rs
@@ -100,7 +100,7 @@
 #![cfg_attr(stage0, feature(alloc_system))]
 #![cfg_attr(not(stage0), feature(needs_allocator))]
 
-#![cfg_attr(test, feature(test, rustc_private))]
+#![cfg_attr(test, feature(test, rustc_private, box_heap))]
 
 #[cfg(stage0)]
 extern crate alloc_system;
diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs
@@ -38,6 +38,8 @@
 #![feature(core_intrinsics)]
 #![feature(core_slice_ext)]
 #![feature(core_str_ext)]
+#![feature(fmt_internals)]
+#![feature(fmt_radix)]
 #![feature(heap_api)]
 #![feature(iter_order)]
 #![feature(iter_arith)]
@@ -47,6 +49,8 @@
 #![feature(oom)]
 #![feature(pattern)]
 #![feature(ptr_as_ref)]
+#![feature(ref_slice)]
+#![feature(slice_bytes)]
 #![feature(slice_patterns)]
 #![feature(staged_api)]
 #![feature(step_by)]
diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs
@@ -38,6 +38,7 @@ use slice::SliceConcatExt;
 use boxed::Box;
 
 pub use core::str::{FromStr, Utf8Error};
+#[allow(deprecated)]
 pub use core::str::{Lines, LinesAny, CharRange};
 pub use core::str::{Split, RSplit};
 pub use core::str::{SplitN, RSplitN};
diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs
@@ -767,6 +767,11 @@ impl<'a, 'tcx, 'v> hir_visit::Visitor<'v> for LateContext<'a, 'tcx> {
         hir_visit::walk_path(self, p);
     }
 
+    fn visit_path_list_item(&mut self, prefix: &hir::Path, item: &hir::PathListItem) {
+        run_lints!(self, check_path_list_item, late_passes, item);
+        hir_visit::walk_path_list_item(self, prefix, item);
+    }
+
     fn visit_attribute(&mut self, attr: &ast::Attribute) {
         run_lints!(self, check_attribute, late_passes, attr);
     }
@@ -915,6 +920,11 @@ impl<'a, 'v> ast_visit::Visitor<'v> for EarlyContext<'a> {
         ast_visit::walk_path(self, p);
     }
 
+    fn visit_path_list_item(&mut self, prefix: &ast::Path, item: &ast::PathListItem) {
+        run_lints!(self, check_path_list_item, early_passes, item);
+        ast_visit::walk_path_list_item(self, prefix, item);
+    }
+
     fn visit_attribute(&mut self, attr: &ast::Attribute) {
         run_lints!(self, check_attribute, early_passes, attr);
     }
diff --git a/src/librustc/lint/mod.rs b/src/librustc/lint/mod.rs
@@ -161,6 +161,7 @@ pub trait LateLintPass: LintPass {
     fn check_lifetime_def(&mut self, _: &LateContext, _: &hir::LifetimeDef) { }
     fn check_explicit_self(&mut self, _: &LateContext, _: &hir::ExplicitSelf) { }
     fn check_path(&mut self, _: &LateContext, _: &hir::Path, _: ast::NodeId) { }
+    fn check_path_list_item(&mut self, _: &LateContext, _: &hir::PathListItem) { }
     fn check_attribute(&mut self, _: &LateContext, _: &ast::Attribute) { }
 
     /// Called when entering a syntax node that can have lint attributes such
@@ -206,6 +207,7 @@ pub trait EarlyLintPass: LintPass {
     fn check_lifetime_def(&mut self, _: &EarlyContext, _: &ast::LifetimeDef) { }
     fn check_explicit_self(&mut self, _: &EarlyContext, _: &ast::ExplicitSelf) { }
     fn check_path(&mut self, _: &EarlyContext, _: &ast::Path, _: ast::NodeId) { }
+    fn check_path_list_item(&mut self, _: &EarlyContext, _: &ast::PathListItem) { }
     fn check_attribute(&mut self, _: &EarlyContext, _: &ast::Attribute) { }
 
     /// Called when entering a syntax node that can have lint attributes such
diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs
@@ -279,6 +279,11 @@ impl<'a, 'tcx, 'v> Visitor<'v> for MarkSymbolVisitor<'a, 'tcx> {
         visit::walk_path(self, path);
     }
 
+    fn visit_path_list_item(&mut self, path: &hir::Path, item: &hir::PathListItem) {
+        self.lookup_and_handle_definition(&item.node.id());
+        visit::walk_path_list_item(self, path, item);
+    }
+
     fn visit_item(&mut self, _: &hir::Item) {
         // Do not recurse into items. These items will be added to the
         // worklist and recursed into manually if necessary.
diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs
@@ -355,6 +355,12 @@ impl<'a, 'v, 'tcx> Visitor<'v> for Checker<'a, 'tcx> {
         visit::walk_path(self, path)
     }
 
+    fn visit_path_list_item(&mut self, prefix: &hir::Path, item: &hir::PathListItem) {
+        check_path_list_item(self.tcx, item,
+                   &mut |id, sp, stab| self.check(id, sp, stab));
+        visit::walk_path_list_item(self, prefix, item)
+    }
+
     fn visit_pat(&mut self, pat: &hir::Pat) {
         check_pat(self.tcx, pat,
                   &mut |id, sp, stab| self.check(id, sp, stab));
@@ -470,7 +476,17 @@ pub fn check_path(tcx: &ty::ctxt, path: &hir::Path, id: ast::NodeId,
         }
         None => {}
     }
+}
 
+pub fn check_path_list_item(tcx: &ty::ctxt, item: &hir::PathListItem,
+                  cb: &mut FnMut(DefId, Span, &Option<&Stability>)) {
+    match tcx.def_map.borrow().get(&item.node.id()).map(|d| d.full_def()) {
+        Some(def::DefPrimTy(..)) => {}
+        Some(def) => {
+            maybe_do_stability_check(tcx, def.def_id(), item.span, cb);
+        }
+        None => {}
+    }
 }
 
 pub fn check_pat(tcx: &ty::ctxt, pat: &hir::Pat,
diff --git a/src/librustc_back/svh.rs b/src/librustc_back/svh.rs
@@ -423,6 +423,10 @@ mod svh_visitor {
             SawPath.hash(self.st); visit::walk_path(self, path)
         }
 
+        fn visit_path_list_item(&mut self, prefix: &Path, item: &'v PathListItem) {
+            SawPath.hash(self.st); visit::walk_path_list_item(self, prefix, item)
+        }
+
         fn visit_block(&mut self, b: &Block) {
             SawBlock.hash(self.st); visit::walk_block(self, b)
         }
diff --git a/src/librustc_front/visit.rs b/src/librustc_front/visit.rs
@@ -121,6 +121,9 @@ pub trait Visitor<'v> : Sized {
     fn visit_path(&mut self, path: &'v Path, _id: NodeId) {
         walk_path(self, path)
     }
+    fn visit_path_list_item(&mut self, prefix: &'v Path, item: &'v PathListItem) {
+        walk_path_list_item(self, prefix, item)
+    }
     fn visit_path_segment(&mut self, path_span: Span, path_segment: &'v PathSegment) {
         walk_path_segment(self, path_span, path_segment)
     }
@@ -203,26 +206,20 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
         ItemExternCrate(..) => {}
         ItemUse(ref vp) => {
             match vp.node {
-                ViewPathSimple(ident, ref path) => {
-                    visitor.visit_ident(vp.span, ident);
+                ViewPathSimple(_ident, ref path) => {
                     visitor.visit_path(path, item.id);
                 }
                 ViewPathGlob(ref path) => {
                     visitor.visit_path(path, item.id);
                 }
                 ViewPathList(ref prefix, ref list) => {
-                    for id in list {
-                        match id.node {
-                            PathListIdent { name, .. } => {
-                                visitor.visit_ident(id.span, name);
-                            }
-                            PathListMod { .. } => ()
+                    if !list.is_empty() {
+                        for item in list {
+                            visitor.visit_path_list_item(prefix, item)
                         }
+                    } else {
+                        visitor.visit_path(prefix, item.id);
                     }
-
-                    // Note that the `prefix` here is not a complete
-                    // path, so we don't use `visit_path`.
-                    walk_path(visitor, prefix);
                 }
             }
         }
@@ -400,6 +397,17 @@ pub fn walk_path<'v, V: Visitor<'v>>(visitor: &mut V, path: &'v Path) {
     }
 }
 
+pub fn walk_path_list_item<'v, V: Visitor<'v>>(visitor: &mut V, prefix: &'v Path,
+                                               item: &'v PathListItem) {
+    for segment in &prefix.segments {
+        visitor.visit_path_segment(prefix.span, segment);
+    }
+
+    if let PathListIdent { name, .. } = item.node {
+        visitor.visit_ident(item.span, name);
+    }
+}
+
 pub fn walk_path_segment<'v, V: Visitor<'v>>(visitor: &mut V,
                                              path_span: Span,
                                              segment: &'v PathSegment) {
diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs
@@ -1386,6 +1386,13 @@ impl LateLintPass for Stability {
                                           &stab.map(|s| hir_to_ast_stability(s)).as_ref()));
     }
 
+    fn check_path_list_item(&mut self, cx: &LateContext, item: &hir::PathListItem) {
+        stability::check_path_list_item(cx.tcx, item,
+                                         &mut |id, sp, stab|
+                                           self.lint(cx, id, sp,
+                                                &stab.map(|s| hir_to_ast_stability(s)).as_ref()));
+    }
+
     fn check_pat(&mut self, cx: &LateContext, pat: &hir::Pat) {
         stability::check_pat(cx.tcx, pat,
                              &mut |id, sp, stab|
diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs
@@ -859,23 +859,6 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> {
 
 impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> {
     fn visit_item(&mut self, item: &hir::Item) {
-        if let hir::ItemUse(ref vpath) = item.node {
-            if let hir::ViewPathList(ref prefix, ref list) = vpath.node {
-                for pid in list {
-                    match pid.node {
-                        hir::PathListIdent { id, name, .. } => {
-                            debug!("privacy - ident item {}", id);
-                            self.check_path(pid.span, id, name.name);
-                        }
-                        hir::PathListMod { id, .. } => {
-                            debug!("privacy - mod item {}", id);
-                            let name = prefix.segments.last().unwrap().identifier.name;
-                            self.check_path(pid.span, id, name);
-                        }
-                    }
-                }
-            }
-        }
         let orig_curitem = replace(&mut self.curitem, item.id);
         visit::walk_item(self, item);
         self.curitem = orig_curitem;
@@ -997,8 +980,22 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> {
     }
 
     fn visit_path(&mut self, path: &hir::Path, id: ast::NodeId) {
-        self.check_path(path.span, id, path.segments.last().unwrap().identifier.name);
-        visit::walk_path(self, path);
+        if !path.segments.is_empty() {
+            self.check_path(path.span, id, path.segments.last().unwrap().identifier.name);
+            visit::walk_path(self, path);
+        }
+    }
+
+    fn visit_path_list_item(&mut self, prefix: &hir::Path, item: &hir::PathListItem) {
+        let name = if let hir::PathListIdent { name, .. } = item.node {
+            name.name
+        } else if !prefix.segments.is_empty() {
+            prefix.segments.last().unwrap().identifier.name
+        } else {
+            self.tcx.sess.bug("`self` import in an import list with empty prefix");
+        };
+        self.check_path(item.span, item.node.id(), name);
+        visit::walk_path_list_item(self, prefix, item);
     }
 }
 
diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
@@ -2210,23 +2210,39 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
 
             ItemUse(ref view_path) => {
                 // check for imports shadowing primitive types
-                let check_rename = |id, ident: Ident| {
-                    match self.def_map.borrow().get(&id).map(|d| d.full_def()) {
+                let check_rename = |this: &Self, id, ident: Ident| {
+                    match this.def_map.borrow().get(&id).map(|d| d.full_def()) {
                         Some(DefTy(..)) | Some(DefStruct(..)) | Some(DefTrait(..)) | None => {
-                            self.check_if_primitive_type_name(ident.name, item.span);
+                            this.check_if_primitive_type_name(ident.name, item.span);
                         }
                         _ => {}
                     }
                 };
 
                 match view_path.node {
                     hir::ViewPathSimple(ident, _) => {
-                        check_rename(item.id, ident);
+                        check_rename(self, item.id, ident);
                     }
-                    hir::ViewPathList(_, ref items) => {
+                    hir::ViewPathList(ref prefix, ref items) => {
                         for item in items {
                             if let Some(ident) = item.node.rename() {
-                                check_rename(item.node.id(), ident);
+                                check_rename(self, item.node.id(), ident);
+                            }
+                        }
+
+                        // Resolve prefix of an import with empty braces (issue #28388)
+                        if items.is_empty() && !prefix.segments.is_empty() {
+                            match self.resolve_crate_relative_path(prefix.span,
+                                                                   &prefix.segments,
+                                                                   TypeNS) {
+                                Some((def, lp)) => self.record_def(item.id,
+                                                   PathResolution::new(def, lp, 0)),
+                                None => {
+                                    resolve_error(self,
+                                                  prefix.span,
+                                                  ResolutionError::FailedToResolve(
+                                                      &path_names_to_string(prefix, 0)));
+                                }
                             }
                         }
                     }
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
@@ -127,6 +127,9 @@ pub trait Visitor<'v> : Sized {
     fn visit_path(&mut self, path: &'v Path, _id: ast::NodeId) {
         walk_path(self, path)
     }
+    fn visit_path_list_item(&mut self, prefix: &'v Path, item: &'v PathListItem) {
+        walk_path_list_item(self, prefix, item)
+    }
     fn visit_path_segment(&mut self, path_span: Span, path_segment: &'v PathSegment) {
         walk_path_segment(self, path_span, path_segment)
     }
@@ -209,33 +212,20 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
         ItemExternCrate(..) => {}
         ItemUse(ref vp) => {
             match vp.node {
-                ViewPathSimple(ident, ref path) => {
-                    visitor.visit_ident(vp.span, ident);
+                ViewPathSimple(_ident, ref path) => {
                     visitor.visit_path(path, item.id);
                 }
                 ViewPathGlob(ref path) => {
                     visitor.visit_path(path, item.id);
                 }
                 ViewPathList(ref prefix, ref list) => {
-                    for id in list {
-                        match id.node {
-                            PathListIdent { name, rename, .. } => {
-                                visitor.visit_ident(id.span, name);
-                                if let Some(ident) = rename {
-                                    visitor.visit_ident(id.span, ident);
-                                }
-                            }
-                            PathListMod { rename, .. } => {
-                                if let Some(ident) = rename {
-                                    visitor.visit_ident(id.span, ident);
-                                }
-                            }
+                    if !list.is_empty() {
+                        for item in list {
+                            visitor.visit_path_list_item(prefix, item)
                         }
+                    } else {
+                        visitor.visit_path(prefix, item.id);
                     }
-
-                    // Note that the `prefix` here is not a complete
-                    // path, so we don't use `visit_path`.
-                    walk_path(visitor, prefix);
                 }
             }
         }
@@ -417,6 +407,17 @@ pub fn walk_path<'v, V: Visitor<'v>>(visitor: &mut V, path: &'v Path) {
     }
 }
 
+pub fn walk_path_list_item<'v, V: Visitor<'v>>(visitor: &mut V, prefix: &'v Path,
+                                               item: &'v PathListItem) {
+    for segment in &prefix.segments {
+        visitor.visit_path_segment(prefix.span, segment);
+    }
+
+    if let PathListIdent { name, .. } = item.node {
+        visitor.visit_ident(item.span, name);
+    }
+}
+
 pub fn walk_path_segment<'v, V: Visitor<'v>>(visitor: &mut V,
                                              path_span: Span,
                                              segment: &'v PathSegment) {
diff --git a/src/test/compile-fail/issue-28075.rs b/src/test/compile-fail/issue-28075.rs
@@ -0,0 +1,25 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Unstable entities should be caught in import lists
+
+// aux-build:lint_stability.rs
+
+#![allow(unused_imports)]
+
+extern crate lint_stability;
+
+use lint_stability::{unstable, deprecated}; //~ ERROR use of unstable library feature 'test_feature'
+//~^ WARNING use of deprecated item
+
+use lint_stability::unstable::{self as u}; //~ ERROR use of unstable library feature 'test_feature'
+
+fn main() {
+}
diff --git a/src/test/compile-fail/issue-28388-1.rs b/src/test/compile-fail/issue-28388-1.rs
diff --git a/src/test/compile-fail/issue-28388-2.rs b/src/test/compile-fail/issue-28388-2.rs
diff --git a/src/test/compile-fail/issue-28388-3.rs b/src/test/compile-fail/issue-28388-3.rs
diff --git a/src/test/compile-fail/lint-output-format.rs b/src/test/compile-fail/lint-output-format.rs

Original file line number	Diff line number	Diff line change
`@@ -767,6 +767,11 @@ impl<'a, 'tcx, 'v> hir_visit::Visitor<'v> for LateContext<'a, 'tcx> {`
`767`	`767`	`hir_visit::walk_path(self, p);`
`768`	`768`	`}`
`769`	`769`
	`770`	`+ fn visit_path_list_item(&mut self, prefix: &hir::Path, item: &hir::PathListItem) {`
	`771`	`+ run_lints!(self, check_path_list_item, late_passes, item);`
	`772`	`+ hir_visit::walk_path_list_item(self, prefix, item);`
	`773`	`+ }`
	`774`	`+`
`770`	`775`	`fn visit_attribute(&mut self, attr: &ast::Attribute) {`
`771`	`776`	`run_lints!(self, check_attribute, late_passes, attr);`
`772`	`777`	`}`
`@@ -915,6 +920,11 @@ impl<'a, 'v> ast_visit::Visitor<'v> for EarlyContext<'a> {`
`915`	`920`	`ast_visit::walk_path(self, p);`
`916`	`921`	`}`
`917`	`922`
	`923`	`+ fn visit_path_list_item(&mut self, prefix: &ast::Path, item: &ast::PathListItem) {`
	`924`	`+ run_lints!(self, check_path_list_item, early_passes, item);`
	`925`	`+ ast_visit::walk_path_list_item(self, prefix, item);`
	`926`	`+ }`
	`927`	`+`
`918`	`928`	`fn visit_attribute(&mut self, attr: &ast::Attribute) {`
`919`	`929`	`run_lints!(self, check_attribute, early_passes, attr);`
`920`	`930`	`}`
Original file line number	Diff line number	Diff line change
`@@ -423,6 +423,10 @@ mod svh_visitor {`
`423`	`423`	`SawPath.hash(self.st); visit::walk_path(self, path)`
`424`	`424`	`}`
`425`	`425`
	`426`	`+ fn visit_path_list_item(&mut self, prefix: &Path, item: &'v PathListItem) {`
	`427`	`+ SawPath.hash(self.st); visit::walk_path_list_item(self, prefix, item)`
	`428`	`+ }`
	`429`	`+`
`426`	`430`	`fn visit_block(&mut self, b: &Block) {`
`427`	`431`	`SawBlock.hash(self.st); visit::walk_block(self, b)`
`428`	`432`	`}`
Original file line number	Diff line number	Diff line change
`@@ -121,6 +121,9 @@ pub trait Visitor<'v> : Sized {`
`121`	`121`	`fn visit_path(&mut self, path: &'v Path, _id: NodeId) {`
`122`	`122`	`walk_path(self, path)`
`123`	`123`	`}`
	`124`	`+ fn visit_path_list_item(&mut self, prefix: &'v Path, item: &'v PathListItem) {`
	`125`	`+ walk_path_list_item(self, prefix, item)`
	`126`	`+ }`
`124`	`127`	`fn visit_path_segment(&mut self, path_span: Span, path_segment: &'v PathSegment) {`
`125`	`128`	`walk_path_segment(self, path_span, path_segment)`
`126`	`129`	`}`
`@@ -203,26 +206,20 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {`
`203`	`206`	`ItemExternCrate(..) => {}`
`204`	`207`	`ItemUse(ref vp) => {`
`205`	`208`	`match vp.node {`
`206`		`- ViewPathSimple(ident, ref path) => {`
`207`		`- visitor.visit_ident(vp.span, ident);`
	`209`	`+ ViewPathSimple(_ident, ref path) => {`
`208`	`210`	`visitor.visit_path(path, item.id);`
`209`	`211`	`}`
`210`	`212`	`ViewPathGlob(ref path) => {`
`211`	`213`	`visitor.visit_path(path, item.id);`
`212`	`214`	`}`
`213`	`215`	`ViewPathList(ref prefix, ref list) => {`
`214`		`- for id in list {`
`215`		`- match id.node {`
`216`		`- PathListIdent { name, .. } => {`
`217`		`- visitor.visit_ident(id.span, name);`
`218`		`- }`
`219`		`- PathListMod { .. } => ()`
	`216`	`+ if !list.is_empty() {`
	`217`	`+ for item in list {`
	`218`	`+ visitor.visit_path_list_item(prefix, item)`
`220`	`219`	`}`
	`220`	`+ } else {`
	`221`	`+ visitor.visit_path(prefix, item.id);`
`221`	`222`	`}`
`222`		`-`
`223`		- // Note that the `prefix` here is not a complete
`224`		- // path, so we don't use `visit_path`.
`225`		`- walk_path(visitor, prefix);`
`226`	`223`	`}`
`227`	`224`	`}`
`228`	`225`	`}`
`@@ -400,6 +397,17 @@ pub fn walk_path<'v, V: Visitor<'v>>(visitor: &mut V, path: &'v Path) {`
`400`	`397`	`}`
`401`	`398`	`}`
`402`	`399`
	`400`	`+pub fn walk_path_list_item<'v, V: Visitor<'v>>(visitor: &mut V, prefix: &'v Path,`
	`401`	`+ item: &'v PathListItem) {`
	`402`	`+ for segment in &prefix.segments {`
	`403`	`+ visitor.visit_path_segment(prefix.span, segment);`
	`404`	`+ }`
	`405`	`+`
	`406`	`+ if let PathListIdent { name, .. } = item.node {`
	`407`	`+ visitor.visit_ident(item.span, name);`
	`408`	`+ }`
	`409`	`+}`
	`410`	`+`
`403`	`411`	`pub fn walk_path_segment<'v, V: Visitor<'v>>(visitor: &mut V,`
`404`	`412`	`path_span: Span,`
`405`	`413`	`segment: &'v PathSegment) {`