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.

14 files changed, 61 insertions, 284 deletions

diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs
index d7aba420864..3765f9f450e 100644
--- a/src/librustc/middle/privacy.rs
+++ b/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");
+                        }
                     }
                 }
             }
diff --git a/src/librustdoc/html/highlight.rs b/src/librustdoc/html/highlight.rs
index 5d4350f8fb5..7ac2db2184b 100644
--- a/src/librustdoc/html/highlight.rs
+++ b/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) {
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index e7f892d77ce..d4c01746098 100644
--- a/src/libsyntax/ast.rs
+++ b/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
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index ffb18e17bda..370bc703b10 100644
--- a/src/libsyntax/ast_util.rs
+++ b/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,
             }
         }
     }
diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs
index b3eec136c7d..e0561c77d59 100644
--- a/src/libsyntax/ext/quote.rs
+++ b/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",
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index 10df264676e..9813e12de01 100644
--- a/src/libsyntax/fold.rs
+++ b/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,
     }
 }
 
diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs
index c78d2aaf3a7..317ba977c56 100644
--- a/src/libsyntax/parse/lexer.rs
+++ b/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') {
-              '>' => { bump(rdr); return token::DARROW; }
-              _ => { return token::LARROW; }
-            }
+            return token::LARROW;
           }
           _ => { return token::LT; }
         }
diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs
index b6aa47128e6..130bbae5b79 100644
--- a/src/libsyntax/parse/obsolete.rs
+++ b/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"
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index c42febcd607..30a6c6c2516 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/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 {
-              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)
-            };
+            ex = 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));
-        } 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);
-        }
+        let lo = self.last_span.lo;
+        let body = self.parse_block();
+        let hi = body.span.hi;
+        self.mk_expr(lo, hi, ExprLoop(body, opt_ident))
     }
 
     // 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::UNDERSCORE {
-                self.obsolete(self.span, ObsoleteStructWildcard);
-            }
-            if etc {
+            if self.token == token::DOTDOT {
                 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;
-
-        // Parse obsolete purity.
-        let fn_style = self.parse_fn_style();
-        if fn_style != NormalFn {
-            self.obsolete(self.last_span, ObsoleteUnsafeExternFn);
-        }
+        self.expect_keyword(keywords::Fn);
 
         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
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index 8758f109042..17ce03ba213 100644
--- a/src/libsyntax/parse/token.rs
+++ b/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");
-        (12,                         Crate,      "crate");
-        (13,                         Else,       "else");
-        (14,                         Enum,       "enum");
-        (15,                         Extern,     "extern");
-        (16,                         False,      "false");
-        (17,                         Fn,         "fn");
-        (18,                         For,        "for");
-        (19,                         If,         "if");
-        (20,                         Impl,       "impl");
-        (21,                         In,         "in");
-        (22,                         Let,        "let");
-        (23,                         Loop,       "loop");
-        (24,                         Match,      "match");
-        (25,                         Mod,        "mod");
-        (26,                         Mut,        "mut");
-        (27,                         Once,       "once");
-        (28,                         Pub,        "pub");
-        (29,                         Ref,        "ref");
-        (30,                         Return,     "return");
+        (11,                         Crate,      "crate");
+        (12,                         Else,       "else");
+        (13,                         Enum,       "enum");
+        (14,                         Extern,     "extern");
+        (15,                         False,      "false");
+        (16,                         Fn,         "fn");
+        (17,                         For,        "for");
+        (18,                         If,         "if");
+        (19,                         Impl,       "impl");
+        (20,                         In,         "in");
+        (21,                         Let,        "let");
+        (22,                         Loop,       "loop");
+        (23,                         Match,      "match");
+        (24,                         Mod,        "mod");
+        (25,                         Mut,        "mut");
+        (26,                         Once,       "once");
+        (27,                         Pub,        "pub");
+        (28,                         Ref,        "ref");
+        (29,                         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");
-        (32,                         Super,      "super");
-        (33,                         True,       "true");
-        (34,                         Trait,      "trait");
-        (35,                         Type,       "type");
-        (36,                         Unsafe,     "unsafe");
-        (37,                         Use,        "use");
-        (38,                         Virtual,    "virtual");
-        (39,                         While,      "while");
-        (40,                         Continue,   "continue");
-        (41,                         Proc,       "proc");
-        (42,                         Box,        "box");
+        (30,                         Struct,     "struct");
+        (31,                         Super,      "super");
+        (32,                         True,       "true");
+        (33,                         Trait,      "trait");
+        (34,                         Type,       "type");
+        (35,                         Unsafe,     "unsafe");
+        (36,                         Use,        "use");
+        (37,                         Virtual,    "virtual");
+        (38,                         While,      "while");
+        (39,                         Continue,   "continue");
+        (40,                         Proc,       "proc");
+        (41,                         Box,        "box");
 
         'reserved:
-        (43,                         Alignof,    "alignof");
-        (44,                         Be,         "be");
+        (42,                         Alignof,    "alignof");
+        (43,                         Be,         "be");
+        (44,                         Const,      "const");
         (45,                         Offsetof,   "offsetof");
         (46,                         Priv,       "priv");
         (47,                         Pure,       "pure");
diff --git a/src/test/bench/noise.rs b/src/test/bench/noise.rs
index 7e41fdea778..27540cc5bbf 100644
--- a/src/test/bench/noise.rs
+++ b/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 }
     }
diff --git a/src/test/compile-fail/loop-as-continue.rs b/src/test/compile-fail/loop-as-continue.rs
deleted file mode 100644
index e4273fdfeff..00000000000
--- a/src/test/compile-fail/loop-as-continue.rs
+++ /dev/null
@@ -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`
-    }
-}
diff --git a/src/test/compile-fail/obsolete-syntax.rs b/src/test/compile-fail/obsolete-syntax.rs
deleted file mode 100644
index 9fe5e2031bb..00000000000
--- a/src/test/compile-fail/obsolete-syntax.rs
+++ /dev/null
@@ -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() { }
diff --git a/src/test/compile-fail/useless-priv2.rs b/src/test/compile-fail/useless-priv2.rs
index 29c87e77ac0..7125a66b294 100644
--- a/src/test/compile-fail/useless-priv2.rs
+++ b/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() {}