mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

syntax: Clean out obsolete syntax parsing

Browse Source 
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.
This commit is contained in:
Alex Crichton 2014-05-22 10:49:26 -07:00
parent 0dd4c1e7bd
commit 33573bc0aa
14 changed files with 61 additions and 284 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/librustc/middle/privacy.rs
View File

@ -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");
}
}
}
}

2
src/librustdoc/html/highlight.rs
View File

@ -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) {

1
src/libsyntax/ast.rs
View File

@ -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

1
src/libsyntax/ast_util.rs
View File

@ -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,
}
}
}

1
src/libsyntax/ext/quote.rs
View File

@ -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",

1
src/libsyntax/fold.rs
View File

@ -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,
}
}

5
src/libsyntax/parse/lexer.rs
View File

@ -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; }
}

80
src/libsyntax/parse/obsolete.rs
View File

@ -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"

140
src/libsyntax/parse/parser.rs
View File

@ -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

70
src/libsyntax/parse/token.rs
View File

@ -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");

2
src/test/bench/noise.rs
View File

@ -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 }
}

15
src/test/compile-fail/loop-as-continue.rs
View File

@ -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`
}
}

16
src/test/compile-fail/obsolete-syntax.rs
View File

@ -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() { }

6
src/test/compile-fail/useless-priv2.rs
View File

@ -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() {}