bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity

Rollup merge of #35618 - jseyfried:ast_view_path_refactor, r=eddyb

Browse source 
Refactor `PathListItem`s

This refactors away variant `Mod` of `ast::PathListItemKind` and refactors the remaining variant `Ident` to a struct `ast::PathListItem_`.
This commit is contained in:
Jeffrey Seyfried 2016-08-28 10:31:15 +00:00
commit 37f30173a0
21 changed files with 82 additions and 192 deletions
Download patch file Download diff file Expand all files Collapse all files

14
src/librustc/hir/fold.rs
View file

@ -271,16 +271,10 @@ pub fn noop_fold_view_path<T: Folder>(view_path: P<ViewPath>, fld: &mut T) -> P<
ViewPathList(fld.fold_path(path),
path_list_idents.move_map(|path_list_ident| {
Spanned {
node: match path_list_ident.node {
PathListIdent { id, name, rename } => PathListIdent {
id: fld.new_id(id),
name: name,
rename: rename,
},
PathListMod { id, rename } => PathListMod {
id: fld.new_id(id),
rename: rename,
},
node: PathListItem_ {
id: fld.new_id(path_list_ident.node.id),
name: path_list_ident.node.name,
rename: path_list_ident.node.rename,
},
span: fld.new_span(path_list_ident.span),
}

12
src/librustc/hir/intravisit.rs
View file

@ -444,12 +444,12 @@ 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) {
visitor.visit_id(item.node.id());
walk_opt_name(visitor, item.span, item.node.name());
walk_opt_name(visitor, item.span, item.node.rename());
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,

14
src/librustc/hir/lowering.rs
View file

@ -218,16 +218,10 @@ impl<'a> LoweringContext<'a> {
fn lower_path_list_item(&mut self, path_list_ident: &PathListItem) -> hir::PathListItem {
Spanned {
node: match path_list_ident.node {
PathListItemKind::Ident { id, name, rename } => hir::PathListIdent {
id: id,
name: name.name,
rename: rename.map(|x| x.name),
},
PathListItemKind::Mod { id, rename } => hir::PathListMod {
id: id,
rename: rename.map(|x| x.name),
},
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,
}

2
src/librustc/hir/map/collector.rs
View file

@ -120,7 +120,7 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
match view_path.node {
ViewPathList(_, ref paths) => {
for path in paths {
this.insert(path.node.id(), NodeItem(i));
this.insert(path.node.id, NodeItem(i));
}
}
_ => ()

37
src/librustc/hir/mod.rs
View file

@ -20,7 +20,6 @@ pub use self::FunctionRetTy::*;
pub use self::ForeignItem_::*;
pub use self::Item_::*;
pub use self::Mutability::*;
pub use self::PathListItem_::*;
pub use self::PrimTy::*;
pub use self::Stmt_::*;
pub use self::TraitItem_::*;
@ -1307,39 +1306,11 @@ pub struct Variant_ {
pub type Variant = Spanned<Variant_>;
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
pub enum PathListItem_ {
PathListIdent {
name: Name,
pub struct PathListItem_ {
pub name: Name,
/// renamed in list, eg `use foo::{bar as baz};`
rename: Option<Name>,
id: NodeId,
},
PathListMod {
/// renamed in list, eg `use foo::{self as baz};`
rename: Option<Name>,
id: NodeId,
},
}
impl PathListItem_ {
pub fn id(&self) -> NodeId {
match *self {
PathListIdent { id, .. } | PathListMod { id, .. } => id,
}
}
pub fn name(&self) -> Option<Name> {
match *self {
PathListIdent { name, .. } => Some(name),
PathListMod { .. } => None,
}
}
pub fn rename(&self) -> Option<Name> {
match *self {
PathListIdent { rename, .. } | PathListMod { rename, .. } => rename,
}
}
pub rename: Option<Name>,
pub id: NodeId,
}
pub type PathListItem = Spanned<PathListItem_>;

11
src/librustc/hir/print.rs
View file

@ -2134,16 +2134,7 @@ impl<'a> State<'a> {
self.print_path(path, false, 0)?;
word(&mut self.s, "::{")?;
}
self.commasep(Inconsistent, &segments[..], |s, w| {
match w.node {
hir::PathListIdent { name, .. } => {
s.print_name(name)
}
hir::PathListMod { .. } => {
word(&mut s.s, "self")
}
}
})?;
self.commasep(Inconsistent, &segments[..], |s, w| s.print_name(w.node.name))?;
word(&mut self.s, "}")
}
}

2
src/librustc/middle/dead.rs
View file

@ -294,7 +294,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for MarkSymbolVisitor<'a, 'tcx> {
}
fn visit_path_list_item(&mut self, path: &hir::Path, item: &hir::PathListItem) {
self.lookup_and_handle_definition(item.node.id());
self.lookup_and_handle_definition(item.node.id);
intravisit::walk_path_list_item(self, path, item);
}
}

2
src/librustc/middle/stability.rs
View file

@ -631,7 +631,7 @@ pub fn check_path_list_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
cb: &mut FnMut(DefId, Span,
&Option<&Stability>,
&Option<DeprecationEntry>)) {
match tcx.expect_def(item.node.id()) {
match tcx.expect_def(item.node.id) {
Def::PrimTy(..) => {}
def => {
maybe_do_stability_check(tcx, def.def_id(), item.span, cb);

11
src/librustc_lint/unused.rs
View file

@ -20,6 +20,7 @@ use std::collections::hash_map::Entry::{Occupied, Vacant};
use syntax::ast;
use syntax::attr::{self, AttrMetaMethods};
use syntax::feature_gate::{KNOWN_ATTRIBUTES, AttributeType};
use syntax::parse::token::keywords;
use syntax::ptr::P;
use syntax_pos::Span;
@ -392,13 +393,9 @@ 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 {
if let hir::PathListIdent {ref name, ..} = items[0].node {
let m = format!("braces around {} is unnecessary",
name);
cx.span_lint(UNUSED_IMPORT_BRACES, item.span,
&m[..]);
}
if items.len() == 1 && items[0].node.name != keywords::SelfValue.name() {
let msg = format!("braces around {} is unnecessary", items[0].node.name);
cx.span_lint(UNUSED_IMPORT_BRACES, item.span, &msg);
}
}
}

25
src/librustc_resolve/build_reduced_graph.rs
View file

@ -32,9 +32,9 @@ use syntax::parse::token;
use syntax::ast::{Block, Crate};
use syntax::ast::{ForeignItem, ForeignItemKind, Item, ItemKind};
use syntax::ast::{Mutability, PathListItemKind};
use syntax::ast::{StmtKind, TraitItemKind};
use syntax::ast::{Mutability, StmtKind, TraitItemKind};
use syntax::ast::{Variant, ViewPathGlob, ViewPathList, ViewPathSimple};
use syntax::parse::token::keywords;
use syntax::visit::{self, Visitor};
use syntax_pos::{Span, DUMMY_SP};
@ -130,9 +130,10 @@ impl<'b> Resolver<'b> {
ViewPathList(_, ref source_items) => {
// Make sure there's at most one `mod` import in the list.
let mod_spans = source_items.iter().filter_map(|item| {
match item.node {
PathListItemKind::Mod { .. } => Some(item.span),
_ => None,
if item.node.name.name == keywords::SelfValue.name() {
Some(item.span)
} else {
None
}
}).collect::<Vec<Span>>();
@ -147,10 +148,12 @@ impl<'b> Resolver<'b> {
}
for source_item in source_items {
let (module_path, name, rename) = match source_item.node {
PathListItemKind::Ident { name, rename, .. } =>
(module_path.clone(), name.name, rename.unwrap_or(name).name),
PathListItemKind::Mod { rename, .. } => {
let node = source_item.node;
let (module_path, name, rename) = {
if node.name.name != keywords::SelfValue.name() {
let rename = node.rename.unwrap_or(node.name).name;
(module_path.clone(), node.name.name, rename)
} else {
let name = match module_path.last() {
Some(name) => *name,
None => {
@ -164,12 +167,12 @@ impl<'b> Resolver<'b> {
}
};
let module_path = module_path.split_last().unwrap().1;
let rename = rename.map(|i| i.name).unwrap_or(name);
let rename = node.rename.map(|i| i.name).unwrap_or(name);
(module_path.to_vec(), name, rename)
}
};
let subclass = ImportDirectiveSubclass::single(rename, name);
let (span, id) = (source_item.span, source_item.node.id());
let (span, id) = (source_item.span, source_item.node.id);
self.add_import_directive(module_path, subclass, span, id, vis);
}
}

2
src/librustc_resolve/check_unused.rs
View file

@ -101,7 +101,7 @@ impl<'a, 'b> Visitor for UnusedImportCheckVisitor<'a, 'b> {
ViewPathList(_, ref list) => {
for i in list {
self.check_import(i.node.id(), i.span);
self.check_import(i.node.id, i.span);
}
}
ViewPathGlob(_) => {

13
src/librustc_save_analysis/dump_visitor.rs
View file

@ -1102,18 +1102,11 @@ impl<'l, 'tcx: 'l, 'll, D: Dump +'ll> Visitor for DumpVisitor<'l, 'tcx, 'll, D>
}
ast::ViewPathList(ref path, ref list) => {
for plid in list {
match plid.node {
ast::PathListItemKind::Ident { id, .. } => {
let scope = self.cur_scope;
let id = plid.node.id;
if let Some(def_id) = self.lookup_type_ref(id) {
self.process_def_kind(id,
plid.span,
Some(plid.span),
def_id,
scope);
}
}
ast::PathListItemKind::Mod { .. } => (),
let span = plid.span;
self.process_def_kind(id, span, Some(span), def_id, scope);
}
}

2
src/librustc_typeck/check_unused.rs
View file

@ -49,7 +49,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for UnusedTraitImportVisitor<'a, 'tcx> {
}
hir::ViewPathList(_, ref path_list) => {
for path_item in path_list {
self.check_import(path_item.node.id(), path_item.span);
self.check_import(path_item.node.id, path_item.span);
}
}
}

17
src/librustdoc/clean/mod.rs
View file

@ -2551,7 +2551,7 @@ impl Clean<Vec<Item>> for doctree::Import {
let remaining = if !denied {
let mut remaining = vec![];
for path in list {
match inline::try_inline(cx, path.node.id(), path.node.rename()) {
match inline::try_inline(cx, path.node.id, path.node.rename) {
Some(items) => {
ret.extend(items);
}
@ -2619,17 +2619,10 @@ pub struct ViewListIdent {
impl Clean<ViewListIdent> for hir::PathListItem {
fn clean(&self, cx: &DocContext) -> ViewListIdent {
match self.node {
hir::PathListIdent { id, name, rename } => ViewListIdent {
name: name.clean(cx),
rename: rename.map(|r| r.clean(cx)),
source: resolve_def(cx, id)
},
hir::PathListMod { id, rename } => ViewListIdent {
name: "self".to_string(),
rename: rename.map(|r| r.clean(cx)),
source: resolve_def(cx, id)
}
ViewListIdent {
name: self.node.name.clean(cx),
rename: self.node.rename.map(|r| r.clean(cx)),
source: resolve_def(cx, self.node.id)
}
}
}

2
src/librustdoc/visit_ast.rs
View file

@ -189,7 +189,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
}
hir::ViewPathList(p, paths) => {
let mine = paths.into_iter().filter(|path| {
!self.maybe_inline_local(path.node.id(), path.node.rename(),
!self.maybe_inline_local(path.node.id, path.node.rename,
false, om, please_inline)
}).collect::<hir::HirVec<hir::PathListItem>>();

38
src/libsyntax/ast.rs
View file

@ -1626,42 +1626,14 @@ pub struct Variant_ {
pub type Variant = Spanned<Variant_>;
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
pub enum PathListItemKind {
Ident {
name: Ident,
pub struct PathListItem_ {
pub name: Ident,
/// renamed in list, e.g. `use foo::{bar as baz};`
rename: Option<Ident>,
id: NodeId
},
Mod {
/// renamed in list, e.g. `use foo::{self as baz};`
rename: Option<Ident>,
id: NodeId
}
pub rename: Option<Ident>,
pub id: NodeId,
}
impl PathListItemKind {
pub fn id(&self) -> NodeId {
match *self {
PathListItemKind::Ident { id, .. } | PathListItemKind::Mod { id, .. } => id
}
}
pub fn name(&self) -> Option<Ident> {
match *self {
PathListItemKind::Ident { name, .. } => Some(name),
PathListItemKind::Mod { .. } => None,
}
}
pub fn rename(&self) -> Option<Ident> {
match *self {
PathListItemKind::Ident { rename, .. } | PathListItemKind::Mod { rename, .. } => rename
}
}
}
pub type PathListItem = Spanned<PathListItemKind>;
pub type PathListItem = Spanned<PathListItem_>;
pub type ViewPath = Spanned<ViewPath_>;

2
src/libsyntax/ext/build.rs
View file

@ -1178,7 +1178,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
fn item_use_list(&self, sp: Span, vis: ast::Visibility,
path: Vec<ast::Ident>, imports: &[ast::Ident]) -> P<ast::Item> {
let imports = imports.iter().map(|id| {
let item = ast::PathListItemKind::Ident {
let item = ast::PathListItem_ {
name: *id,
rename: None,
id: ast::DUMMY_NODE_ID,

16
src/libsyntax/fold.rs
View file

@ -307,18 +307,10 @@ pub fn noop_fold_view_path<T: Folder>(view_path: P<ViewPath>, fld: &mut T) -> P<
ViewPathList(fld.fold_path(path),
path_list_idents.move_map(|path_list_ident| {
Spanned {
node: match path_list_ident.node {
PathListItemKind::Ident { id, name, rename } =>
PathListItemKind::Ident {
id: fld.new_id(id),
rename: rename,
name: name
},
PathListItemKind::Mod { id, rename } =>
PathListItemKind::Mod {
id: fld.new_id(id),
rename: rename
}
node: PathListItem_ {
id: fld.new_id(path_list_ident.node.id),
rename: path_list_ident.node.rename,
name: path_list_ident.node.name,
},
span: fld.new_span(path_list_ident.span)
}

13
src/libsyntax/parse/parser.rs
View file

@ -6040,13 +6040,16 @@ impl<'a> Parser<'a> {
&token::CloseDelim(token::Brace),
SeqSep::trailing_allowed(token::Comma), |this| {
let lo = this.span.lo;
let node = if this.eat_keyword(keywords::SelfValue) {
let rename = this.parse_rename()?;
ast::PathListItemKind::Mod { id: ast::DUMMY_NODE_ID, rename: rename }
let ident = if this.eat_keyword(keywords::SelfValue) {
keywords::SelfValue.ident()
} else {
let ident = this.parse_ident()?;
this.parse_ident()?
};
let rename = this.parse_rename()?;
ast::PathListItemKind::Ident { name: ident, rename: rename, id: ast::DUMMY_NODE_ID }
let node = ast::PathListItem_ {
name: ident,
rename: rename,
id: ast::DUMMY_NODE_ID
};
let hi = this.last_span.hi;
Ok(spanned(lo, hi, node))

17
src/libsyntax/print/pprust.rs
View file

@ -2879,26 +2879,13 @@ impl<'a> State<'a> {
try!(word(&mut self.s, "::{"));
}
try!(self.commasep(Inconsistent, &idents[..], |s, w| {
match w.node {
ast::PathListItemKind::Ident { name, rename, .. } => {
try!(s.print_ident(name));
if let Some(ident) = rename {
try!(s.print_ident(w.node.name));
if let Some(ident) = w.node.rename {
try!(space(&mut s.s));
try!(s.word_space("as"));
try!(s.print_ident(ident));
}
Ok(())
},
ast::PathListItemKind::Mod { rename, .. } => {
try!(word(&mut s.s, "self"));
if let Some(ident) = rename {
try!(space(&mut s.s));
try!(s.word_space("as"));
try!(s.print_ident(ident));
}
Ok(())
}
}
}));
word(&mut self.s, "}")
}

4
src/libsyntax/visit.rs
View file

@ -367,8 +367,8 @@ pub fn walk_path<V: Visitor>(visitor: &mut V, path: &Path) {
}
pub fn walk_path_list_item<V: Visitor>(visitor: &mut V, _prefix: &Path, item: &PathListItem) {
walk_opt_ident(visitor, item.span, item.node.name());
walk_opt_ident(visitor, item.span, item.node.rename());
visitor.visit_ident(item.span, item.node.name);
walk_opt_ident(visitor, item.span, item.node.rename);
}
pub fn walk_path_segment<V: Visitor>(visitor: &mut V, path_span: Span, segment: &PathSegment) {