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

syntax: ViewItemUse no longer contains multiple view paths. 

it reflected the obsolete syntax `use a, b, c;` and did not make
past the parser (though it was a non-fatal error so we can continue).
this legacy affected many portions of rustc and rustdoc as well,
so this commit cleans them up altogether.
This commit is contained in:
Kang Seonghoon 2014-04-26 22:33:45 +09:00
parent eea4909a87
commit b03547bac1
15 changed files with 185 additions and 208 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
src/librustc/front/feature_gate.rs
View File

@ -130,16 +130,14 @@ impl<'a> Visitor<()> for Context<'a> {
fn visit_view_item(&mut self, i: &ast::ViewItem, _: ()) { fn visit_view_item(&mut self, i: &ast::ViewItem, _: ()) {
match i.node { match i.node {
ast::ViewItemUse(ref paths) => { ast::ViewItemUse(ref path) => {
for path in paths.iter() { match path.node {
match path.node { ast::ViewPathGlob(..) => {
ast::ViewPathGlob(..) => { self.gate_feature("globs", path.span,
self.gate_feature("globs", path.span, "glob import statements are \
"glob import statements are \ experimental and possibly buggy");
experimental and possibly buggy");
}
_ => {}
} }
_ => {}
} }
} }
ast::ViewItemExternCrate(..) => { ast::ViewItemExternCrate(..) => {

2
src/librustc/front/std_inject.rs
View File

@ -166,7 +166,7 @@ impl<'a> fold::Folder for PreludeInjector<'a> {
let vp = @codemap::dummy_spanned(ast::ViewPathGlob(prelude_path, ast::DUMMY_NODE_ID)); let vp = @codemap::dummy_spanned(ast::ViewPathGlob(prelude_path, ast::DUMMY_NODE_ID));
let vi2 = ast::ViewItem { let vi2 = ast::ViewItem {
node: ast::ViewItemUse(vec!(vp)), node: ast::ViewItemUse(vp),
attrs: Vec::new(), attrs: Vec::new(),
vis: ast::Inherited, vis: ast::Inherited,
span: DUMMY_SP, span: DUMMY_SP,

6
src/librustc/front/test.rs
View File

@ -299,9 +299,9 @@ fn mk_std(cx: &TestCtxt) -> ast::ViewItem {
let id_test = token::str_to_ident("test"); let id_test = token::str_to_ident("test");
let (vi, vis) = if cx.is_test_crate { let (vi, vis) = if cx.is_test_crate {
(ast::ViewItemUse( (ast::ViewItemUse(
vec!(@nospan(ast::ViewPathSimple(id_test, @nospan(ast::ViewPathSimple(id_test,
path_node(vec!(id_test)), path_node(vec!(id_test)),
ast::DUMMY_NODE_ID)))), ast::DUMMY_NODE_ID))),
ast::Public) ast::Public)
} else { } else {
(ast::ViewItemExternCrate(id_test, (ast::ViewItemExternCrate(id_test,

38
src/librustc/middle/privacy.rs
View File

@ -872,26 +872,24 @@ impl<'a> Visitor<()> for PrivacyVisitor<'a> {
fn visit_view_item(&mut self, a: &ast::ViewItem, _: ()) { fn visit_view_item(&mut self, a: &ast::ViewItem, _: ()) {
match a.node { match a.node {
ast::ViewItemExternCrate(..) => {} ast::ViewItemExternCrate(..) => {}
ast::ViewItemUse(ref uses) => { ast::ViewItemUse(ref vpath) => {
for vpath in uses.iter() { match vpath.node {
match vpath.node { ast::ViewPathSimple(..) | ast::ViewPathGlob(..) => {}
ast::ViewPathSimple(..) | ast::ViewPathGlob(..) => {} ast::ViewPathList(_, ref list, _) => {
ast::ViewPathList(_, ref list, _) => { for pid in list.iter() {
for pid in list.iter() { debug!("privacy - list {}", pid.node.id);
debug!("privacy - list {}", pid.node.id); let seg = ast::PathSegment {
let seg = ast::PathSegment { identifier: pid.node.name,
identifier: pid.node.name, lifetimes: Vec::new(),
lifetimes: Vec::new(), types: OwnedSlice::empty(),
types: OwnedSlice::empty(), };
}; let segs = vec!(seg);
let segs = vec!(seg); let path = ast::Path {
let path = ast::Path { global: false,
global: false, span: pid.span,
span: pid.span, segments: segs,
segments: segs, };
}; self.check_path(pid.span, pid.node.id, &path);
self.check_path(pid.span, pid.node.id, &path);
}
} }
} }
} }

142
src/librustc/middle/resolve.rs
View File

@ -1417,72 +1417,70 @@ impl<'a> Resolver<'a> {
fn build_reduced_graph_for_view_item(&mut self, view_item: &ViewItem, fn build_reduced_graph_for_view_item(&mut self, view_item: &ViewItem,
parent: ReducedGraphParent) { parent: ReducedGraphParent) {
match view_item.node { match view_item.node {
ViewItemUse(ref view_paths) => { ViewItemUse(ref view_path) => {
for view_path in view_paths.iter() { // Extract and intern the module part of the path. For
// Extract and intern the module part of the path. For // globs and lists, the path is found directly in the AST;
// globs and lists, the path is found directly in the AST; // for simple paths we have to munge the path a little.
// for simple paths we have to munge the path a little.
let mut module_path = Vec::new(); let mut module_path = Vec::new();
match view_path.node { match view_path.node {
ViewPathSimple(_, ref full_path, _) => { ViewPathSimple(_, ref full_path, _) => {
let path_len = full_path.segments.len(); let path_len = full_path.segments.len();
assert!(path_len != 0); assert!(path_len != 0);
for (i, segment) in full_path.segments for (i, segment) in full_path.segments
.iter() .iter()
.enumerate() { .enumerate() {
if i != path_len - 1 { if i != path_len - 1 {
module_path.push(segment.identifier)
}
}
}
ViewPathGlob(ref module_ident_path, _) |
ViewPathList(ref module_ident_path, _, _) => {
for segment in module_ident_path.segments.iter() {
module_path.push(segment.identifier) module_path.push(segment.identifier)
} }
} }
} }
// Build up the import directives. ViewPathGlob(ref module_ident_path, _) |
let module_ = parent.module(); ViewPathList(ref module_ident_path, _, _) => {
let is_public = view_item.vis == ast::Public; for segment in module_ident_path.segments.iter() {
match view_path.node { module_path.push(segment.identifier)
ViewPathSimple(binding, ref full_path, id) => {
let source_ident =
full_path.segments.last().unwrap().identifier;
let subclass = SingleImport(binding,
source_ident);
self.build_import_directive(&*module_,
module_path,
subclass,
view_path.span,
id,
is_public);
} }
ViewPathList(_, ref source_idents, _) => { }
for source_ident in source_idents.iter() { }
let name = source_ident.node.name;
self.build_import_directive( // Build up the import directives.
&*module_, let module_ = parent.module();
module_path.clone(), let is_public = view_item.vis == ast::Public;
SingleImport(name, name), match view_path.node {
source_ident.span, ViewPathSimple(binding, ref full_path, id) => {
source_ident.node.id, let source_ident =
is_public); full_path.segments.last().unwrap().identifier;
} let subclass = SingleImport(binding,
} source_ident);
ViewPathGlob(_, id) => { self.build_import_directive(&*module_,
self.build_import_directive(&*module_, module_path,
module_path, subclass,
GlobImport, view_path.span,
view_path.span, id,
id, is_public);
is_public); }
ViewPathList(_, ref source_idents, _) => {
for source_ident in source_idents.iter() {
let name = source_ident.node.name;
self.build_import_directive(
&*module_,
module_path.clone(),
SingleImport(name, name),
source_ident.span,
source_ident.node.id,
is_public);
} }
} }
ViewPathGlob(_, id) => {
self.build_import_directive(&*module_,
module_path,
GlobImport,
view_path.span,
id,
is_public);
}
} }
} }
@ -5226,23 +5224,21 @@ impl<'a> Resolver<'a> {
match vi.node { match vi.node {
ViewItemExternCrate(..) => {} // ignore ViewItemExternCrate(..) => {} // ignore
ViewItemUse(ref path) => { ViewItemUse(ref p) => {
for p in path.iter() { match p.node {
match p.node { ViewPathSimple(_, _, id) => self.finalize_import(id, p.span),
ViewPathSimple(_, _, id) => self.finalize_import(id, p.span), ViewPathList(_, ref list, _) => {
ViewPathList(_, ref list, _) => { for i in list.iter() {
for i in list.iter() { self.finalize_import(i.node.id, i.span);
self.finalize_import(i.node.id, i.span); }
} },
}, ViewPathGlob(_, id) => {
ViewPathGlob(_, id) => { if !self.used_imports.contains(&(id, TypeNS)) &&
if !self.used_imports.contains(&(id, TypeNS)) && !self.used_imports.contains(&(id, ValueNS)) {
!self.used_imports.contains(&(id, ValueNS)) { self.session.add_lint(UnusedImports, id, p.span,
self.session.add_lint(UnusedImports, id, p.span, "unused import".to_owned());
"unused import".to_owned()); }
} },
},
}
} }
} }
} }

4
src/librustdoc/clean.rs
View File

@ -1085,7 +1085,7 @@ impl Clean<Item> for ast::ViewItem {
#[deriving(Clone, Encodable, Decodable)] #[deriving(Clone, Encodable, Decodable)]
pub enum ViewItemInner { pub enum ViewItemInner {
ExternCrate(~str, Option<~str>, ast::NodeId), ExternCrate(~str, Option<~str>, ast::NodeId),
Import(Vec<ViewPath>) Import(ViewPath)
} }
impl Clean<ViewItemInner> for ast::ViewItem_ { impl Clean<ViewItemInner> for ast::ViewItem_ {
@ -1099,7 +1099,7 @@ impl Clean<ViewItemInner> for ast::ViewItem_ {
ExternCrate(i.clean(), string, *id) ExternCrate(i.clean(), string, *id)
} }
&ast::ViewItemUse(ref vp) => { &ast::ViewItemUse(ref vp) => {
Import(vp.clean().move_iter().collect()) Import(vp.clean())
} }
} }
} }

10
src/librustdoc/html/render.rs
View File

@ -1165,12 +1165,10 @@ fn item_module(w: &mut Writer, cx: &Context,
try!(write!(w, ";</code></td></tr>")); try!(write!(w, ";</code></td></tr>"));
} }
clean::Import(ref imports) => { clean::Import(ref import) => {
for import in imports.iter() { try!(write!(w, "<tr><td><code>{}{}</code></td></tr>",
try!(write!(w, "<tr><td><code>{}{}</code></td></tr>", VisSpace(myitem.visibility),
VisSpace(myitem.visibility), *import));
*import));
}
} }
} }

8
src/librustdoc/visit_ast.rs
View File

@ -133,14 +133,12 @@ impl<'a> RustdocVisitor<'a> {
return om.view_items.push(item.clone()); return om.view_items.push(item.clone());
} }
let item = match item.node { let item = match item.node {
ast::ViewItemUse(ref paths) => { ast::ViewItemUse(ref vpath) => {
// rustc no longer supports "use foo, bar;" match self.visit_view_path(*vpath, om) {
assert_eq!(paths.len(), 1);
match self.visit_view_path(*paths.get(0), om) {
None => return, None => return,
Some(path) => { Some(path) => {
ast::ViewItem { ast::ViewItem {
node: ast::ViewItemUse(vec!(path)), node: ast::ViewItemUse(path),
.. item.clone() .. item.clone()
} }
} }

2
src/libsyntax/ast.rs
View File

@ -1003,7 +1003,7 @@ pub enum ViewItem_ {
// (containing arbitrary characters) from which to fetch the crate sources // (containing arbitrary characters) from which to fetch the crate sources
// For example, extern crate whatever = "github.com/mozilla/rust" // For example, extern crate whatever = "github.com/mozilla/rust"
ViewItemExternCrate(Ident, Option<(InternedString,StrStyle)>, NodeId), ViewItemExternCrate(Ident, Option<(InternedString,StrStyle)>, NodeId),
ViewItemUse(Vec<@ViewPath> ), ViewItemUse(@ViewPath),
} }
// Meta-data associated with an item // Meta-data associated with an item

22
src/libsyntax/ast_util.rs
View File

@ -407,18 +407,16 @@ impl<'a, O: IdVisitingOperation> Visitor<()> for IdVisitor<'a, O> {
ViewItemExternCrate(_, _, node_id) => { ViewItemExternCrate(_, _, node_id) => {
self.operation.visit_id(node_id) self.operation.visit_id(node_id)
} }
ViewItemUse(ref view_paths) => { ViewItemUse(ref view_path) => {
for view_path in view_paths.iter() { match view_path.node {
match view_path.node { ViewPathSimple(_, _, node_id) |
ViewPathSimple(_, _, node_id) | ViewPathGlob(_, node_id) => {
ViewPathGlob(_, node_id) => { self.operation.visit_id(node_id)
self.operation.visit_id(node_id) }
} ViewPathList(_, ref paths, node_id) => {
ViewPathList(_, ref paths, node_id) => { self.operation.visit_id(node_id);
self.operation.visit_id(node_id); for path in paths.iter() {
for path in paths.iter() { self.operation.visit_id(path.node.id)
self.operation.visit_id(path.node.id)
}
} }
} }
} }

24
src/libsyntax/ext/build.rs
View File

@ -246,7 +246,7 @@ pub trait AstBuilder {
-> @ast::MetaItem; -> @ast::MetaItem;
fn view_use(&self, sp: Span, fn view_use(&self, sp: Span,
vis: ast::Visibility, vp: Vec<@ast::ViewPath> ) -> ast::ViewItem; vis: ast::Visibility, vp: @ast::ViewPath) -> ast::ViewItem;
fn view_use_simple(&self, sp: Span, vis: ast::Visibility, path: ast::Path) -> ast::ViewItem; fn view_use_simple(&self, sp: Span, vis: ast::Visibility, path: ast::Path) -> ast::ViewItem;
fn view_use_simple_(&self, sp: Span, vis: ast::Visibility, fn view_use_simple_(&self, sp: Span, vis: ast::Visibility,
ident: ast::Ident, path: ast::Path) -> ast::ViewItem; ident: ast::Ident, path: ast::Path) -> ast::ViewItem;
@ -949,7 +949,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
} }
fn view_use(&self, sp: Span, fn view_use(&self, sp: Span,
vis: ast::Visibility, vp: Vec<@ast::ViewPath> ) -> ast::ViewItem { vis: ast::Visibility, vp: @ast::ViewPath) -> ast::ViewItem {
ast::ViewItem { ast::ViewItem {
node: ast::ViewItemUse(vp), node: ast::ViewItemUse(vp),
attrs: Vec::new(), attrs: Vec::new(),
@ -966,10 +966,10 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
fn view_use_simple_(&self, sp: Span, vis: ast::Visibility, fn view_use_simple_(&self, sp: Span, vis: ast::Visibility,
ident: ast::Ident, path: ast::Path) -> ast::ViewItem { ident: ast::Ident, path: ast::Path) -> ast::ViewItem {
self.view_use(sp, vis, self.view_use(sp, vis,
vec!(@respan(sp, @respan(sp,
ast::ViewPathSimple(ident, ast::ViewPathSimple(ident,
path, path,
ast::DUMMY_NODE_ID)))) ast::DUMMY_NODE_ID)))
} }
fn view_use_list(&self, sp: Span, vis: ast::Visibility, fn view_use_list(&self, sp: Span, vis: ast::Visibility,
@ -979,17 +979,17 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
}).collect(); }).collect();
self.view_use(sp, vis, self.view_use(sp, vis,
vec!(@respan(sp, @respan(sp,
ast::ViewPathList(self.path(sp, path), ast::ViewPathList(self.path(sp, path),
imports, imports,
ast::DUMMY_NODE_ID)))) ast::DUMMY_NODE_ID)))
} }
fn view_use_glob(&self, sp: Span, fn view_use_glob(&self, sp: Span,
vis: ast::Visibility, path: Vec<ast::Ident> ) -> ast::ViewItem { vis: ast::Visibility, path: Vec<ast::Ident> ) -> ast::ViewItem {
self.view_use(sp, vis, self.view_use(sp, vis,
vec!(@respan(sp, @respan(sp,
ast::ViewPathGlob(self.path(sp, path), ast::DUMMY_NODE_ID)))) ast::ViewPathGlob(self.path(sp, path), ast::DUMMY_NODE_ID)))
} }
} }

76
src/libsyntax/fold.rs
View File

@ -28,44 +28,42 @@ pub trait Folder {
meta_items.iter().map(|x| fold_meta_item_(*x, self)).collect() meta_items.iter().map(|x| fold_meta_item_(*x, self)).collect()
} }
fn fold_view_paths(&mut self, view_paths: &[@ViewPath]) -> Vec<@ViewPath> { fn fold_view_path(&mut self, view_path: @ViewPath) -> @ViewPath {
view_paths.iter().map(|view_path| { let inner_view_path = match view_path.node {
let inner_view_path = match view_path.node { ViewPathSimple(ref ident, ref path, node_id) => {
ViewPathSimple(ref ident, ref path, node_id) => { let id = self.new_id(node_id);
let id = self.new_id(node_id); ViewPathSimple(ident.clone(),
ViewPathSimple(ident.clone(), self.fold_path(path),
self.fold_path(path), id)
id)
}
ViewPathGlob(ref path, node_id) => {
let id = self.new_id(node_id);
ViewPathGlob(self.fold_path(path), id)
}
ViewPathList(ref path, ref path_list_idents, node_id) => {
let id = self.new_id(node_id);
ViewPathList(self.fold_path(path),
path_list_idents.iter().map(|path_list_ident| {
let id = self.new_id(path_list_ident.node
.id);
Spanned {
node: PathListIdent_ {
name: path_list_ident.node
.name
.clone(),
id: id,
},
span: self.new_span(
path_list_ident.span)
}
}).collect(),
id)
}
};
@Spanned {
node: inner_view_path,
span: self.new_span(view_path.span),
} }
}).collect() ViewPathGlob(ref path, node_id) => {
let id = self.new_id(node_id);
ViewPathGlob(self.fold_path(path), id)
}
ViewPathList(ref path, ref path_list_idents, node_id) => {
let id = self.new_id(node_id);
ViewPathList(self.fold_path(path),
path_list_idents.iter().map(|path_list_ident| {
let id = self.new_id(path_list_ident.node
.id);
Spanned {
node: PathListIdent_ {
name: path_list_ident.node
.name
.clone(),
id: id,
},
span: self.new_span(
path_list_ident.span)
}
}).collect(),
id)
}
};
@Spanned {
node: inner_view_path,
span: self.new_span(view_path.span),
}
} }
fn fold_view_item(&mut self, vi: &ViewItem) -> ViewItem { fn fold_view_item(&mut self, vi: &ViewItem) -> ViewItem {
@ -557,8 +555,8 @@ pub fn noop_fold_view_item<T: Folder>(vi: &ViewItem, folder: &mut T)
(*string).clone(), (*string).clone(),
folder.new_id(node_id)) folder.new_id(node_id))
} }
ViewItemUse(ref view_paths) => { ViewItemUse(ref view_path) => {
ViewItemUse(folder.fold_view_paths(view_paths.as_slice())) ViewItemUse(folder.fold_view_path(*view_path))
} }
}; };
ViewItem { ViewItem {

6
src/libsyntax/parse/parser.rs
View File

@ -4918,12 +4918,12 @@ impl<'a> Parser<'a> {
} }
// matches view_paths = view_path | view_path , view_paths // matches view_paths = view_path | view_path , view_paths
fn parse_view_paths(&mut self) -> Vec<@ViewPath> { fn parse_view_paths(&mut self) -> @ViewPath {
let mut vp = vec!(self.parse_view_path()); let vp = self.parse_view_path();
while self.token == token::COMMA { while self.token == token::COMMA {
self.bump(); self.bump();
self.obsolete(self.last_span, ObsoleteMultipleImport); self.obsolete(self.last_span, ObsoleteMultipleImport);
vp.push(self.parse_view_path()); let _ = self.parse_view_path();
} }
return vp; return vp;
} }

9
src/libsyntax/print/pprust.rs
View File

@ -1995,11 +1995,6 @@ impl<'a> State<'a> {
} }
} }
pub fn print_view_paths(&mut self,
vps: &[@ast::ViewPath]) -> IoResult<()> {
self.commasep(Inconsistent, vps, |s, &vp| s.print_view_path(vp))
}
pub fn print_view_item(&mut self, item: &ast::ViewItem) -> IoResult<()> { pub fn print_view_item(&mut self, item: &ast::ViewItem) -> IoResult<()> {
try!(self.hardbreak_if_not_bol()); try!(self.hardbreak_if_not_bol());
try!(self.maybe_print_comment(item.span.lo)); try!(self.maybe_print_comment(item.span.lo));
@ -2017,9 +2012,9 @@ impl<'a> State<'a> {
} }
} }
ast::ViewItemUse(ref vps) => { ast::ViewItemUse(ref vp) => {
try!(self.head("use")); try!(self.head("use"));
try!(self.print_view_paths(vps.as_slice())); try!(self.print_view_path(*vp));
} }
} }
try!(word(&mut self.s, ";")); try!(word(&mut self.s, ";"));

28
src/libsyntax/visit.rs
View File

@ -150,22 +150,20 @@ pub fn walk_view_item<E: Clone, V: Visitor<E>>(visitor: &mut V, vi: &ViewItem, e
ViewItemExternCrate(name, _, _) => { ViewItemExternCrate(name, _, _) => {
visitor.visit_ident(vi.span, name, env) visitor.visit_ident(vi.span, name, env)
} }
ViewItemUse(ref paths) => { ViewItemUse(ref vp) => {
for vp in paths.iter() { match vp.node {
match vp.node { ViewPathSimple(ident, ref path, id) => {
ViewPathSimple(ident, ref path, id) => { visitor.visit_ident(vp.span, ident, env.clone());
visitor.visit_ident(vp.span, ident, env.clone()); visitor.visit_path(path, id, env.clone());
visitor.visit_path(path, id, env.clone()); }
} ViewPathGlob(ref path, id) => {
ViewPathGlob(ref path, id) => { visitor.visit_path(path, id, env.clone());
visitor.visit_path(path, id, env.clone()); }
} ViewPathList(ref path, ref list, _) => {
ViewPathList(ref path, ref list, _) => { for id in list.iter() {
for id in list.iter() { visitor.visit_ident(id.span, id.node.name, env.clone())
visitor.visit_ident(id.span, id.node.name, env.clone())
}
walk_path(visitor, path, env.clone());
} }
walk_path(visitor, path, env.clone());
} }
} }
} }