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.

7 files changed, 78 insertions, 89 deletions

diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index ccb25239f6c..9c9560e6dea 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -1003,7 +1003,7 @@ pub enum ViewItem_ {
     // (containing arbitrary characters) from which to fetch the crate sources
     // For example, extern crate whatever = "github.com/mozilla/rust"
     ViewItemExternCrate(Ident, Option<(InternedString,StrStyle)>, NodeId),
-    ViewItemUse(Vec<@ViewPath> ),
+    ViewItemUse(@ViewPath),
 }
 
 // Meta-data associated with an item
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index c80c4dc3a22..cdae6e663b8 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -407,18 +407,16 @@ impl<'a, O: IdVisitingOperation> Visitor<()> for IdVisitor<'a, O> {
             ViewItemExternCrate(_, _, node_id) => {
                 self.operation.visit_id(node_id)
             }
-            ViewItemUse(ref view_paths) => {
-                for view_path in view_paths.iter() {
-                    match view_path.node {
-                        ViewPathSimple(_, _, node_id) |
-                        ViewPathGlob(_, node_id) => {
-                            self.operation.visit_id(node_id)
-                        }
-                        ViewPathList(_, ref paths, node_id) => {
-                            self.operation.visit_id(node_id);
-                            for path in paths.iter() {
-                                self.operation.visit_id(path.node.id)
-                            }
+            ViewItemUse(ref view_path) => {
+                match view_path.node {
+                    ViewPathSimple(_, _, node_id) |
+                    ViewPathGlob(_, node_id) => {
+                        self.operation.visit_id(node_id)
+                    }
+                    ViewPathList(_, ref paths, node_id) => {
+                        self.operation.visit_id(node_id);
+                        for path in paths.iter() {
+                            self.operation.visit_id(path.node.id)
                         }
                     }
                 }
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index 1a160cb33aa..dbf3c75401c 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -246,7 +246,7 @@ pub trait AstBuilder {
                        -> @ast::MetaItem;
 
     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,
                         ident: ast::Ident, path: ast::Path) -> ast::ViewItem;
@@ -949,7 +949,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
     }
 
     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 {
             node: ast::ViewItemUse(vp),
             attrs: Vec::new(),
@@ -966,10 +966,10 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
     fn view_use_simple_(&self, sp: Span, vis: ast::Visibility,
                         ident: ast::Ident, path: ast::Path) -> ast::ViewItem {
         self.view_use(sp, vis,
-                      vec!(@respan(sp,
-                                ast::ViewPathSimple(ident,
-                                                    path,
-                                                    ast::DUMMY_NODE_ID))))
+                      @respan(sp,
+                           ast::ViewPathSimple(ident,
+                                               path,
+                                               ast::DUMMY_NODE_ID)))
     }
 
     fn view_use_list(&self, sp: Span, vis: ast::Visibility,
@@ -979,17 +979,17 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
         }).collect();
 
         self.view_use(sp, vis,
-                      vec!(@respan(sp,
-                                ast::ViewPathList(self.path(sp, path),
-                                                  imports,
-                                                  ast::DUMMY_NODE_ID))))
+                      @respan(sp,
+                           ast::ViewPathList(self.path(sp, path),
+                                             imports,
+                                             ast::DUMMY_NODE_ID)))
     }
 
     fn view_use_glob(&self, sp: Span,
                      vis: ast::Visibility, path: Vec<ast::Ident> ) -> ast::ViewItem {
         self.view_use(sp, vis,
-                      vec!(@respan(sp,
-                                ast::ViewPathGlob(self.path(sp, path), ast::DUMMY_NODE_ID))))
+                      @respan(sp,
+                           ast::ViewPathGlob(self.path(sp, path), ast::DUMMY_NODE_ID)))
     }
 }
 
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index ae82a07601b..a4219d152a9 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -28,44 +28,42 @@ pub trait Folder {
         meta_items.iter().map(|x| fold_meta_item_(*x, self)).collect()
     }
 
-    fn fold_view_paths(&mut self, view_paths: &[@ViewPath]) -> Vec<@ViewPath> {
-        view_paths.iter().map(|view_path| {
-            let inner_view_path = match view_path.node {
-                ViewPathSimple(ref ident, ref path, node_id) => {
-                    let id = self.new_id(node_id);
-                    ViewPathSimple(ident.clone(),
-                                   self.fold_path(path),
-                                   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),
+    fn fold_view_path(&mut self, view_path: @ViewPath) -> @ViewPath {
+        let inner_view_path = match view_path.node {
+            ViewPathSimple(ref ident, ref path, node_id) => {
+                let id = self.new_id(node_id);
+                ViewPathSimple(ident.clone(),
+                               self.fold_path(path),
+                               id)
             }
-        }).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 {
@@ -557,8 +555,8 @@ pub fn noop_fold_view_item<T: Folder>(vi: &ViewItem, folder: &mut T)
                               (*string).clone(),
                               folder.new_id(node_id))
         }
-        ViewItemUse(ref view_paths) => {
-            ViewItemUse(folder.fold_view_paths(view_paths.as_slice()))
+        ViewItemUse(ref view_path) => {
+            ViewItemUse(folder.fold_view_path(*view_path))
         }
     };
     ViewItem {
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 974077956d1..88110a87e6c 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -4918,12 +4918,12 @@ impl<'a> Parser<'a> {
     }
 
     // matches view_paths = view_path | view_path , view_paths
-    fn parse_view_paths(&mut self) -> Vec<@ViewPath> {
-        let mut vp = vec!(self.parse_view_path());
+    fn parse_view_paths(&mut self) -> @ViewPath {
+        let vp = self.parse_view_path();
         while self.token == token::COMMA {
             self.bump();
             self.obsolete(self.last_span, ObsoleteMultipleImport);
-            vp.push(self.parse_view_path());
+            let _ = self.parse_view_path();
         }
         return vp;
     }
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 9d3f7cbc69a..7ea4dcbf28a 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -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<()> {
         try!(self.hardbreak_if_not_bol());
         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.print_view_paths(vps.as_slice()));
+                try!(self.print_view_path(*vp));
             }
         }
         try!(word(&mut self.s, ";"));
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index e830daf8ede..260ba247092 100644
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -150,22 +150,20 @@ pub fn walk_view_item<E: Clone, V: Visitor<E>>(visitor: &mut V, vi: &ViewItem, e
         ViewItemExternCrate(name, _, _) => {
             visitor.visit_ident(vi.span, name, env)
         }
-        ViewItemUse(ref paths) => {
-            for vp in paths.iter() {
-                match vp.node {
-                    ViewPathSimple(ident, ref path, id) => {
-                        visitor.visit_ident(vp.span, ident, env.clone());
-                        visitor.visit_path(path, id, env.clone());
-                    }
-                    ViewPathGlob(ref path, id) => {
-                        visitor.visit_path(path, id, env.clone());
-                    }
-                    ViewPathList(ref path, ref list, _) => {
-                        for id in list.iter() {
-                            visitor.visit_ident(id.span, id.node.name, env.clone())
-                        }
-                        walk_path(visitor, path, env.clone());
+        ViewItemUse(ref vp) => {
+            match vp.node {
+                ViewPathSimple(ident, ref path, id) => {
+                    visitor.visit_ident(vp.span, ident, env.clone());
+                    visitor.visit_path(path, id, env.clone());
+                }
+                ViewPathGlob(ref path, id) => {
+                    visitor.visit_path(path, id, env.clone());
+                }
+                ViewPathList(ref path, ref list, _) => {
+                    for id in list.iter() {
+                        visitor.visit_ident(id.span, id.node.name, env.clone())
                     }
+                    walk_path(visitor, path, env.clone());
                 }
             }
         }