Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Assorted cleanup in parser & AST validation #60751

Merged
merged 4 commits into from
May 12, 2019
Merged

Assorted cleanup in parser & AST validation #60751

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
0535e42
ast_validation: comments -> doc comments
Centril May 5, 2019
9b4a630
syntax::parse::parser: convert unnecessary '&mut self's to '&self'.
Centril May 12, 2019
b680b66
parse_bottom_expr: extract common 'return' out.
Centril May 12, 2019
4aa4a8f
Minor cleanup in parse_assoc_expr_with.
Centril May 12, 2019
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
22 changes: 11 additions & 11 deletions src/librustc_passes/ast_validation.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -54,21 +54,21 @@ struct AstValidator<'a> {
has_proc_macro_decls: bool,
has_global_allocator: bool,

// Used to ban nested `impl Trait`, e.g., `impl Into<impl Debug>`.
// Nested `impl Trait` _is_ allowed in associated type position,
// e.g `impl Iterator<Item=impl Debug>`
/// Used to ban nested `impl Trait`, e.g., `impl Into<impl Debug>`.
/// Nested `impl Trait` _is_ allowed in associated type position,
/// e.g `impl Iterator<Item=impl Debug>`
outer_impl_trait: Option<OuterImplTrait>,

// Used to ban `impl Trait` in path projections like `<impl Iterator>::Item`
// or `Foo::Bar<impl Trait>`
/// Used to ban `impl Trait` in path projections like `<impl Iterator>::Item`
/// or `Foo::Bar<impl Trait>`
is_impl_trait_banned: bool,

// rust-lang/rust#57979: the ban of nested `impl Trait` was buggy
// until PRs #57730 and #57981 landed: it would jump directly to
// walk_ty rather than visit_ty (or skip recurring entirely for
// impl trait in projections), and thus miss some cases. We track
// whether we should downgrade to a warning for short-term via
// these booleans.
/// rust-lang/rust#57979: the ban of nested `impl Trait` was buggy
/// until PRs #57730 and #57981 landed: it would jump directly to
/// walk_ty rather than visit_ty (or skip recurring entirely for
/// impl trait in projections), and thus miss some cases. We track
/// whether we should downgrade to a warning for short-term via
/// these booleans.
warning_period_57979_didnt_record_next_impl_trait: bool,
warning_period_57979_impl_trait_in_proj: bool,
}
Expand Down
87 changes: 38 additions & 49 deletions src/libsyntax/parse/parser.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1877,7 +1877,7 @@ impl<'a> Parser<'a> {
Ok(MutTy { ty: t, mutbl: mutbl })
}

fn is_named_argument(&mut self) -> bool {
fn is_named_argument(&self) -> bool {
let offset = match self.token {
token::Interpolated(ref nt) => match **nt {
token::NtPat(..) => return self.look_ahead(1, |t| t == &token::Colon),
Expand Down Expand Up @@ -2471,27 +2471,27 @@ impl<'a> Parser<'a> {
})
}

fn mk_expr(&mut self, span: Span, node: ExprKind, attrs: ThinVec<Attribute>) -> P<Expr> {
fn mk_expr(&self, span: Span, node: ExprKind, attrs: ThinVec<Attribute>) -> P<Expr> {
P(Expr { node, span, attrs, id: ast::DUMMY_NODE_ID })
}

fn mk_unary(&mut self, unop: ast::UnOp, expr: P<Expr>) -> ast::ExprKind {
fn mk_unary(&self, unop: ast::UnOp, expr: P<Expr>) -> ast::ExprKind {
ExprKind::Unary(unop, expr)
}

fn mk_binary(&mut self, binop: ast::BinOp, lhs: P<Expr>, rhs: P<Expr>) -> ast::ExprKind {
fn mk_binary(&self, binop: ast::BinOp, lhs: P<Expr>, rhs: P<Expr>) -> ast::ExprKind {
ExprKind::Binary(binop, lhs, rhs)
}

fn mk_call(&mut self, f: P<Expr>, args: Vec<P<Expr>>) -> ast::ExprKind {
fn mk_call(&self, f: P<Expr>, args: Vec<P<Expr>>) -> ast::ExprKind {
ExprKind::Call(f, args)
}

fn mk_index(&mut self, expr: P<Expr>, idx: P<Expr>) -> ast::ExprKind {
fn mk_index(&self, expr: P<Expr>, idx: P<Expr>) -> ast::ExprKind {
ExprKind::Index(expr, idx)
}

fn mk_range(&mut self,
fn mk_range(&self,
start: Option<P<Expr>>,
end: Option<P<Expr>>,
limits: RangeLimits)
Expand All @@ -2503,7 +2503,7 @@ impl<'a> Parser<'a> {
}
}

fn mk_assign_op(&mut self, binop: ast::BinOp,
fn mk_assign_op(&self, binop: ast::BinOp,
lhs: P<Expr>, rhs: P<Expr>) -> ast::ExprKind {
ExprKind::AssignOp(binop, lhs, rhs)
}
Expand Down Expand Up @@ -2643,13 +2643,12 @@ impl<'a> Parser<'a> {
hi = path.span;
return Ok(self.mk_expr(lo.to(hi), ExprKind::Path(Some(qself), path), attrs));
}
if self.span.rust_2018() && self.check_keyword(keywords::Async)
{
if self.is_async_block() { // check for `async {` and `async move {`
return self.parse_async_block(attrs);
if self.span.rust_2018() && self.check_keyword(keywords::Async) {
return if self.is_async_block() { // check for `async {` and `async move {`
self.parse_async_block(attrs)
} else {
return self.parse_lambda_expr(attrs);
}
self.parse_lambda_expr(attrs)
};
}
if self.check_keyword(keywords::Move) || self.check_keyword(keywords::Static) {
return self.parse_lambda_expr(attrs);
Expand Down Expand Up @@ -3574,7 +3573,8 @@ impl<'a> Parser<'a> {
} else {
self.restrictions
};
if op.precedence() < min_prec {
let prec = op.precedence();
if prec < min_prec {
break;
}
// Check for deprecated `...` syntax
Expand Down Expand Up @@ -3615,8 +3615,7 @@ impl<'a> Parser<'a> {
// We have 2 alternatives here: `x..y`/`x..=y` and `x..`/`x..=` The other
// two variants are handled with `parse_prefix_range_expr` call above.
let rhs = if self.is_at_start_of_range_notation_rhs() {
Some(self.parse_assoc_expr_with(op.precedence() + 1,
LhsExpr::NotYetParsed)?)
Some(self.parse_assoc_expr_with(prec + 1, LhsExpr::NotYetParsed)?)
} else {
None
};
Expand All @@ -3636,28 +3635,18 @@ impl<'a> Parser<'a> {
break
}

let rhs = match op.fixity() {
Fixity::Right => self.with_res(
restrictions - Restrictions::STMT_EXPR,
|this| {
this.parse_assoc_expr_with(op.precedence(),
LhsExpr::NotYetParsed)
}),
Fixity::Left => self.with_res(
restrictions - Restrictions::STMT_EXPR,
|this| {
this.parse_assoc_expr_with(op.precedence() + 1,
LhsExpr::NotYetParsed)
}),
let fixity = op.fixity();
let prec_adjustment = match fixity {
Fixity::Right => 0,
Fixity::Left => 1,
// We currently have no non-associative operators that are not handled above by
// the special cases. The code is here only for future convenience.
Fixity::None => self.with_res(
restrictions - Restrictions::STMT_EXPR,
|this| {
this.parse_assoc_expr_with(op.precedence() + 1,
LhsExpr::NotYetParsed)
}),
}?;
Fixity::None => 1,
};
let rhs = self.with_res(
restrictions - Restrictions::STMT_EXPR,
|this| this.parse_assoc_expr_with(prec + prec_adjustment, LhsExpr::NotYetParsed)
)?;

// Make sure that the span of the parent node is larger than the span of lhs and rhs,
// including the attributes.
Expand Down Expand Up @@ -3703,7 +3692,7 @@ impl<'a> Parser<'a> {
}
};

if op.fixity() == Fixity::None { break }
if let Fixity::None = fixity { break }
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Suggested change
if let Fixity::None = fixity { break }
if fixity == Fixity::None { break }

}
Ok(lhs)
}
Expand Down Expand Up @@ -3840,7 +3829,7 @@ impl<'a> Parser<'a> {
/// Produce an error if comparison operators are chained (RFC #558).
/// We only need to check lhs, not rhs, because all comparison ops
/// have same precedence and are left-associative
fn check_no_chained_comparison(&mut self, lhs: &Expr, outer_op: &AssocOp) {
fn check_no_chained_comparison(&self, lhs: &Expr, outer_op: &AssocOp) {
debug_assert!(outer_op.is_comparison(),
"check_no_chained_comparison: {:?} is not comparison",
outer_op);
Expand Down Expand Up @@ -5137,7 +5126,7 @@ impl<'a> Parser<'a> {
})
}

fn is_async_block(&mut self) -> bool {
fn is_async_block(&self) -> bool {
self.token.is_keyword(keywords::Async) &&
(
( // `async move {`
Expand All @@ -5149,19 +5138,19 @@ impl<'a> Parser<'a> {
)
}

fn is_async_fn(&mut self) -> bool {
fn is_async_fn(&self) -> bool {
self.token.is_keyword(keywords::Async) &&
self.look_ahead(1, |t| t.is_keyword(keywords::Fn))
}

fn is_do_catch_block(&mut self) -> bool {
fn is_do_catch_block(&self) -> bool {
self.token.is_keyword(keywords::Do) &&
self.look_ahead(1, |t| t.is_keyword(keywords::Catch)) &&
self.look_ahead(2, |t| *t == token::OpenDelim(token::Brace)) &&
!self.restrictions.contains(Restrictions::NO_STRUCT_LITERAL)
}

fn is_try_block(&mut self) -> bool {
fn is_try_block(&self) -> bool {
self.token.is_keyword(keywords::Try) &&
self.look_ahead(1, |t| *t == token::OpenDelim(token::Brace)) &&
self.span.rust_2018() &&
Expand All @@ -5183,7 +5172,7 @@ impl<'a> Parser<'a> {
self.look_ahead(1, |t| t.is_keyword(keywords::Type))
}

fn is_auto_trait_item(&mut self) -> bool {
fn is_auto_trait_item(&self) -> bool {
// auto trait
(self.token.is_keyword(keywords::Auto)
&& self.look_ahead(1, |t| t.is_keyword(keywords::Trait)))
Expand Down Expand Up @@ -5445,7 +5434,7 @@ impl<'a> Parser<'a> {
}

/// Checks if this expression is a successfully parsed statement.
fn expr_is_complete(&mut self, e: &Expr) -> bool {
fn expr_is_complete(&self, e: &Expr) -> bool {
self.restrictions.contains(Restrictions::STMT_EXPR) &&
!classify::expr_requires_semi_to_be_stmt(e)
}
Expand Down Expand Up @@ -6517,7 +6506,7 @@ impl<'a> Parser<'a> {
Ok((id, generics))
}

fn mk_item(&mut self, span: Span, ident: Ident, node: ItemKind, vis: Visibility,
fn mk_item(&self, span: Span, ident: Ident, node: ItemKind, vis: Visibility,
attrs: Vec<Attribute>) -> P<Item> {
P(Item {
ident,
Expand Down Expand Up @@ -6549,7 +6538,7 @@ impl<'a> Parser<'a> {

/// Returns `true` if we are looking at `const ID`
/// (returns `false` for things like `const fn`, etc.).
fn is_const_item(&mut self) -> bool {
fn is_const_item(&self) -> bool {
self.token.is_keyword(keywords::Const) &&
!self.look_ahead(1, |t| t.is_keyword(keywords::Fn)) &&
!self.look_ahead(1, |t| t.is_keyword(keywords::Unsafe))
Expand Down Expand Up @@ -6657,7 +6646,7 @@ impl<'a> Parser<'a> {
})
}

fn complain_if_pub_macro(&mut self, vis: &VisibilityKind, sp: Span) {
fn complain_if_pub_macro(&self, vis: &VisibilityKind, sp: Span) {
match *vis {
VisibilityKind::Inherited => {}
_ => {
Expand Down Expand Up @@ -6686,7 +6675,7 @@ impl<'a> Parser<'a> {
}
}

fn missing_assoc_item_kind_err(&mut self, item_type: &str, prev_span: Span)
fn missing_assoc_item_kind_err(&self, item_type: &str, prev_span: Span)
-> DiagnosticBuilder<'a>
{
let expected_kinds = if item_type == "extern" {
Expand Down