syntax: Clean out obsolete syntax parsing

All of these features have been obsolete since February 2014, where most have
been obsolete since 2013. There shouldn't be any more need to keep around the
parser hacks after this length of time.

src/librustc/middle/privacy.rs

@@ -1094,7 +1094,10 @@ impl<'a> SanePrivacyVisitor<'a> {
                             check_inherited(m.span, m.vis,
                                             "unnecessary visibility");
                         }
-                        ast::Required(..) => {}
+                        ast::Required(ref m) => {
+                            check_inherited(m.span, m.vis,
+                                            "unnecessary visibility");
+                        }
                     }
                 }
             }

src/librustdoc/html/highlight.rs

@@ -102,7 +102,7 @@ fn doit(sess: &parse::ParseSess, mut lexer: lexer::StringReader, class: Option<&
 
             // miscellaneous, no highlighting
             t::DOT | t::DOTDOT | t::DOTDOTDOT | t::COMMA | t::SEMI |
-                t::COLON | t::MOD_SEP | t::LARROW | t::DARROW | t::LPAREN |
+                t::COLON | t::MOD_SEP | t::LARROW | t::LPAREN |
                 t::RPAREN | t::LBRACKET | t::LBRACE | t::RBRACE => "",
             t::DOLLAR => {
                 if t::is_ident(&lexer.peek().tok) {

src/libsyntax/ast.rs

@@ -689,6 +689,7 @@ pub struct TypeMethod {
     pub explicit_self: ExplicitSelf,
     pub id: NodeId,
     pub span: Span,
+    pub vis: Visibility,
 }
 
 // A trait method is either required (meaning it doesn't have an

src/libsyntax/ast_util.rs

@@ -305,6 +305,7 @@ pub fn trait_method_to_ty_method(method: &TraitMethod) -> TypeMethod {
                 explicit_self: m.explicit_self,
                 id: m.id,
                 span: m.span,
+                vis: m.vis,
             }
         }
     }

src/libsyntax/ext/quote.rs

@@ -543,7 +543,6 @@ fn mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> @ast::Expr {
         MOD_SEP => "MOD_SEP",
         RARROW => "RARROW",
         LARROW => "LARROW",
-        DARROW => "DARROW",
         FAT_ARROW => "FAT_ARROW",
         LPAREN => "LPAREN",
         RPAREN => "RPAREN",

src/libsyntax/fold.rs

@@ -648,6 +648,7 @@ pub fn noop_fold_type_method<T: Folder>(m: &TypeMethod, fld: &mut T) -> TypeMeth
         generics: fold_generics(&m.generics, fld),
         explicit_self: fld.fold_explicit_self(&m.explicit_self),
         span: fld.new_span(m.span),
+        vis: m.vis,
     }
 }
 

src/libsyntax/parse/lexer.rs

@@ -790,10 +790,7 @@ fn next_token_inner(rdr: &mut StringReader) -> token::Token {
           '<' => { return binop(rdr, token::SHL); }
           '-' => {
             bump(rdr);
-            match rdr.curr.unwrap_or('\x00') {
+            return token::LARROW;
-              '>' => { bump(rdr); return token::DARROW; }
-              _ => { return token::LARROW; }
-            }
           }
           _ => { return token::LT; }
         }

src/libsyntax/parse/obsolete.rs

@@ -25,21 +25,6 @@ use parse::token;
 /// The specific types of unsupported syntax
 #[deriving(Eq, TotalEq, Hash)]
 pub enum ObsoleteSyntax {
-    ObsoleteSwap,
-    ObsoleteUnsafeBlock,
-    ObsoleteBareFnType,
-    ObsoleteMultipleLocalDecl,
-    ObsoleteUnsafeExternFn,
-    ObsoleteTraitFuncVisibility,
-    ObsoleteConstPointer,
-    ObsoleteLoopAsContinue,
-    ObsoleteEnumWildcard,
-    ObsoleteStructWildcard,
-    ObsoleteVecDotDotWildcard,
-    ObsoleteMultipleImport,
-    ObsoleteManagedPattern,
-    ObsoleteManagedString,
-    ObsoleteManagedVec,
     ObsoleteOwnedType,
     ObsoleteOwnedExpr,
     ObsoleteOwnedPattern,
@@ -64,71 +49,6 @@ impl<'a> ParserObsoleteMethods for Parser<'a> {
     /// Reports an obsolete syntax non-fatal error.
     fn obsolete(&mut self, sp: Span, kind: ObsoleteSyntax) {
         let (kind_str, desc) = match kind {
-            ObsoleteSwap => (
-                "swap",
-                "use std::mem::{swap, replace} instead"
-            ),
-            ObsoleteUnsafeBlock => (
-                "non-standalone unsafe block",
-                "use an inner `unsafe { ... }` block instead"
-            ),
-            ObsoleteBareFnType => (
-                "bare function type",
-                "use `|A| -> B` or `extern fn(A) -> B` instead"
-            ),
-            ObsoleteMultipleLocalDecl => (
-                "declaration of multiple locals at once",
-                "instead of e.g. `let a = 1, b = 2`, write \
-                 `let (a, b) = (1, 2)`."
-            ),
-            ObsoleteUnsafeExternFn => (
-                "unsafe external function",
-                "external functions are always unsafe; remove the `unsafe` \
-                 keyword"
-            ),
-            ObsoleteTraitFuncVisibility => (
-                "visibility not necessary",
-                "trait functions inherit the visibility of the trait itself"
-            ),
-            ObsoleteConstPointer => (
-                "const pointer",
-                "instead of `&const Foo` or `@const Foo`, write `&Foo` or \
-                 `@Foo`"
-            ),
-            ObsoleteLoopAsContinue => (
-                "`loop` instead of `continue`",
-                "`loop` is now only used for loops and `continue` is used for \
-                 skipping iterations"
-            ),
-            ObsoleteEnumWildcard => (
-                "enum wildcard",
-                "use `..` instead of `*` for matching all enum fields"
-            ),
-            ObsoleteStructWildcard => (
-                "struct wildcard",
-                "use `..` instead of `_` for matching trailing struct fields"
-            ),
-            ObsoleteVecDotDotWildcard => (
-                "vec slice wildcard",
-                "use `..` instead of `.._` for matching slices"
-            ),
-            ObsoleteMultipleImport => (
-                "multiple imports",
-                "only one import is allowed per `use` statement"
-            ),
-            ObsoleteManagedPattern => (
-                "managed pointer pattern",
-                "use a nested `match` expression instead of a managed box \
-                 pattern"
-            ),
-            ObsoleteManagedString => (
-                "managed string",
-                "use `Rc<StrBuf>` instead of a managed string"
-            ),
-            ObsoleteManagedVec => (
-                "managed vector",
-                "use `Rc<~[T]>` instead of a managed vector"
-            ),
             ObsoleteOwnedType => (
                 "`~` notation for owned pointers",
                 "use `Box<T>` in `std::owned` instead"

src/libsyntax/parse/parser.rs

@@ -1129,11 +1129,10 @@ impl<'a> Parser<'a> {
             let attrs = p.parse_outer_attributes();
             let lo = p.span.lo;
 
-            let vis_span = p.span;
-            let vis = p.parse_visibility();
-            let style = p.parse_fn_style();
             // NB: at the moment, trait methods are public by default; this
             // could change.
+            let vis = p.parse_visibility();
+            let style = p.parse_fn_style();
             let ident = p.parse_ident();
 
             let generics = p.parse_generics();
@@ -1149,11 +1148,6 @@ impl<'a> Parser<'a> {
               token::SEMI => {
                 p.bump();
                 debug!("parse_trait_methods(): parsing required method");
-                // NB: at the moment, visibility annotations on required
-                // methods are ignored; this could change.
-                if vis != ast::Inherited {
-                    p.obsolete(vis_span, ObsoleteTraitFuncVisibility);
-                }
                 Required(TypeMethod {
                     ident: ident,
                     attrs: attrs,
@@ -1162,7 +1156,8 @@ impl<'a> Parser<'a> {
                     generics: generics,
                     explicit_self: explicit_self,
                     id: ast::DUMMY_NODE_ID,
-                    span: mk_sp(lo, hi)
+                    span: mk_sp(lo, hi),
+                    vis: vis,
                 })
               }
               token::LBRACE => {
@@ -1682,9 +1677,6 @@ impl<'a> Parser<'a> {
     pub fn parse_mutability(&mut self) -> Mutability {
         if self.eat_keyword(keywords::Mut) {
             MutMutable
-        } else if self.eat_keyword(keywords::Const) {
-            self.obsolete(self.last_span, ObsoleteConstPointer);
-            MutImmutable
         } else {
             MutImmutable
         }
@@ -2309,20 +2301,7 @@ impl<'a> Parser<'a> {
             let e = self.parse_prefix_expr();
             hi = e.span.hi;
             // HACK: pretending @[] is a (removed) @-vec
-            ex = match e.node {
+            ex = self.mk_unary(UnBox, e);
-              ExprVec(..) |
-              ExprRepeat(..) => {
-                  self.obsolete(e.span, ObsoleteManagedVec);
-                  // the above error means that no-one will know we're
-                  // lying... hopefully.
-                  ExprVstore(e, ExprVstoreUniq)
-              }
-              ExprLit(lit) if lit_is_str(lit) => {
-                  self.obsolete(self.last_span, ObsoleteManagedString);
-                  ExprVstore(e, ExprVstoreUniq)
-              }
-              _ => self.mk_unary(UnBox, e)
-            };
           }
           token::TILDE => {
             self.bump();
@@ -2460,13 +2439,6 @@ impl<'a> Parser<'a> {
               let assign_op = self.mk_assign_op(aop, lhs, rhs);
               self.mk_expr(lo, rhs.span.hi, assign_op)
           }
-          token::DARROW => {
-            self.obsolete(self.span, ObsoleteSwap);
-            self.bump();
-            // Ignore what we get, this is an error anyway
-            self.parse_expr();
-            self.mk_expr(lo, self.span.hi, ExprBreak(None))
-          }
           _ => {
               lhs
           }
@@ -2577,37 +2549,10 @@ impl<'a> Parser<'a> {
     }
 
     pub fn parse_loop_expr(&mut self, opt_ident: Option<ast::Ident>) -> @Expr {
-        // loop headers look like 'loop {' or 'loop unsafe {'
-        let is_loop_header =
-            self.token == token::LBRACE
-            || (is_ident(&self.token)
-                && self.look_ahead(1, |t| *t == token::LBRACE));
-
-        if is_loop_header {
-            // This is a loop body
         let lo = self.last_span.lo;
         let body = self.parse_block();
         let hi = body.span.hi;
-            return self.mk_expr(lo, hi, ExprLoop(body, opt_ident));
+        self.mk_expr(lo, hi, ExprLoop(body, opt_ident))
-        } else {
-            // This is an obsolete 'continue' expression
-            if opt_ident.is_some() {
-                self.span_err(self.last_span,
-                              "a label may not be used with a `loop` expression");
-            }
-
-            self.obsolete(self.last_span, ObsoleteLoopAsContinue);
-            let lo = self.span.lo;
-            let ex = if Parser::token_is_lifetime(&self.token) {
-                let lifetime = self.get_lifetime();
-                self.bump();
-                ExprAgain(Some(lifetime))
-            } else {
-                ExprAgain(None)
-            };
-            let hi = self.span.hi;
-            return self.mk_expr(lo, hi, ex);
-        }
     }
 
     // For distingishing between struct literals and blocks
@@ -2721,14 +2666,6 @@ impl<'a> Parser<'a> {
                 } else {
                     let subpat = self.parse_pat();
                     match *subpat {
-                        ast::Pat { id, node: PatWild, span } => {
-                            self.obsolete(self.span, ObsoleteVecDotDotWildcard);
-                            slice = Some(@ast::Pat {
-                                id: id,
-                                node: PatWildMulti,
-                                span: span
-                            })
-                        },
                         ast::Pat { node: PatIdent(_, _, _), .. } => {
                             slice = Some(subpat);
                         }
@@ -2764,11 +2701,7 @@ impl<'a> Parser<'a> {
                 if self.token == token::RBRACE { break }
             }
 
-            etc = self.token == token::UNDERSCORE || self.token == token::DOTDOT;
+            if self.token == token::DOTDOT {
-            if self.token == token::UNDERSCORE {
-                self.obsolete(self.span, ObsoleteStructWildcard);
-            }
-            if etc {
                 self.bump();
                 if self.token != token::RBRACE {
                     let token_str = self.this_token_to_str();
@@ -2833,18 +2766,6 @@ impl<'a> Parser<'a> {
                 span: mk_sp(lo, hi)
             }
           }
-          // parse @pat
-          token::AT => {
-            self.bump();
-            let sub = self.parse_pat();
-            self.obsolete(self.span, ObsoleteManagedPattern);
-            let hi = self.last_span.hi;
-            return @ast::Pat {
-                id: ast::DUMMY_NODE_ID,
-                node: PatUniq(sub),
-                span: mk_sp(lo, hi)
-            }
-          }
           token::TILDE => {
             // parse ~pat
             self.bump();
@@ -3001,24 +2922,15 @@ impl<'a> Parser<'a> {
                         let mut args: Vec<@Pat> = Vec::new();
                         match self.token {
                           token::LPAREN => {
-                            let is_star = self.look_ahead(1, |t| {
-                                match *t {
-                                    token::BINOP(token::STAR) => true,
-                                    _ => false,
-                                }
-                            });
                             let is_dotdot = self.look_ahead(1, |t| {
                                 match *t {
                                     token::DOTDOT => true,
                                     _ => false,
                                 }
                             });
-                            if is_star | is_dotdot {
+                            if is_dotdot {
                                 // This is a "top constructor only" pat
                                 self.bump();
-                                if is_star {
-                                    self.obsolete(self.span, ObsoleteEnumWildcard);
-                                }
                                 self.bump();
                                 self.expect(&token::RPAREN);
                                 pat = PatEnum(enum_path, None);
@@ -3115,10 +3027,6 @@ impl<'a> Parser<'a> {
     fn parse_let(&mut self) -> @Decl {
         let lo = self.span.lo;
         let local = self.parse_local();
-        while self.eat(&token::COMMA) {
-            let _ = self.parse_local();
-            self.obsolete(self.span, ObsoleteMultipleLocalDecl);
-        }
         return @spanned(lo, self.last_span.hi, DeclLocal(local));
     }
 
@@ -3265,9 +3173,6 @@ impl<'a> Parser<'a> {
         maybe_whole!(no_clone self, NtBlock);
 
         let lo = self.span.lo;
-        if self.eat_keyword(keywords::Unsafe) {
-            self.obsolete(self.span, ObsoleteUnsafeBlock);
-        }
         self.expect(&token::LBRACE);
 
         return self.parse_block_tail_(lo, DefaultBlock, Vec::new());
@@ -3280,9 +3185,6 @@ impl<'a> Parser<'a> {
         maybe_whole!(pair_empty self, NtBlock);
 
         let lo = self.span.lo;
-        if self.eat_keyword(keywords::Unsafe) {
-            self.obsolete(self.span, ObsoleteUnsafeBlock);
-        }
         self.expect(&token::LBRACE);
         let (inner, next) = self.parse_inner_attrs_and_next();
 
@@ -4316,12 +4218,7 @@ impl<'a> Parser<'a> {
     fn parse_item_foreign_fn(&mut self, vis: ast::Visibility,
                              attrs: Vec<Attribute> ) -> @ForeignItem {
         let lo = self.span.lo;
-
+        self.expect_keyword(keywords::Fn);
-        // Parse obsolete purity.
-        let fn_style = self.parse_fn_style();
-        if fn_style != NormalFn {
-            self.obsolete(self.last_span, ObsoleteUnsafeExternFn);
-        }
 
         let (ident, generics) = self.parse_fn_header();
         let decl = self.parse_fn_decl(true);
@@ -4898,7 +4795,7 @@ impl<'a> Parser<'a> {
 
     // parse, e.g., "use a::b::{z,y}"
     fn parse_use(&mut self) -> ViewItem_ {
-        return ViewItemUse(self.parse_view_paths());
+        return ViewItemUse(self.parse_view_path());
     }
 
 
@@ -5029,17 +4926,6 @@ impl<'a> Parser<'a> {
                         ViewPathSimple(last, path, ast::DUMMY_NODE_ID));
     }
 
-    // matches view_paths = view_path | view_path , view_paths
-    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);
-            let _ = self.parse_view_path();
-        }
-        return vp;
-    }
-
     // Parses a sequence of items. Stops when it finds program
     // text that can't be parsed as an item
     // - mod_items uses extern_mod_allowed = true

src/libsyntax/parse/token.rs

@@ -67,7 +67,6 @@ pub enum Token {
     MOD_SEP,
     RARROW,
     LARROW,
-    DARROW,
     FAT_ARROW,
     LPAREN,
     RPAREN,
@@ -183,7 +182,6 @@ pub fn to_str(t: &Token) -> StrBuf {
       MOD_SEP => "::".to_strbuf(),
       RARROW => "->".to_strbuf(),
       LARROW => "<-".to_strbuf(),
-      DARROW => "<->".to_strbuf(),
       FAT_ARROW => "=>".to_strbuf(),
       LPAREN => "(".to_strbuf(),
       RPAREN => ")".to_strbuf(),
@@ -449,45 +447,45 @@ declare_special_idents_and_keywords! {
         'strict:
         (9,                          As,         "as");
         (10,                         Break,      "break");
-        (11,                         Const,      "const");
+        (11,                         Crate,      "crate");
-        (12,                         Crate,      "crate");
+        (12,                         Else,       "else");
-        (13,                         Else,       "else");
+        (13,                         Enum,       "enum");
-        (14,                         Enum,       "enum");
+        (14,                         Extern,     "extern");
-        (15,                         Extern,     "extern");
+        (15,                         False,      "false");
-        (16,                         False,      "false");
+        (16,                         Fn,         "fn");
-        (17,                         Fn,         "fn");
+        (17,                         For,        "for");
-        (18,                         For,        "for");
+        (18,                         If,         "if");
-        (19,                         If,         "if");
+        (19,                         Impl,       "impl");
-        (20,                         Impl,       "impl");
+        (20,                         In,         "in");
-        (21,                         In,         "in");
+        (21,                         Let,        "let");
-        (22,                         Let,        "let");
+        (22,                         Loop,       "loop");
-        (23,                         Loop,       "loop");
+        (23,                         Match,      "match");
-        (24,                         Match,      "match");
+        (24,                         Mod,        "mod");
-        (25,                         Mod,        "mod");
+        (25,                         Mut,        "mut");
-        (26,                         Mut,        "mut");
+        (26,                         Once,       "once");
-        (27,                         Once,       "once");
+        (27,                         Pub,        "pub");
-        (28,                         Pub,        "pub");
+        (28,                         Ref,        "ref");
-        (29,                         Ref,        "ref");
+        (29,                         Return,     "return");
-        (30,                         Return,     "return");
         // Static and Self are also special idents (prefill de-dupes)
         (super::STATIC_KEYWORD_NAME, Static,     "static");
         (super::SELF_KEYWORD_NAME,   Self,       "self");
-        (31,                         Struct,     "struct");
+        (30,                         Struct,     "struct");
-        (32,                         Super,      "super");
+        (31,                         Super,      "super");
-        (33,                         True,       "true");
+        (32,                         True,       "true");
-        (34,                         Trait,      "trait");
+        (33,                         Trait,      "trait");
-        (35,                         Type,       "type");
+        (34,                         Type,       "type");
-        (36,                         Unsafe,     "unsafe");
+        (35,                         Unsafe,     "unsafe");
-        (37,                         Use,        "use");
+        (36,                         Use,        "use");
-        (38,                         Virtual,    "virtual");
+        (37,                         Virtual,    "virtual");
-        (39,                         While,      "while");
+        (38,                         While,      "while");
-        (40,                         Continue,   "continue");
+        (39,                         Continue,   "continue");
-        (41,                         Proc,       "proc");
+        (40,                         Proc,       "proc");
-        (42,                         Box,        "box");
+        (41,                         Box,        "box");
 
         'reserved:
-        (43,                         Alignof,    "alignof");
+        (42,                         Alignof,    "alignof");
-        (44,                         Be,         "be");
+        (43,                         Be,         "be");
+        (44,                         Const,      "const");
         (45,                         Offsetof,   "offsetof");
         (46,                         Priv,       "priv");
         (47,                         Pure,       "pure");

src/test/bench/noise.rs

@@ -52,7 +52,7 @@ impl Noise2DContext {
         for (i, x) in permutations.mut_iter().enumerate() {
             *x = i as i32;
         }
-        rng.shuffle_mut(permutations);
+        rng.shuffle(permutations);
 
         Noise2DContext { rgradients: rgradients, permutations: permutations }
     }

src/test/compile-fail/loop-as-continue.rs

@@ -1,15 +0,0 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn main() {
-    loop {
-        loop //~ ERROR: `loop` instead of `continue`
-    }
-}

src/test/compile-fail/obsolete-syntax.rs

@@ -1,16 +0,0 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-trait A {
-    pub fn foo(); //~ ERROR: visibility not necessary
-    pub fn bar(); //~ ERROR: visibility not necessary
-}
-
-fn main() { }

src/test/compile-fail/useless-priv2.rs

@@ -9,6 +9,8 @@
 // except according to those terms.
 
 pub trait E {
-    pub fn foo();               //~ ERROR: obsolete syntax
+    pub fn foo();               //~ ERROR: unnecessary visibility
 }
-trait F { pub fn foo(); }       //~ ERROR: obsolete syntax
+trait F { pub fn foo(); }       //~ ERROR: unnecessary visibility
+
+fn main() {}