OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

rustc: desugar use a::{b,c}; into use a::b; use a::c; in HIR.

Browse Source
This commit is contained in:
Eduard-Mihai Burtescu 2016-11-24 06:11:31 +02:00
parent 6ebc6d8154
commit bc096549e8
29 changed files with 228 additions and 395 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
src/librustc/hir/intravisit.rs
View File

@ -250,9 +250,6 @@ 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)
}
@ -352,23 +349,9 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
visitor.visit_id(item.id);
walk_opt_name(visitor, item.span, opt_name)
}
ItemUse(ref vp) => {
ItemUse(ref path, _) => {
visitor.visit_id(item.id);
match vp.node {
ViewPathSimple(name, ref path) => {
visitor.visit_name(vp.span, name);
visitor.visit_path(path, item.id);
}
ViewPathGlob(ref path) => {
visitor.visit_path(path, item.id);
}
ViewPathList(ref prefix, ref list) => {
visitor.visit_path(prefix, item.id);
for item in list {
visitor.visit_path_list_item(prefix, item)
}
}
}
visitor.visit_path(path, item.id);
}
ItemStatic(ref typ, _, ref expr) |
ItemConst(ref typ, ref expr) => {
@ -529,14 +512,6 @@ pub fn walk_path<'v, V: Visitor<'v>>(visitor: &mut V, path: &'v Path) {
}
}
pub fn walk_path_list_item<'v, V>(visitor: &mut V, _prefix: &'v Path, item: &'v PathListItem)
where V: Visitor<'v>,
{
visitor.visit_id(item.node.id);
visitor.visit_name(item.span, item.node.name);
walk_opt_name(visitor, item.span, item.node.rename);
}
pub fn walk_path_segment<'v, V: Visitor<'v>>(visitor: &mut V,
path_span: Span,
segment: &'v PathSegment) {

194
src/librustc/hir/lowering.rs
View File

@ -55,6 +55,7 @@ use syntax::ptr::P;
use syntax::codemap::{respan, Spanned};
use syntax::std_inject;
use syntax::symbol::{Symbol, keywords};
use syntax::util::small_vector::SmallVector;
use syntax::visit::{self, Visitor};
use syntax_pos::Span;
@ -67,6 +68,11 @@ pub struct LoweringContext<'a> {
// a definition, then we can properly create the def id.
parent_def: Option<DefIndex>,
resolver: &'a mut Resolver,
/// The items being lowered are collected here.
items: BTreeMap<NodeId, hir::Item>,
impl_items: BTreeMap<hir::ImplItemId, hir::ImplItem>,
}
pub trait Resolver {
@ -98,6 +104,8 @@ pub fn lower_crate(sess: &Session,
sess: sess,
parent_def: None,
resolver: resolver,
items: BTreeMap::new(),
impl_items: BTreeMap::new(),
}.lower_crate(krate)
}
@ -110,41 +118,35 @@ enum ParamMode {
}
impl<'a> LoweringContext<'a> {
fn lower_crate(&mut self, c: &Crate) -> hir::Crate {
fn lower_crate(mut self, c: &Crate) -> hir::Crate {
struct ItemLowerer<'lcx, 'interner: 'lcx> {
items: BTreeMap<NodeId, hir::Item>,
impl_items: BTreeMap<hir::ImplItemId, hir::ImplItem>,
lctx: &'lcx mut LoweringContext<'interner>,
}
impl<'lcx, 'interner> Visitor for ItemLowerer<'lcx, 'interner> {
fn visit_item(&mut self, item: &Item) {
self.items.insert(item.id, self.lctx.lower_item(item));
let hir_item = self.lctx.lower_item(item);
self.lctx.items.insert(item.id, hir_item);
visit::walk_item(self, item);
}
fn visit_impl_item(&mut self, item: &ImplItem) {
let id = self.lctx.lower_impl_item_ref(item).id;
self.impl_items.insert(id, self.lctx.lower_impl_item(item));
let hir_item = self.lctx.lower_impl_item(item);
self.lctx.impl_items.insert(id, hir_item);
visit::walk_impl_item(self, item);
}
}
let (items, impl_items) = {
let mut item_lowerer = ItemLowerer { items: BTreeMap::new(),
impl_items: BTreeMap::new(),
lctx: self };
visit::walk_crate(&mut item_lowerer, c);
(item_lowerer.items, item_lowerer.impl_items)
};
visit::walk_crate(&mut ItemLowerer { lctx: &mut self }, c);
hir::Crate {
module: self.lower_mod(&c.module),
attrs: self.lower_attrs(&c.attrs),
span: c.span,
exported_macros: c.exported_macros.iter().map(|m| self.lower_macro_def(m)).collect(),
items: items,
impl_items: impl_items,
items: self.items,
impl_items: self.impl_items,
}
}
@ -183,38 +185,6 @@ impl<'a> LoweringContext<'a> {
attrs.clone().into()
}
fn lower_view_path(&mut self, view_path: &ViewPath) -> P<hir::ViewPath> {
P(Spanned {
node: match view_path.node {
ViewPathSimple(ident, ref path) => {
hir::ViewPathSimple(ident.name,
self.lower_path(path, ParamMode::Explicit))
}
ViewPathGlob(ref path) => {
hir::ViewPathGlob(self.lower_path(path, ParamMode::Explicit))
}
ViewPathList(ref path, ref path_list_idents) => {
hir::ViewPathList(self.lower_path(path, ParamMode::Explicit),
path_list_idents.iter()
.map(|item| self.lower_path_list_item(item))
.collect())
}
},
span: view_path.span,
})
}
fn lower_path_list_item(&mut self, path_list_ident: &PathListItem) -> hir::PathListItem {
Spanned {
node: hir::PathListItem_ {
id: path_list_ident.node.id,
name: path_list_ident.node.name.name,
rename: path_list_ident.node.rename.map(|rename| rename.name),
},
span: path_list_ident.span,
}
}
fn lower_arm(&mut self, arm: &Arm) -> hir::Arm {
hir::Arm {
attrs: self.lower_attrs(&arm.attrs),
@ -382,19 +352,32 @@ impl<'a> LoweringContext<'a> {
proj_start, p.segments.len())
}
fn lower_path(&mut self,
p: &Path,
param_mode: ParamMode)
-> hir::Path {
fn lower_path_extra(&mut self,
p: &Path,
name: Option<Name>,
param_mode: ParamMode)
-> hir::Path {
hir::Path {
global: p.global,
segments: p.segments.iter().map(|segment| {
self.lower_path_segment(segment, param_mode)
}).collect(),
}).chain(name.map(|name| {
hir::PathSegment {
name: name,
parameters: hir::PathParameters::none()
}
})).collect(),
span: p.span,
}
}
fn lower_path(&mut self,
p: &Path,
param_mode: ParamMode)
-> hir::Path {
self.lower_path_extra(p, None, param_mode)
}
fn lower_path_segment(&mut self,
segment: &PathSegment,
param_mode: ParamMode)
@ -661,12 +644,10 @@ impl<'a> LoweringContext<'a> {
}
fn lower_block(&mut self, b: &Block) -> P<hir::Block> {
let mut stmts = Vec::new();
let mut expr = None;
if let Some((last, rest)) = b.stmts.split_last() {
stmts = rest.iter().map(|s| self.lower_stmt(s)).collect::<Vec<_>>();
let last = self.lower_stmt(last);
let mut stmts = b.stmts.iter().flat_map(|s| self.lower_stmt(s)).collect::<Vec<_>>();
if let Some(last) = stmts.pop() {
if let hir::StmtExpr(e, _) = last.node {
expr = Some(e);
} else {
@ -683,11 +664,65 @@ impl<'a> LoweringContext<'a> {
})
}
fn lower_item_kind(&mut self, i: &ItemKind) -> hir::Item_ {
fn lower_item_kind(&mut self,
name: &mut Name,
attrs: &hir::HirVec<Attribute>,
vis: &mut hir::Visibility,
i: &ItemKind)
-> hir::Item_ {
match *i {
ItemKind::ExternCrate(string) => hir::ItemExternCrate(string),
ItemKind::Use(ref view_path) => {
hir::ItemUse(self.lower_view_path(view_path))
let path = match view_path.node {
ViewPathSimple(_, ref path) => path,
ViewPathGlob(ref path) => path,
ViewPathList(ref path, ref path_list_idents) => {
for &Spanned { node: ref import, span } in path_list_idents {
// `use a::{self as x, b as y};` lowers to
// `use a as x; use a::b as y;`
let mut ident = import.name;
let suffix = if ident.name == keywords::SelfValue.name() {
if let Some(last) = path.segments.last() {
ident = last.identifier;
}
None
} else {
Some(ident.name)
};
let mut path = self.lower_path_extra(path, suffix,
ParamMode::Explicit);
path.span = span;
self.items.insert(import.id, hir::Item {
id: import.id,
name: import.rename.unwrap_or(ident).name,
attrs: attrs.clone(),
node: hir::ItemUse(P(path), hir::UseKind::Single),
vis: vis.clone(),
span: span,
});
}
path
}
};
let path = P(self.lower_path(path, ParamMode::Explicit));
let kind = match view_path.node {
ViewPathSimple(ident, _) => {
*name = ident.name;
hir::UseKind::Single
}
ViewPathGlob(_) => {
hir::UseKind::Glob
}
ViewPathList(..) => {
// Privatize the degenerate import base, used only to check
// the stability of `use a::{};`, to avoid it showing up as
// a reexport by accident when `pub`, e.g. in documentation.
*vis = hir::Inherited;
hir::UseKind::ListStem
}
};
hir::ItemUse(path, kind)
}
ItemKind::Static(ref t, m, ref e) => {
hir::ItemStatic(self.lower_ty(t),
@ -835,7 +870,7 @@ impl<'a> LoweringContext<'a> {
fn lower_mod(&mut self, m: &Mod) -> hir::Mod {
hir::Mod {
inner: m.inner,
item_ids: m.items.iter().map(|x| self.lower_item_id(x)).collect(),
item_ids: m.items.iter().flat_map(|x| self.lower_item_id(x)).collect(),
}
}
@ -851,21 +886,30 @@ impl<'a> LoweringContext<'a> {
}
}
fn lower_item_id(&mut self, i: &Item) -> hir::ItemId {
hir::ItemId { id: i.id }
fn lower_item_id(&mut self, i: &Item) -> SmallVector<hir::ItemId> {
if let ItemKind::Use(ref view_path) = i.node {
if let ViewPathList(_, ref imports) = view_path.node {
return iter::once(i.id).chain(imports.iter().map(|import| import.node.id))
.map(|id| hir::ItemId { id: id }).collect();
}
}
SmallVector::one(hir::ItemId { id: i.id })
}
pub fn lower_item(&mut self, i: &Item) -> hir::Item {
let mut name = i.ident.name;
let attrs = self.lower_attrs(&i.attrs);
let mut vis = self.lower_visibility(&i.vis);
let node = self.with_parent_def(i.id, |this| {
this.lower_item_kind(&i.node)
this.lower_item_kind(&mut name, &attrs, &mut vis, &i.node)
});
hir::Item {
id: i.id,
name: i.ident.name,
attrs: self.lower_attrs(&i.attrs),
name: name,
attrs: attrs,
node: node,
vis: self.lower_visibility(&i.vis),
vis: vis,
span: i.span,
}
}
@ -1701,8 +1745,8 @@ impl<'a> LoweringContext<'a> {
}
}
fn lower_stmt(&mut self, s: &Stmt) -> hir::Stmt {
match s.node {
fn lower_stmt(&mut self, s: &Stmt) -> SmallVector<hir::Stmt> {
SmallVector::one(match s.node {
StmtKind::Local(ref l) => Spanned {
node: hir::StmtDecl(P(Spanned {
node: hir::DeclLocal(self.lower_local(l)),
@ -1710,13 +1754,17 @@ impl<'a> LoweringContext<'a> {
}), s.id),
span: s.span,
},
StmtKind::Item(ref it) => Spanned {
node: hir::StmtDecl(P(Spanned {
node: hir::DeclItem(self.lower_item_id(it)),
StmtKind::Item(ref it) => {
// Can only use the ID once.
let mut id = Some(s.id);
return self.lower_item_id(it).into_iter().map(|item_id| Spanned {
node: hir::StmtDecl(P(Spanned {
node: hir::DeclItem(item_id),
span: s.span,
}), id.take().unwrap_or_else(|| self.next_id())),
span: s.span,
}), s.id),
span: s.span,
},
}).collect();
}
StmtKind::Expr(ref e) => {
Spanned {
node: hir::StmtExpr(P(self.lower_expr(e)), s.id),
@ -1730,7 +1778,7 @@ impl<'a> LoweringContext<'a> {
}
}
StmtKind::Mac(..) => panic!("Shouldn't exist here"),
}
})
}
fn lower_capture_clause(&mut self, c: CaptureBy) -> hir::CaptureClause {

10
src/librustc/hir/map/collector.rs
View File

@ -124,16 +124,6 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
this.insert(struct_def.id(), NodeStructCtor(struct_def));
}
}
ItemUse(ref view_path) => {
match view_path.node {
ViewPathList(_, ref paths) => {
for path in paths {
this.insert(path.node.id, NodeItem(i));
}
}
_ => ()
}
}
_ => {}
}
intravisit::walk_item(this, i);

15
src/librustc/hir/map/def_collector.rs
View File

@ -155,7 +155,20 @@ impl<'a> visit::Visitor for DefCollector<'a> {
DefPathData::ValueNs(i.ident.name.as_str()),
ItemKind::Mac(..) if i.id == DUMMY_NODE_ID => return, // Scope placeholder
ItemKind::Mac(..) => return self.visit_macro_invoc(i.id, false),
ItemKind::Use(..) => DefPathData::Misc,
ItemKind::Use(ref view_path) => {
match view_path.node {
ViewPathGlob(..) => {}
// FIXME(eddyb) Should use the real name. Which namespace?
ViewPathSimple(..) => {}
ViewPathList(_, ref imports) => {
for import in imports {
self.create_def(import.node.id, DefPathData::Misc);
}
}
}
DefPathData::Misc
}
};
let def = self.create_def(i.id, def_data);

12
src/librustc/hir/map/mod.rs
View File

@ -250,16 +250,8 @@ impl<'ast> Map<'ast> {
loop {
match map[id.as_usize()] {
EntryItem(_, item) => {
let def_id = self.local_def_id(item.id);
// NB ^~~~~~~
//
// You would expect that `item.id == id`, but this
// is not always the case. In particular, for a
// ViewPath item like `use self::{mem, foo}`, we
// map the ids for `mem` and `foo` to the
// enclosing view path item. This seems mega super
// ultra wrong, but then who am I to judge?
// -nmatsakis
assert_eq!(id, item.id);
let def_id = self.local_def_id(id);
assert!(!self.is_inlined_def_id(def_id));
return DepNode::Hir(def_id);
}

46
src/librustc/hir/mod.rs
View File

@ -27,7 +27,6 @@ pub use self::Ty_::*;
pub use self::TyParamBound::*;
pub use self::UnOp::*;
pub use self::UnsafeSource::*;
pub use self::ViewPath_::*;
pub use self::Visibility::{Public, Inherited};
pub use self::PathParameters::*;
@ -1385,32 +1384,20 @@ pub struct Variant_ {
pub type Variant = Spanned<Variant_>;
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
pub struct PathListItem_ {
pub name: Name,
/// renamed in list, eg `use foo::{bar as baz};`
pub rename: Option<Name>,
pub id: NodeId,
}
#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub enum UseKind {
/// One import, e.g. `use foo::bar` or `use foo::bar as baz`.
/// Also produced for each element of a list `use`, e.g.
// `use foo::{a, b}` lowers to `use foo::a; use foo::b;`.
Single,
pub type PathListItem = Spanned<PathListItem_>;
/// Glob import, e.g. `use foo::*`.
Glob,
pub type ViewPath = Spanned<ViewPath_>;
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub enum ViewPath_ {
/// `foo::bar::baz as quux`
///
/// or just
///
/// `foo::bar::baz` (with `as baz` implicitly on the right)
ViewPathSimple(Name, Path),
/// `foo::bar::*`
ViewPathGlob(Path),
/// `foo::bar::{a,b,c}`
ViewPathList(Path, HirVec<PathListItem>),
/// Degenerate list import, e.g. `use foo::{a, b}` produces
/// an additional `use foo::{}` for performing checks such as
/// unstable feature gating. May be removed in the future.
ListStem,
}
/// TraitRef's appear in impls.
@ -1544,8 +1531,13 @@ pub enum Item_ {
///
/// e.g. `extern crate foo` or `extern crate foo_bar as foo`
ItemExternCrate(Option<Name>),
/// A `use` or `pub use` item
ItemUse(P<ViewPath>),
/// `use foo::bar::*;` or `use foo::bar::baz as quux;`
///
/// or just
///
/// `use foo::bar::baz;` (with `as baz` implicitly on the right)
ItemUse(P<Path>, UseKind),
/// A `static` item
ItemStatic(P<Ty>, Mutability, P<Expr>),

50
src/librustc/hir/print.rs
View File

@ -669,10 +669,22 @@ impl<'a> State<'a> {
self.end()?; // end inner head-block
self.end()?; // end outer head-block
}
hir::ItemUse(ref vp) => {
hir::ItemUse(ref path, kind) => {
self.head(&visibility_qualified(&item.vis, "use"))?;
self.print_view_path(&vp)?;
word(&mut self.s, ";")?;
self.print_path(path, false)?;
match kind {
hir::UseKind::Single => {
if path.segments.last().unwrap().name != item.name {
space(&mut self.s)?;
self.word_space("as")?;
self.print_name(item.name)?;
}
word(&mut self.s, ";")?;
}
hir::UseKind::Glob => word(&mut self.s, "::*;")?,
hir::UseKind::ListStem => word(&mut self.s, "::{};")?
}
self.end()?; // end inner head-block
self.end()?; // end outer head-block
}
@ -2153,38 +2165,6 @@ impl<'a> State<'a> {
Ok(())
}
pub fn print_view_path(&mut self, vp: &hir::ViewPath) -> io::Result<()> {
match vp.node {
hir::ViewPathSimple(name, ref path) => {
self.print_path(path, false)?;
if path.segments.last().unwrap().name != name {
space(&mut self.s)?;
self.word_space("as")?;
self.print_name(name)?;
}
Ok(())
}
hir::ViewPathGlob(ref path) => {
self.print_path(path, false)?;
word(&mut self.s, "::*")
}
hir::ViewPathList(ref path, ref segments) => {
if path.segments.is_empty() {
word(&mut self.s, "{")?;
} else {
self.print_path(path, false)?;
word(&mut self.s, "::{")?;
}
self.commasep(Inconsistent, &segments[..], |s, w| s.print_name(w.node.name))?;
word(&mut self.s, "}")
}
}
}
pub fn print_mutability(&mut self, mutbl: hir::Mutability) -> io::Result<()> {
match mutbl {
hir::MutMutable => self.word_nbsp("mut"),

5
src/librustc/lint/context.rs
View File

@ -948,11 +948,6 @@ impl<'a, 'tcx> hir_visit::Visitor<'tcx> for LateContext<'a, 'tcx> {
hir_visit::walk_path(self, p);
}
fn visit_path_list_item(&mut self, prefix: &'tcx hir::Path, item: &'tcx 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) {
check_lint_name_attribute(self, attr);
run_lints!(self, check_attribute, late_passes, attr);

1
src/librustc/lint/mod.rs
View File

@ -168,7 +168,6 @@ pub trait LateLintPass: LintPass {
fn check_lifetime(&mut self, _: &LateContext, _: &hir::Lifetime) { }
fn check_lifetime_def(&mut self, _: &LateContext, _: &hir::LifetimeDef) { }
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

5
src/librustc/middle/dead.rs
View File

@ -297,11 +297,6 @@ impl<'a, 'tcx, 'v> Visitor<'v> for MarkSymbolVisitor<'a, 'tcx> {
self.lookup_and_handle_definition(id);
intravisit::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);
intravisit::walk_path_list_item(self, path, item);
}
}
fn has_allow_dead_code_or_lang_attr(attrs: &[ast::Attribute]) -> bool {

2
src/librustc/middle/reachable.rs
View File

@ -265,7 +265,7 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> {
// These are normal, nothing reachable about these
// inherently and their children are already in the
// worklist, as determined by the privacy pass
hir::ItemExternCrate(_) | hir::ItemUse(_) |
hir::ItemExternCrate(_) | hir::ItemUse(..) |
hir::ItemTy(..) | hir::ItemStatic(..) |
hir::ItemMod(..) | hir::ItemForeignMod(..) |
hir::ItemImpl(..) | hir::ItemTrait(..) |

2
src/librustc/middle/resolve_lifetime.rs
View File

@ -151,7 +151,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
intravisit::walk_item(this, item);
}
hir::ItemExternCrate(_) |
hir::ItemUse(_) |
hir::ItemUse(..) |
hir::ItemMod(..) |
hir::ItemDefaultImpl(..) |
hir::ItemForeignMod(..) |

14
src/librustc/middle/stability.rs
View File

@ -474,12 +474,6 @@ impl<'a, 'tcx> Visitor<'tcx> for Checker<'a, 'tcx> {
intravisit::walk_path(self, path)
}
fn visit_path_list_item(&mut self, prefix: &'tcx hir::Path, item: &'tcx hir::PathListItem) {
check_path_list_item(self.tcx, item,
&mut |id, sp, stab, depr| self.check(id, sp, stab, depr));
intravisit::walk_path_list_item(self, prefix, item)
}
fn visit_pat(&mut self, pat: &'tcx hir::Pat) {
check_pat(self.tcx, pat,
&mut |id, sp, stab, depr| self.check(id, sp, stab, depr));
@ -628,14 +622,6 @@ pub fn check_path<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
}
}
pub fn check_path_list_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
item: &hir::PathListItem,
cb: &mut FnMut(DefId, Span,
&Option<&Stability>,
&Option<DeprecationEntry>)) {
maybe_do_stability_check(tcx, tcx.expect_def(item.node.id).def_id(), item.span, cb);
}
pub fn check_pat<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, pat: &hir::Pat,
cb: &mut FnMut(DefId, Span,
&Option<&Stability>,

13
src/librustc_incremental/calculate_svh/svh_visitor.rs
View File

@ -189,7 +189,6 @@ enum SawAbiComponent<'a> {
SawPath(bool),
SawPathSegment,
SawPathParameters,
SawPathListItem,
SawBlock,
SawPat(SawPatComponent),
SawLocal,
@ -357,7 +356,7 @@ fn saw_lit(lit: &ast::Lit) -> SawExprComponent<'static> {
#[derive(Hash)]
enum SawItemComponent {
SawItemExternCrate,
SawItemUse,
SawItemUse(UseKind),
SawItemStatic(Mutability),
SawItemConst,
SawItemFn(Unsafety, Constness, Abi),
@ -375,7 +374,7 @@ enum SawItemComponent {
fn saw_item(node: &Item_) -> SawItemComponent {
match *node {
ItemExternCrate(..) => SawItemExternCrate,
ItemUse(..) => SawItemUse,
ItemUse(_, kind) => SawItemUse(kind),
ItemStatic(_, mutability, _) => SawItemStatic(mutability),
ItemConst(..) =>SawItemConst,
ItemFn(_, unsafety, constness, abi, _, _) => SawItemFn(unsafety, constness, abi),
@ -747,14 +746,6 @@ impl<'a, 'hash, 'tcx> visit::Visitor<'tcx> for StrictVersionHashVisitor<'a, 'has
visit::walk_poly_trait_ref(self, t, m)
}
fn visit_path_list_item(&mut self, prefix: &'tcx Path, item: &'tcx PathListItem) {
debug!("visit_path_list_item: st={:?}", self.st);
SawPathListItem.hash(self.st);
self.hash_discriminant(&item.node);
hash_span!(self, item.span);
visit::walk_path_list_item(self, prefix, item)
}
fn visit_path_segment(&mut self, path_span: Span, path_segment: &'tcx PathSegment) {
debug!("visit_path_segment: st={:?}", self.st);
SawPathSegment.hash(self.st);

8
src/librustc_lint/builtin.rs
View File

@ -704,14 +704,6 @@ impl LateLintPass for Deprecated {
&mut |id, sp, stab, depr| self.lint(cx, id, sp, &stab, &depr));
}
fn check_path_list_item(&mut self, cx: &LateContext, item: &hir::PathListItem) {
stability::check_path_list_item(cx.tcx,
item,
&mut |id, sp, stab, depr| {
self.lint(cx, id, sp, &stab, &depr)
});
}
fn check_pat(&mut self, cx: &LateContext, pat: &hir::Pat) {
stability::check_pat(cx.tcx,
pat,

2
src/librustc_lint/lib.rs
View File

@ -111,6 +111,7 @@ pub fn register_builtins(store: &mut lint::LintStore, sess: Option<&Session>) {
add_early_builtin!(sess,
UnusedParens,
UnusedImportBraces,
);
add_early_builtin_with_new!(sess,
@ -129,7 +130,6 @@ pub fn register_builtins(store: &mut lint::LintStore, sess: Option<&Session>) {
NonCamelCaseTypes,
NonSnakeCase,
NonUpperCaseGlobals,
UnusedImportBraces,
NonShorthandFieldPatterns,
UnusedUnsafe,
UnsafeCode,

10
src/librustc_lint/unused.rs
View File

@ -406,11 +406,11 @@ impl LintPass for UnusedImportBraces {
}
}
impl LateLintPass for UnusedImportBraces {
fn check_item(&mut self, cx: &LateContext, item: &hir::Item) {
if let hir::ItemUse(ref view_path) = item.node {
if let hir::ViewPathList(_, ref items) = view_path.node {
if items.len() == 1 && items[0].node.name != keywords::SelfValue.name() {
impl EarlyLintPass for UnusedImportBraces {
fn check_item(&mut self, cx: &EarlyContext, item: &ast::Item) {
if let ast::ItemKind::Use(ref view_path) = item.node {
if let ast::ViewPathList(_, ref items) = view_path.node {
if items.len() == 1 && items[0].node.name.name != keywords::SelfValue.name() {
let msg = format!("braces around {} is unnecessary", items[0].node.name);
cx.span_lint(UNUSED_IMPORT_BRACES, item.span, &msg);
}

4
src/librustc_metadata/encoder.rs
View File

@ -729,7 +729,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
EntryKind::Trait(self.lazy(&data))
}
hir::ItemExternCrate(_) |
hir::ItemUse(_) => bug!("cannot encode info for item {:?}", item),
hir::ItemUse(..) => bug!("cannot encode info for item {:?}", item),
};
Entry {
@ -982,7 +982,7 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for EncodeVisitor<'a, 'b, 'tcx> {
let def_id = self.index.tcx.map.local_def_id(item.id);
match item.node {
hir::ItemExternCrate(_) |
hir::ItemUse(_) => (), // ignore these
hir::ItemUse(..) => (), // ignore these
_ => self.index.record(def_id, EncodeContext::encode_info_for_item, (def_id, item)),
}
self.index.encode_addl_info_for_item(item);

6
src/librustc_passes/hir_stats.rs
View File

@ -226,12 +226,6 @@ impl<'v> hir_visit::Visitor<'v> for StatCollector<'v> {
self.record("Path", Id::None, path);
hir_visit::walk_path(self, path)
}
fn visit_path_list_item(&mut self,
prefix: &'v hir::Path,
item: &'v hir::PathListItem) {
self.record("PathListItem", Id::Node(item.node.id), item);
hir_visit::walk_path_list_item(self, prefix, item)
}
fn visit_path_segment(&mut self,
path_span: Span,
path_segment: &'v hir::PathSegment) {

13
src/librustc_typeck/check_unused.rs
View File

@ -45,17 +45,8 @@ impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for UnusedTraitImportVisitor<'a, 'tcx> {
if item.vis == hir::Public || item.span == DUMMY_SP {
return;
}
if let hir::ItemUse(ref path) = item.node {
match path.node {
hir::ViewPathSimple(..) | hir::ViewPathGlob(..) => {
self.check_import(item.id, path.span);
}
hir::ViewPathList(_, ref path_list) => {
for path_item in path_list {
self.check_import(path_item.node.id, path_item.span);
}
}
}
if let hir::ItemUse(ref path, _) = item.node {
self.check_import(item.id, path.span);
}
}

2
src/librustc_typeck/collect.rs
View File

@ -696,7 +696,7 @@ fn convert_item(ccx: &CrateCtxt, it: &hir::Item) {
debug!("convert: item {} with id {}", it.name, it.id);
match it.node {
// These don't define types.
hir::ItemExternCrate(_) | hir::ItemUse(_) | hir::ItemMod(_) => {
hir::ItemExternCrate(_) | hir::ItemUse(..) | hir::ItemMod(_) => {
}
hir::ItemForeignMod(ref foreign_mod) => {
for item in &foreign_mod.items {

2
src/librustc_typeck/variance/constraints.rs
View File

@ -104,7 +104,7 @@ impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for ConstraintContext<'a, 'tcx> {
}
hir::ItemExternCrate(_) |
hir::ItemUse(_) |
hir::ItemUse(..) |
hir::ItemStatic(..) |
hir::ItemConst(..) |
hir::ItemFn(..) |

2
src/librustc_typeck/variance/terms.rs
View File

@ -246,7 +246,7 @@ impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for TermsContext<'a, 'tcx> {
}
hir::ItemExternCrate(_) |
hir::ItemUse(_) |
hir::ItemUse(..) |
hir::ItemDefaultImpl(..) |
hir::ItemImpl(..) |
hir::ItemStatic(..) |

72
src/librustdoc/clean/mod.rs
View File

@ -2589,47 +2589,19 @@ impl Clean<Vec<Item>> for doctree::Import {
None => false,
}
});
let (mut ret, inner) = match self.node {
hir::ViewPathGlob(ref p) => {
(vec![], Import::Glob(resolve_use_source(cx, p.clean(cx), self.id)))
}
hir::ViewPathList(ref p, ref list) => {
// Attempt to inline all reexported items, but be sure
// to keep any non-inlineable reexports so they can be
// listed in the documentation.
let mut ret = vec![];
let remaining = if !denied {
let mut remaining = vec![];
for path in list {
match inline::try_inline(cx, path.node.id, path.node.rename) {
Some(items) => {
ret.extend(items);
}
None => {
remaining.push(path.clean(cx));
}
}
}
remaining
} else {
list.clean(cx)
};
if remaining.is_empty() {
return ret;
let path = self.path.clean(cx);
let inner = if self.glob {
Import::Glob(resolve_use_source(cx, path, self.id))
} else {
let name = self.name;
if !denied {
if let Some(items) = inline::try_inline(cx, self.id, Some(name)) {
return items;
}
(ret, Import::List(resolve_use_source(cx, p.clean(cx), self.id), remaining))
}
hir::ViewPathSimple(name, ref p) => {
if !denied {
if let Some(items) = inline::try_inline(cx, self.id, Some(name)) {
return items;
}
}
(vec![], Import::Simple(name.clean(cx),
resolve_use_source(cx, p.clean(cx), self.id)))
}
Import::Simple(name.clean(cx), resolve_use_source(cx, path, self.id))
};
ret.push(Item {
vec![Item {
name: None,
attrs: self.attrs.clean(cx),
source: self.whence.clean(cx),
@ -2638,8 +2610,7 @@ impl Clean<Vec<Item>> for doctree::Import {
stability: None,
deprecation: None,
inner: ImportItem(inner)
});
ret
}]
}
}
@ -2648,9 +2619,7 @@ pub enum Import {
// use source as str;
Simple(String, ImportSource),
// use source::*;
Glob(ImportSource),
// use source::{a, b, c};
List(ImportSource, Vec<ViewListIdent>),
Glob(ImportSource)
}
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
@ -2659,23 +2628,6 @@ pub struct ImportSource {
pub did: Option<DefId>,
}
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub struct ViewListIdent {
pub name: String,
pub rename: Option<String>,
pub source: Option<DefId>,
}
impl Clean<ViewListIdent> for hir::PathListItem {
fn clean(&self, cx: &DocContext) -> ViewListIdent {
ViewListIdent {
name: self.node.name.clean(cx),
rename: self.node.rename.map(|r| r.clean(cx)),
source: resolve_def(cx, self.node.id)
}
}
}
impl Clean<Vec<Item>> for hir::ForeignMod {
fn clean(&self, cx: &DocContext) -> Vec<Item> {
let mut items = self.items.clean(cx);

4
src/librustdoc/doctree.rs
View File

@ -254,10 +254,12 @@ pub struct ExternCrate {
}
pub struct Import {
pub name: Name,
pub id: NodeId,
pub vis: hir::Visibility,
pub attrs: hir::HirVec<ast::Attribute>,
pub node: hir::ViewPath_,
pub path: hir::Path,
pub glob: bool,
pub whence: Span,
}

27
src/librustdoc/html/format.rs
View File

@ -969,16 +969,6 @@ impl fmt::Display for clean::Import {
clean::Import::Glob(ref src) => {
write!(f, "use {}::*;", *src)
}
clean::Import::List(ref src, ref names) => {
write!(f, "use {}::{{", *src)?;
for (i, n) in names.iter().enumerate() {
if i > 0 {
write!(f, ", ")?;
}
write!(f, "{}", *n)?;
}
write!(f, "}};")
}
}
}
}
@ -1000,23 +990,6 @@ impl fmt::Display for clean::ImportSource {
}
}
impl fmt::Display for clean::ViewListIdent {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self.source {
Some(did) => {
let path = clean::Path::singleton(self.name.clone());
resolved_path(f, did, &path, false)?;
}
_ => write!(f, "{}", self.name)?,
}
if let Some(ref name) = self.rename {
write!(f, " as {}", name)?;
}
Ok(())
}
}
impl fmt::Display for clean::TypeBinding {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if f.alternate() {

59
src/librustdoc/visit_ast.rs
View File

@ -225,42 +225,6 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
om
}
fn visit_view_path(&mut self, path: hir::ViewPath_,
om: &mut Module,
id: ast::NodeId,
please_inline: bool) -> Option<hir::ViewPath_> {
match path {
hir::ViewPathSimple(dst, base) => {
if self.maybe_inline_local(id, Some(dst), false, om, please_inline) {
None
} else {
Some(hir::ViewPathSimple(dst, base))
}
}
hir::ViewPathList(p, paths) => {
let mine = paths.into_iter().filter(|path| {
!self.maybe_inline_local(path.node.id, path.node.rename,
false, om, please_inline)
}).collect::<hir::HirVec<hir::PathListItem>>();
if mine.is_empty() {
None
} else {
Some(hir::ViewPathList(p, mine))
}
}
hir::ViewPathGlob(base) => {
if self.maybe_inline_local(id, None, true, om, please_inline) {
None
} else {
Some(hir::ViewPathGlob(base))
}
}
}
}
/// Tries to resolve the target of a `pub use` statement and inlines the
/// target if it is defined locally and would not be documented otherwise,
/// or when it is specifically requested with `please_inline`.
@ -388,11 +352,13 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
whence: item.span,
})
}
hir::ItemUse(ref vpath) => {
let node = vpath.node.clone();
hir::ItemUse(_, hir::UseKind::ListStem) => {}
hir::ItemUse(ref path, kind) => {
let is_glob = kind == hir::UseKind::Glob;
// If there was a private module in the current path then don't bother inlining
// anything as it will probably be stripped anyway.
let node = if item.vis == hir::Public && self.inside_public_path {
if item.vis == hir::Public && self.inside_public_path {
let please_inline = item.attrs.iter().any(|item| {
match item.meta_item_list() {
Some(list) if item.check_name("doc") => {
@ -401,18 +367,19 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
_ => false,
}
});
match self.visit_view_path(node, om, item.id, please_inline) {
None => return,
Some(p) => p
let name = if is_glob { None } else { Some(name) };
if self.maybe_inline_local(item.id, name, is_glob, om, please_inline) {
return;
}
} else {
node
};
}
om.imports.push(Import {
name: item.name,
id: item.id,
vis: item.vis.clone(),
attrs: item.attrs.clone(),
node: node,
path: (**path).clone(),
glob: is_glob,
whence: item.span,
});
}

7
src/test/rustdoc/viewpath-rename.rs
View File

@ -21,8 +21,11 @@ pub enum Maybe<A> {
// @has foo/prelude/index.html
pub mod prelude {
// @has foo/prelude/index.html '//code' 'pub use io::{self as FooIo, Reader as FooReader}'
// @has foo/prelude/index.html '//code' 'pub use io as FooIo;'
// @has foo/prelude/index.html '//code' 'pub use io::Reader as FooReader;'
#[doc(no_inline)] pub use io::{self as FooIo, Reader as FooReader};
// @has foo/prelude/index.html '//code' 'pub use Maybe::{self, Just as MaybeJust, Nothing}'
// @has foo/prelude/index.html '//code' 'pub use Maybe;'
// @has foo/prelude/index.html '//code' 'pub use Maybe::Just as MaybeJust;'
// @has foo/prelude/index.html '//code' 'pub use Maybe::Nothing;'
#[doc(no_inline)] pub use Maybe::{self, Just as MaybeJust, Nothing};
}

7
src/test/rustdoc/viewpath-self.rs
View File

@ -21,8 +21,11 @@ pub enum Maybe<A> {
// @has foo/prelude/index.html
pub mod prelude {
// @has foo/prelude/index.html '//code' 'pub use io::{self, Reader}'
// @has foo/prelude/index.html '//code' 'pub use io;'
// @has foo/prelude/index.html '//code' 'pub use io::Reader;'
#[doc(no_inline)] pub use io::{self, Reader};
// @has foo/prelude/index.html '//code' 'pub use Maybe::{self, Just, Nothing}'
// @has foo/prelude/index.html '//code' 'pub use Maybe;'
// @has foo/prelude/index.html '//code' 'pub use Maybe::Just;'
// @has foo/prelude/index.html '//code' 'pub use Maybe::Nothing;'
#[doc(no_inline)] pub use Maybe::{self, Just, Nothing};
}