Skip to content
Permalink
Browse files

Add span information to `ExprKind::Assign`

  • Loading branch information
varkor committed Dec 22, 2019
1 parent 5ab4735 commit 35979a92bf6dba402885a1488ecfd84046e4bd71
@@ -1043,9 +1043,9 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr) {
walk_list!(visitor, visit_label, opt_label);
visitor.visit_block(block);
}
ExprKind::Assign(ref left_hand_expression, ref right_hand_expression) => {
visitor.visit_expr(right_hand_expression);
visitor.visit_expr(left_hand_expression)
ExprKind::Assign(ref lhs, ref rhs, _) => {
visitor.visit_expr(rhs);
visitor.visit_expr(lhs)
}
ExprKind::AssignOp(_, ref left_expression, ref right_expression) => {
visitor.visit_expr(right_expression);
@@ -122,8 +122,8 @@ impl LoweringContext<'_, '_> {
self.lower_block(blk, opt_label.is_some()),
self.lower_label(opt_label),
),
ExprKind::Assign(ref el, ref er) => {
hir::ExprKind::Assign(P(self.lower_expr(el)), P(self.lower_expr(er)))
ExprKind::Assign(ref el, ref er, span) => {
hir::ExprKind::Assign(P(self.lower_expr(el)), P(self.lower_expr(er)), span)
}
ExprKind::AssignOp(op, ref el, ref er) => hir::ExprKind::AssignOp(
self.lower_binop(op),
@@ -994,8 +994,11 @@ impl LoweringContext<'_, '_> {
let (val_pat, val_pat_hid) = self.pat_ident(pat.span, val_ident);
let val_expr = P(self.expr_ident(pat.span, val_ident, val_pat_hid));
let next_expr = P(self.expr_ident(pat.span, next_ident, next_pat_hid));
let assign =
P(self.expr(pat.span, hir::ExprKind::Assign(next_expr, val_expr), ThinVec::new()));
let assign = P(self.expr(
pat.span,
hir::ExprKind::Assign(next_expr, val_expr, pat.span),
ThinVec::new(),
));
let some_pat = self.pat_some(pat.span, val_pat);
self.arm(some_pat, assign)
};
@@ -1628,7 +1628,7 @@ pub enum ExprKind {
Block(P<Block>, Option<Label>),

/// An assignment (e.g., `a = foo()`).
Assign(P<Expr>, P<Expr>),
Assign(P<Expr>, P<Expr>, Span),
/// An assignment with an operator.
///
/// E.g., `a += 1`.
@@ -1289,7 +1289,7 @@ impl<'a> State<'a> {
self.ibox(0);
self.print_block(&blk);
}
hir::ExprKind::Assign(ref lhs, ref rhs) => {
hir::ExprKind::Assign(ref lhs, ref rhs, _) => {
let prec = AssocOp::Assign.precedence() as i8;
self.print_expr_maybe_paren(&lhs, prec + 1);
self.s.space();
@@ -2265,7 +2265,7 @@ fn contains_exterior_struct_lit(value: &hir::Expr) -> bool {
match value.kind {
hir::ExprKind::Struct(..) => true,

hir::ExprKind::Assign(ref lhs, ref rhs)
hir::ExprKind::Assign(ref lhs, ref rhs, _)
| hir::ExprKind::AssignOp(_, ref lhs, ref rhs)
| hir::ExprKind::Binary(_, ref lhs, ref rhs) => {
// `X { y: 1 } + X { y: 2 }`
@@ -490,7 +490,7 @@ impl EarlyLintPass for UnusedParens {
(value, "`return` value", false, Some(left), None)
}

Assign(_, ref value) => (value, "assigned value", false, None, None),
Assign(_, ref value, _) => (value, "assigned value", false, None, None),
AssignOp(.., ref value) => (value, "assigned value", false, None, None),
// either function/method call, or something this lint doesn't care about
ref call_or_other => {
@@ -227,7 +227,7 @@ fn make_mirror_unadjusted<'a, 'tcx>(cx: &mut Cx<'a, 'tcx>, expr: &'tcx hir::Expr

hir::ExprKind::Block(ref blk, _) => ExprKind::Block { body: &blk },

hir::ExprKind::Assign(ref lhs, ref rhs) => {
hir::ExprKind::Assign(ref lhs, ref rhs, _) => {
ExprKind::Assign { lhs: lhs.to_ref(), rhs: rhs.to_ref() }
}

@@ -281,7 +281,9 @@ impl<'a> Parser<'a> {
let binary = self.mk_binary(source_map::respan(cur_op_span, ast_op), lhs, rhs);
self.mk_expr(span, binary, AttrVec::new())
}
AssocOp::Assign => self.mk_expr(span, ExprKind::Assign(lhs, rhs), AttrVec::new()),
AssocOp::Assign => {
self.mk_expr(span, ExprKind::Assign(lhs, rhs, cur_op_span), AttrVec::new())
}
AssocOp::AssignOp(k) => {
let aop = match k {
token::Plus => BinOpKind::Add,
@@ -1079,7 +1079,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
.unwrap_or_else(|| span_bug!(expr.span, "continue to unknown label"))
}

hir::ExprKind::Assign(ref l, ref r) => {
hir::ExprKind::Assign(ref l, ref r, _) => {
// see comment on places in
// propagate_through_place_components()
let succ = self.write_place(&l, succ, ACC_WRITE);
@@ -1373,7 +1373,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Liveness<'a, 'tcx> {

fn check_expr<'tcx>(this: &mut Liveness<'_, 'tcx>, expr: &'tcx Expr) {
match expr.kind {
hir::ExprKind::Assign(ref l, _) => {
hir::ExprKind::Assign(ref l, ..) => {
this.check_place(&l);
}

@@ -1251,7 +1251,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypePrivacyVisitor<'a, 'tcx> {
return;
}
match expr.kind {
hir::ExprKind::Assign(.., ref rhs) | hir::ExprKind::Match(ref rhs, ..) => {
hir::ExprKind::Assign(_, ref rhs, _) | hir::ExprKind::Match(ref rhs, ..) => {
// Do not report duplicate errors for `x = y` and `match x { ... }`.
if self.check_expr_pat_type(rhs.hir_id, rhs.span) {
return;
@@ -492,7 +492,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
String::new()
};
if let Some(hir::Node::Expr(hir::Expr {
kind: hir::ExprKind::Assign(left_expr, _),
kind: hir::ExprKind::Assign(left_expr, ..),
..
})) = self.tcx.hir().find(self.tcx.hir().get_parent_node(expr.hir_id))
{
@@ -219,7 +219,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
ExprKind::Box(ref subexpr) => self.check_expr_box(subexpr, expected),
ExprKind::Lit(ref lit) => self.check_lit(&lit, expected),
ExprKind::Binary(op, ref lhs, ref rhs) => self.check_binop(expr, op, lhs, rhs),
ExprKind::AssignOp(op, ref lhs, ref rhs) => self.check_binop_assign(expr, op, lhs, rhs),
ExprKind::Assign(ref lhs, ref rhs, ref span) => {
self.check_binop_assign(expr, op, lhs, rhs)
}
ExprKind::Unary(unop, ref oprnd) => {
self.check_expr_unary(unop, oprnd, expected, needs, expr)
}
@@ -245,7 +247,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
}
ExprKind::Ret(ref expr_opt) => self.check_expr_return(expr_opt.as_deref(), expr),
ExprKind::Assign(ref lhs, ref rhs) => self.check_expr_assign(expr, expected, lhs, rhs),
ExprKind::Loop(ref body, _, source) => {
self.check_expr_loop(body, source, expected, expr)
}
@@ -767,6 +768,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
expected: Expectation<'tcx>,
lhs: &'tcx hir::Expr,
rhs: &'tcx hir::Expr,
span: &Span,
) -> Ty<'tcx> {
let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
@@ -789,7 +791,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
err.emit();
} else {
self.check_lhs_assignable(lhs, "E0070", &expr.span);
self.check_lhs_assignable(lhs, "E0070", span);
}

self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
@@ -286,7 +286,7 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> {
}
}

hir::ExprKind::Assign(ref lhs, ref rhs) => {
hir::ExprKind::Assign(ref lhs, ref rhs, _) => {
self.mutate_expr(lhs);
self.consume_expr(rhs);
}
@@ -1216,7 +1216,7 @@ pub enum ExprKind {
TryBlock(P<Block>),

/// An assignment (`a = foo()`).
Assign(P<Expr>, P<Expr>),
Assign(P<Expr>, P<Expr>, Span),
/// An assignment with an operator.
///
/// E.g., `a += 1`.
@@ -1168,7 +1168,7 @@ pub fn noop_visit_expr<T: MutVisitor>(Expr { kind, id, span, attrs }: &mut Expr,
vis.visit_block(body);
}
ExprKind::Await(expr) => vis.visit_expr(expr),
ExprKind::Assign(el, er) => {
ExprKind::Assign(el, er, _) => {
vis.visit_expr(el);
vis.visit_expr(er);
}
@@ -2041,7 +2041,7 @@ impl<'a> State<'a> {
self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX);
self.s.word(".await");
}
ast::ExprKind::Assign(ref lhs, ref rhs) => {
ast::ExprKind::Assign(ref lhs, ref rhs, _) => {
let prec = AssocOp::Assign.precedence() as i8;
self.print_expr_maybe_paren(lhs, prec + 1);
self.s.space();
@@ -378,7 +378,7 @@ pub fn contains_exterior_struct_lit(value: &ast::Expr) -> bool {
match value.kind {
ast::ExprKind::Struct(..) => true,

ast::ExprKind::Assign(ref lhs, ref rhs)
ast::ExprKind::Assign(ref lhs, ref rhs, _)
| ast::ExprKind::AssignOp(_, ref lhs, ref rhs)
| ast::ExprKind::Binary(_, ref lhs, ref rhs) => {
// X { y: 1 } + X { y: 2 }
@@ -766,9 +766,9 @@ pub fn walk_expr<'a, V: Visitor<'a>>(visitor: &mut V, expression: &'a Expr) {
visitor.visit_block(body);
}
ExprKind::Await(ref expr) => visitor.visit_expr(expr),
ExprKind::Assign(ref left_hand_expression, ref right_hand_expression) => {
visitor.visit_expr(left_hand_expression);
visitor.visit_expr(right_hand_expression);
ExprKind::Assign(ref lhs, ref rhs, _) => {
visitor.visit_expr(lhs);
visitor.visit_expr(rhs);
}
ExprKind::AssignOp(_, ref left_expression, ref right_expression) => {
visitor.visit_expr(left_expression);
@@ -126,8 +126,8 @@ fn iter_exprs(depth: usize, f: &mut dyn FnMut(P<Expr>)) {
DUMMY_SP)));
},
12 => {
iter_exprs(depth - 1, &mut |e| g(ExprKind::Assign(e, make_x())));
iter_exprs(depth - 1, &mut |e| g(ExprKind::Assign(make_x(), e)));
iter_exprs(depth - 1, &mut |e| g(ExprKind::Assign(e, make_x(), DUMMY_SP)));
iter_exprs(depth - 1, &mut |e| g(ExprKind::Assign(make_x(), e, DUMMY_SP)));
},
13 => {
iter_exprs(depth - 1, &mut |e| g(ExprKind::Field(e, Ident::from_str("f"))));
@@ -1,8 +1,8 @@
error[E0070]: invalid left-hand side of assignment
--> $DIR/bad-expr-lhs.rs:2:5
--> $DIR/bad-expr-lhs.rs:2:7
|
LL | 1 = 2;
| -^^^^
| - ^
| |
| cannot assign to this expression

@@ -15,29 +15,29 @@ LL | 1 += 2;
| cannot assign to this expression

error[E0070]: invalid left-hand side of assignment
--> $DIR/bad-expr-lhs.rs:4:5
--> $DIR/bad-expr-lhs.rs:4:12
|
LL | (1, 2) = (3, 4);
| ------^^^^^^^^^
| ------ ^
| |
| cannot assign to this expression

error[E0070]: invalid left-hand side of assignment
--> $DIR/bad-expr-lhs.rs:7:5
--> $DIR/bad-expr-lhs.rs:7:12
|
LL | (a, b) = (3, 4);
| ------^^^^^^^^^
| ------ ^
| |
| cannot assign to this expression
|
= note: destructuring assignments are not yet supported
= note: for more information, see https://github.com/rust-lang/rfcs/issues/372

error[E0070]: invalid left-hand side of assignment
--> $DIR/bad-expr-lhs.rs:9:5
--> $DIR/bad-expr-lhs.rs:9:10
|
LL | None = Some(3);
| ----^^^^^^^^^^
| ---- ^
| |
| cannot assign to this expression

@@ -1,8 +1,8 @@
error[E0070]: invalid left-hand side of assignment
--> $DIR/destructuring-assignment.rs:6:5
--> $DIR/destructuring-assignment.rs:6:12
|
LL | (a, b) = (3, 4);
| ------^^^^^^^^^
| ------ ^
| |
| cannot assign to this expression
|
@@ -31,10 +31,10 @@ LL | (a, b) += (3, 4);
= note: for more information, see https://github.com/rust-lang/rfcs/issues/372

error[E0070]: invalid left-hand side of assignment
--> $DIR/destructuring-assignment.rs:10:5
--> $DIR/destructuring-assignment.rs:10:12
|
LL | [a, b] = [3, 4];
| ------^^^^^^^^^
| ------ ^
| |
| cannot assign to this expression
|
@@ -63,10 +63,10 @@ LL | [a, b] += [3, 4];
= note: for more information, see https://github.com/rust-lang/rfcs/issues/372

error[E0070]: invalid left-hand side of assignment
--> $DIR/destructuring-assignment.rs:16:5
--> $DIR/destructuring-assignment.rs:16:22
|
LL | S { x: a, y: b } = s;
| ----------------^^^^
| ---------------- ^
| |
| cannot assign to this expression
|
@@ -95,21 +95,21 @@ LL | S { x: a, y: b } += s;
= note: for more information, see https://github.com/rust-lang/rfcs/issues/372

error[E0070]: invalid left-hand side of assignment
--> $DIR/destructuring-assignment.rs:20:5
--> $DIR/destructuring-assignment.rs:20:21
|
LL | S { x: a, ..s } = S { x: 3, y: 4 };
| ---------------^^^^^^^^^^^^^^^^^^^
| --------------- ^
| |
| cannot assign to this expression
|
= note: destructuring assignments are not yet supported
= note: for more information, see https://github.com/rust-lang/rfcs/issues/372

error[E0070]: invalid left-hand side of assignment
--> $DIR/destructuring-assignment.rs:24:5
--> $DIR/destructuring-assignment.rs:24:17
|
LL | ((a, b), c) = ((3, 4), 5);
| -----------^^^^^^^^^^^^^^
| ----------- ^
| |
| cannot assign to this expression
|
@@ -1,16 +1,16 @@
error[E0070]: invalid left-hand side of assignment
--> $DIR/E0070.rs:6:5
--> $DIR/E0070.rs:6:16
|
LL | SOME_CONST = 14;
| ----------^^^^^
| ---------- ^
| |
| cannot assign to this expression

error[E0070]: invalid left-hand side of assignment
--> $DIR/E0070.rs:7:5
--> $DIR/E0070.rs:7:7
|
LL | 1 = 3;
| -^^^^
| - ^
| |
| cannot assign to this expression

@@ -21,10 +21,10 @@ LL | some_other_func() = 4;
| ^ expected `()`, found integer

error[E0070]: invalid left-hand side of assignment
--> $DIR/E0070.rs:8:5
--> $DIR/E0070.rs:8:23
|
LL | some_other_func() = 4;
| -----------------^^^^
| ----------------- ^
| |
| cannot assign to this expression

@@ -11,10 +11,10 @@ LL | A::C = 1;
| ^ expected struct `A::C`, found integer

error[E0070]: invalid left-hand side of assignment
--> $DIR/issue-13407.rs:6:5
--> $DIR/issue-13407.rs:6:10
|
LL | A::C = 1;
| ----^^^^
| ---- ^
| |
| cannot assign to this expression

0 comments on commit 35979a9

Please sign in to comment.
You can’t perform that action at this time.