about summary refs log tree commit diff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/librustc/middle/privacy.rs5
-rw-r--r--src/librustdoc/html/highlight.rs2
-rw-r--r--src/libsyntax/ast.rs1
-rw-r--r--src/libsyntax/ast_util.rs1
-rw-r--r--src/libsyntax/ext/quote.rs1
-rw-r--r--src/libsyntax/fold.rs1
-rw-r--r--src/libsyntax/parse/lexer.rs5
-rw-r--r--src/libsyntax/parse/obsolete.rs80
-rw-r--r--src/libsyntax/parse/parser.rs140
-rw-r--r--src/libsyntax/parse/token.rs70
-rw-r--r--src/test/bench/noise.rs2
-rw-r--r--src/test/compile-fail/loop-as-continue.rs15
-rw-r--r--src/test/compile-fail/obsolete-syntax.rs16
-rw-r--r--src/test/compile-fail/useless-priv2.rs6
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() {}
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2025-10-31 10:06:02 +0000