bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Refactor away variant ast::PathListItemKind::Mod

Browse source 
and refactor `ast::PathListItemKind::Ident` -> `ast::PathListItem_`.
This commit is contained in:
Jeffrey Seyfried 2016-08-12 09:01:22 +00:00
parent 1576de0ce6
commit 98ce875b58
10 changed files with 52 additions and 108 deletions
Download patch file Download diff file Expand all files Collapse all files

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 { fn lower_path_list_item(&mut self, path_list_ident: &PathListItem) -> hir::PathListItem {
Spanned { Spanned {
node: match path_list_ident.node { node: hir::PathListIdent {
PathListItemKind::Ident { id, name, rename } => hir::PathListIdent { id: path_list_ident.node.id,
id: id, name: path_list_ident.node.name.name,
name: name.name, rename: path_list_ident.node.rename.map(|rename| rename.name),
rename: rename.map(|x| x.name),
},
PathListItemKind::Mod { id, rename } => hir::PathListMod {
id: id,
rename: rename.map(|x| x.name),
},
}, },
span: path_list_ident.span, span: path_list_ident.span,
} }

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

17
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) => { ast::ViewPathList(ref path, ref list) => {
for plid in list { for plid in list {
match plid.node { let scope = self.cur_scope;
ast::PathListItemKind::Ident { id, .. } => { let id = plid.node.id;
let scope = self.cur_scope; if let Some(def_id) = self.lookup_type_ref(id) {
if let Some(def_id) = self.lookup_type_ref(id) { let span = plid.span;
self.process_def_kind(id, self.process_def_kind(id, span, Some(span), def_id, scope);
plid.span,
Some(plid.span),
def_id,
scope);
}
}
ast::PathListItemKind::Mod { .. } => (),
} }
} }

40
src/libsyntax/ast.rs
View file

@ -1624,42 +1624,14 @@ pub struct Variant_ {
pub type Variant = Spanned<Variant_>; pub type Variant = Spanned<Variant_>;
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
pub enum PathListItemKind { pub struct PathListItem_ {
Ident { pub name: Ident,
name: Ident, /// renamed in list, e.g. `use foo::{bar as baz};`
/// renamed in list, e.g. `use foo::{bar as baz};` pub rename: Option<Ident>,
rename: Option<Ident>, pub id: NodeId,
id: NodeId
},
Mod {
/// renamed in list, e.g. `use foo::{self as baz};`
rename: Option<Ident>,
id: NodeId
}
} }
impl PathListItemKind { pub type PathListItem = Spanned<PathListItem_>;
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 ViewPath = Spanned<ViewPath_>; 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, fn item_use_list(&self, sp: Span, vis: ast::Visibility,
path: Vec<ast::Ident>, imports: &[ast::Ident]) -> P<ast::Item> { path: Vec<ast::Ident>, imports: &[ast::Ident]) -> P<ast::Item> {
let imports = imports.iter().map(|id| { let imports = imports.iter().map(|id| {
let item = ast::PathListItemKind::Ident { let item = ast::PathListItem_ {
name: *id, name: *id,
rename: None, rename: None,
id: ast::DUMMY_NODE_ID, 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), ViewPathList(fld.fold_path(path),
path_list_idents.move_map(|path_list_ident| { path_list_idents.move_map(|path_list_ident| {
Spanned { Spanned {
node: match path_list_ident.node { node: PathListItem_ {
PathListItemKind::Ident { id, name, rename } => id: fld.new_id(path_list_ident.node.id),
PathListItemKind::Ident { rename: path_list_ident.node.rename,
id: fld.new_id(id), name: path_list_ident.node.name,
rename: rename,
name: name
},
PathListItemKind::Mod { id, rename } =>
PathListItemKind::Mod {
id: fld.new_id(id),
rename: rename
}
}, },
span: fld.new_span(path_list_ident.span) span: fld.new_span(path_list_ident.span)
} }

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

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

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

@ -2878,26 +2878,13 @@ impl<'a> State<'a> {
try!(word(&mut self.s, "::{")); try!(word(&mut self.s, "::{"));
} }
try!(self.commasep(Inconsistent, &idents[..], |s, w| { try!(self.commasep(Inconsistent, &idents[..], |s, w| {
match w.node { try!(s.print_ident(w.node.name));
ast::PathListItemKind::Ident { name, rename, .. } => { if let Some(ident) = w.node.rename {
try!(s.print_ident(name)); try!(space(&mut s.s));
if let Some(ident) = rename { try!(s.word_space("as"));
try!(space(&mut s.s)); try!(s.print_ident(ident));
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(())
}
} }
Ok(())
})); }));
word(&mut self.s, "}") 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) { pub fn walk_path_list_item<V: Visitor>(visitor: &mut V, _prefix: &Path, item: &PathListItem) {
walk_opt_ident(visitor, item.span, item.node.name()); visitor.visit_ident(item.span, item.node.name);
walk_opt_ident(visitor, item.span, item.node.rename()); walk_opt_ident(visitor, item.span, item.node.rename);
} }
pub fn walk_path_segment<V: Visitor>(visitor: &mut V, path_span: Span, segment: &PathSegment) { pub fn walk_path_segment<V: Visitor>(visitor: &mut V, path_span: Span, segment: &PathSegment) {