From 33573bc0aaec14c55adbe6be314f761f34f8cdd0 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Thu, 22 May 2014 10:49:26 -0700 Subject: [PATCH] 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 | 5 +- src/librustdoc/html/highlight.rs | 2 +- src/libsyntax/ast.rs | 1 + src/libsyntax/ast_util.rs | 1 + src/libsyntax/ext/quote.rs | 1 - src/libsyntax/fold.rs | 1 + src/libsyntax/parse/lexer.rs | 5 +- src/libsyntax/parse/obsolete.rs | 80 ------------- src/libsyntax/parse/parser.rs | 140 ++-------------------- src/libsyntax/parse/token.rs | 70 ++++++----- src/test/bench/noise.rs | 2 +- src/test/compile-fail/loop-as-continue.rs | 15 --- src/test/compile-fail/obsolete-syntax.rs | 16 --- src/test/compile-fail/useless-priv2.rs | 6 +- 14 files changed, 61 insertions(+), 284 deletions(-) delete mode 100644 src/test/compile-fail/loop-as-continue.rs delete mode 100644 src/test/compile-fail/obsolete-syntax.rs diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs index d7aba4208640..3765f9f450e6 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 5d4350f8fb5c..7ac2db2184bf 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 e7f892d77cea..d4c01746098e 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 ffb18e17bdae..370bc703b106 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 b3eec136c7d6..e0561c77d59c 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 10df264676e3..9813e12de01c 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -648,6 +648,7 @@ pub fn noop_fold_type_method(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 c78d2aaf3a7e..317ba977c56b 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 b6aa47128e63..130bbae5b797 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` instead of a managed string" - ), - ObsoleteManagedVec => ( - "managed vector", - "use `Rc<~[T]>` instead of a managed vector" - ), ObsoleteOwnedType => ( "`~` notation for owned pointers", "use `Box` in `std::owned` instead" diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index c42febcd607a..30a6c6c25160 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) -> @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 ) -> @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 8758f109042f..17ce03ba213a 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 7e41fdea778d..27540cc5bbf9 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 e4273fdfeff9..000000000000 --- 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 or the MIT license -// , 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 9fe5e2031bbf..000000000000 --- 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 or the MIT license -// , 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 29c87e77ac02..7125a66b294c 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() {}