bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity

Auto merge of #39110 - petrochenkov:sum, r=eddyb

Browse source 
Merge ObjectSum and PolyTraitRef in AST/HIR + some other refactoring

`ObjectSum` and `PolyTraitRef` are the same thing (list of bounds), they exist separately only due to parser quirks. The second commit merges them.

The first commit replaces `Path` with `Ty` in (not yet supported) equality predicates. They are parsed as types anyway and arbitrary types can always be disguised as paths using aliases, so this doesn't add any new functionality.

The third commit uses `Vec` instead of `P<[T]>` in AST. AST is not immutable like HIR and `Vec`s are more convenient for it, unnecessary conversions are also avoided.

The last commit renames `parse_ty_sum` (which is used for parsing types in general) into `parse_ty`, and renames `parse_ty` (which is used restricted contexts where `+` is not permitted due to operator priorities or other reasons) into `parse_ty_no_plus`.

This is the first part of https://github.com/rust-lang/rust/issues/39085#issuecomment-272743755 and https://github.com/rust-lang/rust/issues/39080 focused on data changes and mechanical renaming, I'll submit a PR with parser changes a bit later.

r? @eddyb
This commit is contained in:
bors 2017-01-17 12:31:15 +00:00
commit a167c042ab
30 changed files with 239 additions and 373 deletions
Download patch file Download diff file Expand all files Collapse all files

166
src/libsyntax/parse/parser.rs
View file

@ -40,7 +40,7 @@ use ast::{Visibility, WhereClause};
use ast::{BinOpKind, UnOp};
use {ast, attr};
use codemap::{self, CodeMap, Spanned, spanned, respan};
use syntax_pos::{self, Span, BytePos, mk_sp};
use syntax_pos::{self, Span, Pos, BytePos, mk_sp};
use errors::{self, DiagnosticBuilder};
use ext::tt::macro_parser;
use parse;
@ -685,7 +685,7 @@ impl<'a> Parser<'a> {
pub fn parse_seq_to_before_gt_or_return<T, F>(&mut self,
sep: Option<token::Token>,
mut f: F)
-> PResult<'a, (P<[T]>, bool)>
-> PResult<'a, (Vec<T>, bool)>
where F: FnMut(&mut Parser<'a>) -> PResult<'a, Option<T>>,
{
let mut v = Vec::new();
@ -706,7 +706,7 @@ impl<'a> Parser<'a> {
if i % 2 == 0 {
match f(self)? {
Some(result) => v.push(result),
None => return Ok((P::from_vec(v), true))
None => return Ok((v, true))
}
} else {
if let Some(t) = sep.as_ref() {
@ -715,7 +715,7 @@ impl<'a> Parser<'a> {
}
}
return Ok((P::from_vec(v), false));
return Ok((v, false));
}
/// Parse a sequence bracketed by '<' and '>', stopping
@ -723,7 +723,7 @@ impl<'a> Parser<'a> {
pub fn parse_seq_to_before_gt<T, F>(&mut self,
sep: Option<token::Token>,
mut f: F)
-> PResult<'a, P<[T]>> where
-> PResult<'a, Vec<T>> where
F: FnMut(&mut Parser<'a>) -> PResult<'a, T>,
{
let (result, returned) = self.parse_seq_to_before_gt_or_return(sep,
@ -735,7 +735,7 @@ impl<'a> Parser<'a> {
pub fn parse_seq_to_gt<T, F>(&mut self,
sep: Option<token::Token>,
f: F)
-> PResult<'a, P<[T]>> where
-> PResult<'a, Vec<T>> where
F: FnMut(&mut Parser<'a>) -> PResult<'a, T>,
{
let v = self.parse_seq_to_before_gt(sep, f)?;
@ -746,7 +746,7 @@ impl<'a> Parser<'a> {
pub fn parse_seq_to_gt_or_return<T, F>(&mut self,
sep: Option<token::Token>,
f: F)
-> PResult<'a, (P<[T]>, bool)> where
-> PResult<'a, (Vec<T>, bool)> where
F: FnMut(&mut Parser<'a>) -> PResult<'a, Option<T>>,
{
let (v, returned) = self.parse_seq_to_before_gt_or_return(sep, f)?;
@ -1039,13 +1039,13 @@ impl<'a> Parser<'a> {
let other_bounds = if self.eat(&token::BinOp(token::Plus)) {
self.parse_ty_param_bounds()?
} else {
P::new()
Vec::new()
};
let all_bounds =
Some(TraitTyParamBound(poly_trait_ref, TraitBoundModifier::None)).into_iter()
.chain(other_bounds.into_vec())
.chain(other_bounds)
.collect();
Ok(ast::TyKind::PolyTraitRef(all_bounds))
Ok(ast::TyKind::TraitObject(all_bounds))
}
}
@ -1128,7 +1128,7 @@ impl<'a> Parser<'a> {
self.expect_keyword(keywords::Const)?;
let ident = self.parse_ident()?;
self.expect(&token::Colon)?;
let ty = self.parse_ty_sum()?;
let ty = self.parse_ty()?;
let default = if self.check(&token::Eq) {
self.bump();
let expr = self.parse_expr()?;
@ -1244,30 +1244,30 @@ impl<'a> Parser<'a> {
/// Parse a possibly mutable type
pub fn parse_mt(&mut self) -> PResult<'a, MutTy> {
let mutbl = self.parse_mutability()?;
let t = self.parse_ty()?;
let t = self.parse_ty_no_plus()?;
Ok(MutTy { ty: t, mutbl: mutbl })
}
/// Parse optional return type [ -> TY ] in function decl
pub fn parse_ret_ty(&mut self) -> PResult<'a, FunctionRetTy> {
if self.eat(&token::RArrow) {
Ok(FunctionRetTy::Ty(self.parse_ty()?))
Ok(FunctionRetTy::Ty(self.parse_ty_no_plus()?))
} else {
let pos = self.span.lo;
Ok(FunctionRetTy::Default(mk_sp(pos, pos)))
}
}
/// Parse a type in a context where `T1+T2` is allowed.
pub fn parse_ty_sum(&mut self) -> PResult<'a, P<Ty>> {
/// Parse a type.
pub fn parse_ty(&mut self) -> PResult<'a, P<Ty>> {
let lo = self.span.lo;
let lhs = self.parse_ty()?;
let lhs = self.parse_ty_no_plus()?;
if !self.eat(&token::BinOp(token::Plus)) {
return Ok(lhs);
}
let bounds = self.parse_ty_param_bounds()?;
let mut bounds = self.parse_ty_param_bounds()?;
// In type grammar, `+` is treated like a binary operator,
// and hence both L and R side are required.
@ -1277,14 +1277,66 @@ impl<'a> Parser<'a> {
"at least one type parameter bound \
must be specified");
}
if let TyKind::Path(None, ref path) = lhs.node {
let poly_trait_ref = PolyTraitRef {
bound_lifetimes: Vec::new(),
trait_ref: TraitRef { path: path.clone(), ref_id: lhs.id },
span: lhs.span,
};
let poly_trait_ref = TraitTyParamBound(poly_trait_ref, TraitBoundModifier::None);
bounds.insert(0, poly_trait_ref);
} else {
let mut err = struct_span_err!(self.sess.span_diagnostic, lhs.span, E0178,
"expected a path on the left-hand side \
of `+`, not `{}`",
pprust::ty_to_string(&lhs));
err.span_label(lhs.span, &format!("expected a path"));
let hi = bounds.iter().map(|x| match *x {
ast::TraitTyParamBound(ref tr, _) => tr.span.hi,
ast::RegionTyParamBound(ref r) => r.span.hi,
}).max_by_key(|x| x.to_usize());
let full_span = hi.map(|hi| Span {
lo: lhs.span.lo,
hi: hi,
expn_id: lhs.span.expn_id,
});
match (&lhs.node, full_span) {
(&TyKind::Rptr(ref lifetime, ref mut_ty), Some(full_span)) => {
let ty_str = pprust::to_string(|s| {
use print::pp::word;
use print::pprust::PrintState;
word(&mut s.s, "&")?;
s.print_opt_lifetime(lifetime)?;
s.print_mutability(mut_ty.mutbl)?;
s.popen()?;
s.print_type(&mut_ty.ty)?;
s.print_bounds(" +", &bounds)?;
s.pclose()
});
err.span_suggestion(full_span, "try adding parentheses (per RFC 438):",
ty_str);
}
_ => {
help!(&mut err,
"perhaps you forgot parentheses? (per RFC 438)");
}
}
err.emit();
}
let sp = mk_sp(lo, self.prev_span.hi);
let sum = ast::TyKind::ObjectSum(lhs, bounds);
let sum = TyKind::TraitObject(bounds);
Ok(P(Ty {id: ast::DUMMY_NODE_ID, node: sum, span: sp}))
}
/// Parse a type.
pub fn parse_ty(&mut self) -> PResult<'a, P<Ty>> {
/// Parse a type in restricted contexts where `+` is not permitted.
/// Example 1: `&'a TYPE`
/// `+` is prohibited to maintain operator priority (P(+) < P(&)).
/// Example 2: `value1 as TYPE + value2`
/// `+` is prohibited to avoid interactions with expression grammar.
pub fn parse_ty_no_plus(&mut self) -> PResult<'a, P<Ty>> {
maybe_whole!(self, NtTy, |x| x);
let lo = self.span.lo;
@ -1298,7 +1350,7 @@ impl<'a> Parser<'a> {
let mut ts = vec![];
let mut last_comma = false;
while self.token != token::CloseDelim(token::Paren) {
ts.push(self.parse_ty_sum()?);
ts.push(self.parse_ty()?);
if self.check(&token::Comma) {
last_comma = true;
self.bump();
@ -1323,7 +1375,7 @@ impl<'a> Parser<'a> {
} else if self.check(&token::OpenDelim(token::Bracket)) {
// VECTOR
self.expect(&token::OpenDelim(token::Bracket))?;
let t = self.parse_ty_sum()?;
let t = self.parse_ty()?;
// Parse the `; e` in `[ i32; e ]`
// where `e` is a const expression
@ -1404,7 +1456,7 @@ impl<'a> Parser<'a> {
`*mut T` or `*const T` as appropriate)");
Mutability::Immutable
};
let t = self.parse_ty()?;
let t = self.parse_ty_no_plus()?;
Ok(MutTy { ty: t, mutbl: mutbl })
}
@ -1451,7 +1503,7 @@ impl<'a> Parser<'a> {
})
};
let t = self.parse_ty_sum()?;
let t = self.parse_ty()?;
Ok(Arg {
ty: t,
@ -1469,7 +1521,7 @@ impl<'a> Parser<'a> {
pub fn parse_fn_block_arg(&mut self) -> PResult<'a, Arg> {
let pat = self.parse_pat()?;
let t = if self.eat(&token::Colon) {
self.parse_ty_sum()?
self.parse_ty()?
} else {
P(Ty {
id: ast::DUMMY_NODE_ID,
@ -1610,7 +1662,7 @@ impl<'a> Parser<'a> {
pub fn parse_qualified_path(&mut self, mode: PathStyle)
-> PResult<'a, (QSelf, ast::Path)> {
let span = self.prev_span;
let self_type = self.parse_ty_sum()?;
let self_type = self.parse_ty()?;
let mut path = if self.eat_keyword(keywords::As) {
self.parse_path(PathStyle::Type)?
} else {
@ -1711,8 +1763,8 @@ impl<'a> Parser<'a> {
let (lifetimes, types, bindings) = self.parse_generic_values_after_lt()?;
ast::AngleBracketedParameterData {
lifetimes: lifetimes,
types: P::from_vec(types),
bindings: P::from_vec(bindings),
types: types,
bindings: bindings,
}.into()
} else if self.eat(&token::OpenDelim(token::Paren)) {
let lo = self.prev_span.lo;
@ -1720,10 +1772,10 @@ impl<'a> Parser<'a> {
let inputs = self.parse_seq_to_end(
&token::CloseDelim(token::Paren),
SeqSep::trailing_allowed(token::Comma),
|p| p.parse_ty_sum())?;
|p| p.parse_ty())?;
let output_ty = if self.eat(&token::RArrow) {
Some(self.parse_ty()?)
Some(self.parse_ty_no_plus()?)
} else {
None
};
@ -1771,8 +1823,8 @@ impl<'a> Parser<'a> {
identifier: identifier,
parameters: ast::AngleBracketedParameterData {
lifetimes: lifetimes,
types: P::from_vec(types),
bindings: P::from_vec(bindings),
types: types,
bindings: bindings,
}.into(),
});
@ -2933,12 +2985,12 @@ impl<'a> Parser<'a> {
}
// Special cases:
if op == AssocOp::As {
let rhs = self.parse_ty()?;
let rhs = self.parse_ty_no_plus()?;
let (lo, hi) = (lhs_span.lo, rhs.span.hi);
lhs = self.mk_expr(lo, hi, ExprKind::Cast(lhs, rhs), ThinVec::new());
continue
} else if op == AssocOp::Colon {
let rhs = self.parse_ty()?;
let rhs = self.parse_ty_no_plus()?;
let (lo, hi) = (lhs_span.lo, rhs.span.hi);
lhs = self.mk_expr(lo, hi, ExprKind::Type(lhs, rhs), ThinVec::new());
continue
@ -3706,7 +3758,7 @@ impl<'a> Parser<'a> {
let mut ty = None;
if self.eat(&token::Colon) {
ty = Some(self.parse_ty_sum()?);
ty = Some(self.parse_ty()?);
}
let init = self.parse_initializer()?;
Ok(P(ast::Local {
@ -3727,7 +3779,7 @@ impl<'a> Parser<'a> {
-> PResult<'a, StructField> {
let name = self.parse_ident()?;
self.expect(&token::Colon)?;
let ty = self.parse_ty_sum()?;
let ty = self.parse_ty()?;
Ok(StructField {
span: mk_sp(lo, self.prev_span.hi),
ident: Some(name),
@ -4144,7 +4196,7 @@ impl<'a> Parser<'a> {
fn parse_colon_then_ty_param_bounds(&mut self) -> PResult<'a, TyParamBounds>
{
if !self.eat(&token::Colon) {
Ok(P::new())
Ok(Vec::new())
} else {
self.parse_ty_param_bounds()
}
@ -4190,7 +4242,7 @@ impl<'a> Parser<'a> {
}
}
return Ok(P::from_vec(result));
return Ok(result);
}
/// Matches typaram = IDENT (`?` unbound)? optbounds ( EQ ty )?
@ -4202,7 +4254,7 @@ impl<'a> Parser<'a> {
let default = if self.check(&token::Eq) {
self.bump();
Some(self.parse_ty_sum()?)
Some(self.parse_ty()?)
} else {
None
};
@ -4297,7 +4349,7 @@ impl<'a> Parser<'a> {
let mut err = self.diagnostic().struct_span_err(self.span, &msg);
let span_hi = self.span.hi;
let span_hi = match self.parse_ty() {
let span_hi = match self.parse_ty_no_plus() {
Ok(..) => self.span.hi,
Err(ref mut err) => {
self.cancel(err);
@ -4320,14 +4372,14 @@ impl<'a> Parser<'a> {
if p.look_ahead(1, |t| t == &token::Eq) {
Ok(None)
} else {
Ok(Some(p.parse_ty_sum()?))
Ok(Some(p.parse_ty()?))
}
}
)?;
// If we found the `>`, don't continue.
if !returned {
return Ok((lifetimes, types.into_vec(), Vec::new()));
return Ok((lifetimes, types, Vec::new()));
}
// Then parse type bindings.
@ -4338,7 +4390,7 @@ impl<'a> Parser<'a> {
let lo = p.span.lo;
let ident = p.parse_ident()?;
p.expect(&token::Eq)?;
let ty = p.parse_ty()?;
let ty = p.parse_ty_no_plus()?;
let hi = ty.span.hi;
let span = mk_sp(lo, hi);
return Ok(TypeBinding{id: ast::DUMMY_NODE_ID,
@ -4348,7 +4400,7 @@ impl<'a> Parser<'a> {
});
}
)?;
Ok((lifetimes, types.into_vec(), bindings.into_vec()))
Ok((lifetimes, types, bindings))
}
fn forbid_lifetime(&mut self) -> PResult<'a, ()> {
@ -4436,7 +4488,7 @@ impl<'a> Parser<'a> {
vec![]
};
let bounded_ty = self.parse_ty()?;
let bounded_ty = self.parse_ty_no_plus()?;
if self.eat(&token::Colon) {
let bounds = self.parse_ty_param_bounds()?;
@ -4459,7 +4511,7 @@ impl<'a> Parser<'a> {
parsed_something = true;
} else if self.eat(&token::Eq) {
// let ty = try!(self.parse_ty());
// let ty = try!(self.parse_ty_no_plus());
let hi = self.prev_span.hi;
let span = mk_sp(lo, hi);
// where_clause.predicates.push(
@ -4631,7 +4683,7 @@ impl<'a> Parser<'a> {
// self: TYPE
let eself_ident = expect_ident(self);
if self.eat(&token::Colon) {
let ty = self.parse_ty_sum()?;
let ty = self.parse_ty()?;
(SelfKind::Explicit(ty, Mutability::Immutable), eself_ident)
} else {
(SelfKind::Value(Mutability::Immutable), eself_ident)
@ -4643,7 +4695,7 @@ impl<'a> Parser<'a> {
self.bump();
let eself_ident = expect_ident(self);
if self.eat(&token::Colon) {
let ty = self.parse_ty_sum()?;
let ty = self.parse_ty()?;
(SelfKind::Explicit(ty, Mutability::Mutable), eself_ident)
} else {
(SelfKind::Value(Mutability::Mutable), eself_ident)
@ -4800,14 +4852,14 @@ impl<'a> Parser<'a> {
let (name, node) = if self.eat_keyword(keywords::Type) {
let name = self.parse_ident()?;
self.expect(&token::Eq)?;
let typ = self.parse_ty_sum()?;
let typ = self.parse_ty()?;
self.expect(&token::Semi)?;
(name, ast::ImplItemKind::Type(typ))
} else if self.is_const_item() {
self.expect_keyword(keywords::Const)?;
let name = self.parse_ident()?;
self.expect(&token::Colon)?;
let typ = self.parse_ty_sum()?;
let typ = self.parse_ty()?;
self.expect(&token::Eq)?;
let expr = self.parse_expr()?;
self.expect(&token::Semi)?;
@ -4931,7 +4983,7 @@ impl<'a> Parser<'a> {
};
// Parse the trait.
let mut ty = self.parse_ty_sum()?;
let mut ty = self.parse_ty()?;
// Parse traits, if necessary.
let opt_trait = if could_be_trait && self.eat_keyword(keywords::For) {
@ -4972,7 +5024,7 @@ impl<'a> Parser<'a> {
ItemKind::DefaultImpl(unsafety, opt_trait.unwrap()), None))
} else {
if opt_trait.is_some() {
ty = self.parse_ty_sum()?;
ty = self.parse_ty()?;
}
generics.where_clause = self.parse_where_clause()?;
@ -5124,7 +5176,7 @@ impl<'a> Parser<'a> {
let mut vis = p.parse_visibility(false)?;
let ty_is_interpolated =
p.token.is_interpolated() || p.look_ahead(1, |t| t.is_interpolated());
let mut ty = p.parse_ty_sum()?;
let mut ty = p.parse_ty()?;
// Handle `pub(path) type`, in which `vis` will be `pub` and `ty` will be `(path)`.
if vis == Visibility::Public && !ty_is_interpolated &&
@ -5132,7 +5184,7 @@ impl<'a> Parser<'a> {
ty = if let TyKind::Paren(ref path_ty) = ty.node {
if let TyKind::Path(None, ref path) = path_ty.node {
vis = Visibility::Restricted { path: P(path.clone()), id: path_ty.id };
Some(p.parse_ty_sum()?)
Some(p.parse_ty()?)
} else {
None
}
@ -5250,7 +5302,7 @@ impl<'a> Parser<'a> {
fn parse_item_const(&mut self, m: Option<Mutability>) -> PResult<'a, ItemInfo> {
let id = self.parse_ident()?;
self.expect(&token::Colon)?;
let ty = self.parse_ty_sum()?;
let ty = self.parse_ty()?;
self.expect(&token::Eq)?;
let e = self.parse_expr()?;
self.expect(&token::Semi)?;
@ -5491,7 +5543,7 @@ impl<'a> Parser<'a> {
let ident = self.parse_ident()?;
self.expect(&token::Colon)?;
let ty = self.parse_ty_sum()?;
let ty = self.parse_ty()?;
let hi = self.span.hi;
self.expect(&token::Semi)?;
Ok(ForeignItem {
@ -5580,7 +5632,7 @@ impl<'a> Parser<'a> {
let mut tps = self.parse_generics()?;
tps.where_clause = self.parse_where_clause()?;
self.expect(&token::Eq)?;
let ty = self.parse_ty_sum()?;
let ty = self.parse_ty()?;
self.expect(&token::Semi)?;
Ok((ident, ItemKind::Ty(ty, tps), None))
}