1
Fork 0

Complete the removal of ty_nil, ast::LitNil, ast::TyBot and ast::TyUniq

[breaking-change]

This will break any uses of macros that assumed () being a valid literal.
This commit is contained in:
Jakub Bukaj 2014-11-09 16:14:15 +01:00
parent 08d6774f39
commit eb01b17b06
34 changed files with 348 additions and 405 deletions

View file

@ -30,13 +30,13 @@ use ast::{ExprVec, ExprWhile, ExprWhileLet, ExprForLoop, Field, FnDecl};
use ast::{Once, Many};
use ast::{FnUnboxedClosureKind, FnMutUnboxedClosureKind};
use ast::{FnOnceUnboxedClosureKind};
use ast::{ForeignItem, ForeignItemStatic, ForeignItemFn, ForeignMod};
use ast::{ForeignItem, ForeignItemStatic, ForeignItemFn, ForeignMod, FunctionRetTy};
use ast::{Ident, NormalFn, Inherited, ImplItem, Item, Item_, ItemStatic};
use ast::{ItemEnum, ItemFn, ItemForeignMod, ItemImpl, ItemConst};
use ast::{ItemMac, ItemMod, ItemStruct, ItemTrait, ItemTy};
use ast::{LifetimeDef, Lit, Lit_};
use ast::{LitBool, LitChar, LitByte, LitBinary};
use ast::{LitNil, LitStr, LitInt, Local, LocalLet};
use ast::{LitStr, LitInt, Local, LocalLet};
use ast::{MutImmutable, MutMutable, Mac_, MacInvocTT, MatchNormal};
use ast::{Method, MutTy, BiMul, Mutability};
use ast::{MethodImplItem, NamedField, UnNeg, NoReturn, UnNot};
@ -44,18 +44,18 @@ use ast::{Pat, PatEnum, PatIdent, PatLit, PatRange, PatRegion, PatStruct};
use ast::{PatTup, PatBox, PatWild, PatWildMulti, PatWildSingle};
use ast::{PolyTraitRef};
use ast::{QPath, RequiredMethod};
use ast::{RetStyle, Return, BiShl, BiShr, Stmt, StmtDecl};
use ast::{Return, BiShl, BiShr, Stmt, StmtDecl};
use ast::{StmtExpr, StmtSemi, StmtMac, StructDef, StructField};
use ast::{StructVariantKind, BiSub};
use ast::StrStyle;
use ast::{SelfExplicit, SelfRegion, SelfStatic, SelfValue};
use ast::{Delimited, SequenceRepetition, TokenTree, TraitItem, TraitRef};
use ast::{TtDelimited, TtSequence, TtToken};
use ast::{TupleVariantKind, Ty, Ty_, TyBot};
use ast::{TupleVariantKind, Ty, Ty_};
use ast::{TypeField, TyFixedLengthVec, TyClosure, TyProc, TyBareFn};
use ast::{TyTypeof, TyInfer, TypeMethod};
use ast::{TyNil, TyParam, TyParamBound, TyParen, TyPath, TyPolyTraitRef, TyPtr, TyQPath};
use ast::{TyRptr, TyTup, TyU32, TyUniq, TyVec, UnUniq};
use ast::{TyParam, TyParamBound, TyParen, TyPath, TyPolyTraitRef, TyPtr, TyQPath};
use ast::{TyRptr, TyTup, TyU32, TyVec, UnUniq};
use ast::{TypeImplItem, TypeTraitItem, Typedef, UnboxedClosureKind};
use ast::{UnnamedField, UnsafeBlock};
use ast::{UnsafeFn, ViewItem, ViewItem_, ViewItemExternCrate, ViewItemUse};
@ -1066,11 +1066,10 @@ impl<'a> Parser<'a> {
self.expect_keyword(keywords::Fn);
let lifetime_defs = self.parse_legacy_lifetime_defs(lifetime_defs);
let (inputs, variadic) = self.parse_fn_args(false, true);
let (ret_style, ret_ty) = self.parse_ret_ty();
let ret_ty = self.parse_ret_ty();
let decl = P(FnDecl {
inputs: inputs,
output: ret_ty,
cf: ret_style,
variadic: variadic
});
TyBareFn(P(BareFnTy {
@ -1100,11 +1099,10 @@ impl<'a> Parser<'a> {
let lifetime_defs = self.parse_legacy_lifetime_defs(lifetime_defs);
let (inputs, variadic) = self.parse_fn_args(false, false);
let bounds = self.parse_colon_then_ty_param_bounds();
let (ret_style, ret_ty) = self.parse_ret_ty();
let ret_ty = self.parse_ret_ty();
let decl = P(FnDecl {
inputs: inputs,
output: ret_ty,
cf: ret_style,
variadic: variadic
});
TyProc(P(ClosureTy {
@ -1200,11 +1198,10 @@ impl<'a> Parser<'a> {
let bounds = self.parse_colon_then_ty_param_bounds();
let (return_style, output) = self.parse_ret_ty();
let output = self.parse_ret_ty();
let decl = P(FnDecl {
inputs: inputs,
output: output,
cf: return_style,
variadic: false
});
@ -1384,31 +1381,20 @@ impl<'a> Parser<'a> {
}
/// Parse optional return type [ -> TY ] in function decl
pub fn parse_ret_ty(&mut self) -> (RetStyle, P<Ty>) {
return if self.eat(&token::RArrow) {
let lo = self.span.lo;
pub fn parse_ret_ty(&mut self) -> FunctionRetTy {
if self.eat(&token::RArrow) {
if self.eat(&token::Not) {
(
NoReturn,
P(Ty {
id: ast::DUMMY_NODE_ID,
node: TyBot,
span: mk_sp(lo, self.last_span.hi)
})
)
NoReturn(self.span)
} else {
(Return, self.parse_ty(true))
Return(self.parse_ty(true))
}
} else {
let pos = self.span.lo;
(
Return,
P(Ty {
id: ast::DUMMY_NODE_ID,
node: TyNil,
span: mk_sp(pos, pos),
})
)
Return(P(Ty {
id: ast::DUMMY_NODE_ID,
node: TyTup(vec![]),
span: mk_sp(pos, pos),
}))
}
}
@ -1423,34 +1409,29 @@ impl<'a> Parser<'a> {
let t = if self.token == token::OpenDelim(token::Paren) {
self.bump();
if self.token == token::CloseDelim(token::Paren) {
self.bump();
TyNil
} else {
// (t) is a parenthesized ty
// (t,) is the type of a tuple with only one field,
// of type t
let mut ts = vec!(self.parse_ty(true));
let mut one_tuple = false;
while self.token == token::Comma {
self.bump();
if self.token != token::CloseDelim(token::Paren) {
ts.push(self.parse_ty(true));
}
else {
one_tuple = true;
}
}
if ts.len() == 1 && !one_tuple {
self.expect(&token::CloseDelim(token::Paren));
TyParen(ts.into_iter().nth(0).unwrap())
// (t) is a parenthesized ty
// (t,) is the type of a tuple with only one field,
// of type t
let mut ts = vec![];
let mut last_comma = false;
while self.token != token::CloseDelim(token::Paren) {
ts.push(self.parse_ty(true));
if self.token == token::Comma {
last_comma = true;
self.bump();
} else {
let t = TyTup(ts);
self.expect(&token::CloseDelim(token::Paren));
t
last_comma = false;
break;
}
}
self.expect(&token::CloseDelim(token::Paren));
if ts.len() == 1 && !last_comma {
TyParen(ts.into_iter().nth(0).unwrap())
} else {
TyTup(ts)
}
} else if self.token == token::Tilde {
// OWNED POINTER
self.bump();
@ -1459,7 +1440,7 @@ impl<'a> Parser<'a> {
token::OpenDelim(token::Bracket) => self.obsolete(last_span, ObsoleteOwnedVector),
_ => self.obsolete(last_span, ObsoleteOwnedType)
}
TyUniq(self.parse_ty(false))
TyTup(vec![self.parse_ty(false)])
} else if self.token == token::BinOp(token::Star) {
// STAR POINTER (bare pointer?)
self.bump();
@ -1662,10 +1643,6 @@ impl<'a> Parser<'a> {
LitBinary(parse::binary_lit(i.as_str())),
token::LitBinaryRaw(i, _) =>
LitBinary(Rc::new(i.as_str().as_bytes().iter().map(|&x| x).collect())),
token::OpenDelim(token::Paren) => {
self.expect(&token::CloseDelim(token::Paren));
LitNil
},
_ => { self.unexpected_last(tok); }
}
}
@ -2126,33 +2103,29 @@ impl<'a> Parser<'a> {
match self.token {
token::OpenDelim(token::Paren) => {
self.bump();
// (e) is parenthesized e
// (e,) is a tuple with only one field, e
let mut es = vec![];
let mut trailing_comma = false;
if self.token == token::CloseDelim(token::Paren) {
hi = self.span.hi;
self.bump();
let lit = P(spanned(lo, hi, LitNil));
return self.mk_expr(lo, hi, ExprLit(lit));
}
let mut es = vec!(self.parse_expr());
self.commit_expr(&**es.last().unwrap(), &[],
&[token::Comma, token::CloseDelim(token::Paren)]);
while self.token == token::Comma {
self.bump();
if self.token != token::CloseDelim(token::Paren) {
es.push(self.parse_expr());
self.commit_expr(&**es.last().unwrap(), &[],
&[token::Comma, token::CloseDelim(token::Paren)]);
} else {
while self.token != token::CloseDelim(token::Paren) {
es.push(self.parse_expr());
self.commit_expr(&**es.last().unwrap(), &[],
&[token::Comma, token::CloseDelim(token::Paren)]);
if self.token == token::Comma {
trailing_comma = true;
self.bump();
} else {
trailing_comma = false;
break;
}
}
hi = self.span.hi;
self.commit_expr_expecting(&**es.last().unwrap(), token::CloseDelim(token::Paren));
self.bump();
hi = self.span.hi;
return if es.len() == 1 && !trailing_comma {
self.mk_expr(lo, hi, ExprParen(es.into_iter().nth(0).unwrap()))
self.mk_expr(lo, hi, ExprParen(es.into_iter().nth(0).unwrap()))
} else {
self.mk_expr(lo, hi, ExprTup(es))
}
@ -3293,13 +3266,8 @@ impl<'a> Parser<'a> {
// parse (pat,pat,pat,...) as tuple
self.bump();
if self.token == token::CloseDelim(token::Paren) {
hi = self.span.hi;
self.bump();
let lit = P(codemap::Spanned {
node: LitNil,
span: mk_sp(lo, hi)});
let expr = self.mk_expr(lo, hi, ExprLit(lit));
pat = PatLit(expr);
pat = PatTup(vec![]);
} else {
let mut fields = vec!(self.parse_pat());
if self.look_ahead(1, |t| *t != token::CloseDelim(token::Paren)) {
@ -4137,12 +4105,11 @@ impl<'a> Parser<'a> {
pub fn parse_fn_decl(&mut self, allow_variadic: bool) -> P<FnDecl> {
let (args, variadic) = self.parse_fn_args(true, allow_variadic);
let (ret_style, ret_ty) = self.parse_ret_ty();
let ret_ty = self.parse_ret_ty();
P(FnDecl {
inputs: args,
output: ret_ty,
cf: ret_style,
variadic: variadic
})
}
@ -4337,12 +4304,11 @@ impl<'a> Parser<'a> {
let hi = self.span.hi;
let (ret_style, ret_ty) = self.parse_ret_ty();
let ret_ty = self.parse_ret_ty();
let fn_decl = P(FnDecl {
inputs: fn_inputs,
output: ret_ty,
cf: ret_style,
variadic: false
});
@ -4368,10 +4334,10 @@ impl<'a> Parser<'a> {
(optional_unboxed_closure_kind, args)
}
};
let (style, output) = if self.token == token::RArrow {
let output = if self.token == token::RArrow {
self.parse_ret_ty()
} else {
(Return, P(Ty {
Return(P(Ty {
id: ast::DUMMY_NODE_ID,
node: TyInfer,
span: self.span,
@ -4381,7 +4347,6 @@ impl<'a> Parser<'a> {
(P(FnDecl {
inputs: inputs_captures,
output: output,
cf: style,
variadic: false
}), optional_unboxed_closure_kind)
}
@ -4394,10 +4359,10 @@ impl<'a> Parser<'a> {
seq_sep_trailing_allowed(token::Comma),
|p| p.parse_fn_block_arg());
let (style, output) = if self.token == token::RArrow {
let output = if self.token == token::RArrow {
self.parse_ret_ty()
} else {
(Return, P(Ty {
Return(P(Ty {
id: ast::DUMMY_NODE_ID,
node: TyInfer,
span: self.span,
@ -4407,7 +4372,6 @@ impl<'a> Parser<'a> {
P(FnDecl {
inputs: inputs,
output: output,
cf: style,
variadic: false
})
}