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);
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),
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)
};
Block(P<Block>, Option<Label>),
/// An assignment (e.g., `a = foo()`).
- Assign(P<Expr>, P<Expr>),
+ /// The `Span` argument is the span of the `=` token.
+ Assign(P<Expr>, P<Expr>, Span),
/// An assignment with an operator.
///
/// E.g., `a += 1`.
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();
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 }`
(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 => {
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() }
}
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,
for predicate in &generics.where_clause.predicates {
if let WherePredicate::EqPredicate(ref predicate) = *predicate {
self.err_handler()
- .span_err(predicate.span, "equality constraints are not yet \
- supported in where clauses (see #20041)");
+ .struct_span_err(
+ predicate.span,
+ "equality constraints are not yet supported in `where` clauses",
+ )
+ .note(
+ "for more information, see https://github.com/rust-lang/rust/issues/20041",
+ )
+ .emit();
}
}
.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);
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);
}
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;
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))
{
use crate::util::common::ErrorReported;
use crate::util::nodemap::FxHashMap;
-use errors::{pluralize, Applicability, DiagnosticBuilder};
+use errors::{pluralize, Applicability, DiagnosticBuilder, DiagnosticId};
use rustc::hir;
use rustc::hir::def::{CtorKind, DefKind, Res};
use rustc::hir::def_id::DefId;
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::Assign(ref lhs, ref rhs, ref span) => {
+ self.check_expr_assign(expr, expected, lhs, rhs, span)
+ }
ExprKind::AssignOp(op, ref lhs, ref rhs) => self.check_binop_assign(expr, op, lhs, rhs),
ExprKind::Unary(unop, ref oprnd) => {
self.check_expr_unary(unop, oprnd, expected, needs, expr)
}
}
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)
}
);
}
+ fn is_destructuring_place_expr(&self, expr: &'tcx hir::Expr) -> bool {
+ match &expr.kind {
+ ExprKind::Array(comps) | ExprKind::Tup(comps) => {
+ comps.iter().all(|e| self.is_destructuring_place_expr(e))
+ }
+ ExprKind::Struct(_path, fields, rest) => {
+ rest.as_ref().map(|e| self.is_destructuring_place_expr(e)).unwrap_or(true)
+ && fields.iter().all(|f| self.is_destructuring_place_expr(&f.expr))
+ }
+ _ => expr.is_syntactic_place_expr(),
+ }
+ }
+
+ pub(crate) fn check_lhs_assignable(
+ &self,
+ lhs: &'tcx hir::Expr,
+ err_code: &'static str,
+ expr_span: &Span,
+ ) {
+ if !lhs.is_syntactic_place_expr() {
+ let mut err = self.tcx.sess.struct_span_err_with_code(
+ *expr_span,
+ "invalid left-hand side of assignment",
+ DiagnosticId::Error(err_code.into()),
+ );
+ err.span_label(lhs.span, "cannot assign to this expression");
+ if self.is_destructuring_place_expr(lhs) {
+ err.note("destructuring assignments are not currently supported");
+ err.note("for more information, see https://github.com/rust-lang/rfcs/issues/372");
+ }
+ err.emit();
+ }
+ }
+
/// Type check assignment expression `expr` of form `lhs = rhs`.
/// The expected type is `()` and is passsed to the function for the purposes of diagnostics.
fn check_expr_assign(
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);
err.help(msg);
}
err.emit();
- } else if !lhs.is_syntactic_place_expr() {
- struct_span_err!(self.tcx.sess, expr.span, E0070, "invalid left-hand side expression")
- .span_label(expr.span, "left-hand of expression not valid")
- .emit();
+ } else {
+ self.check_lhs_assignable(lhs, "E0070", span);
}
self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
&self,
expr: &'tcx hir::Expr,
op: hir::BinOp,
- lhs_expr: &'tcx hir::Expr,
- rhs_expr: &'tcx hir::Expr,
+ lhs: &'tcx hir::Expr,
+ rhs: &'tcx hir::Expr,
) -> Ty<'tcx> {
let (lhs_ty, rhs_ty, return_ty) =
- self.check_overloaded_binop(expr, lhs_expr, rhs_expr, op, IsAssign::Yes);
+ self.check_overloaded_binop(expr, lhs, rhs, op, IsAssign::Yes);
let ty =
if !lhs_ty.is_ty_var() && !rhs_ty.is_ty_var() && is_builtin_binop(lhs_ty, rhs_ty, op) {
- self.enforce_builtin_binop_types(lhs_expr, lhs_ty, rhs_expr, rhs_ty, op);
+ self.enforce_builtin_binop_types(lhs, lhs_ty, rhs, rhs_ty, op);
self.tcx.mk_unit()
} else {
return_ty
};
- if !lhs_expr.is_syntactic_place_expr() {
- struct_span_err!(
- self.tcx.sess,
- lhs_expr.span,
- E0067,
- "invalid left-hand side expression"
- )
- .span_label(lhs_expr.span, "invalid expression for left-hand side")
- .emit();
- }
+ self.check_lhs_assignable(lhs, "E0067", &op.span);
+
ty
}
}
}
- hir::ExprKind::Assign(ref lhs, ref rhs) => {
+ hir::ExprKind::Assign(ref lhs, ref rhs, _) => {
self.mutate_expr(lhs);
self.consume_expr(rhs);
}
TryBlock(P<Block>),
/// An assignment (`a = foo()`).
- Assign(P<Expr>, P<Expr>),
+ /// The `Span` argument is the span of the `=` token.
+ Assign(P<Expr>, P<Expr>, Span),
/// An assignment with an operator.
///
/// E.g., `a += 1`.
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);
}
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();
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 }
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);
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"))));
fn main() {
- 1 = 2; //~ ERROR invalid left-hand side expression
- 1 += 2; //~ ERROR invalid left-hand side expression
- (1, 2) = (3, 4); //~ ERROR invalid left-hand side expression
+ 1 = 2; //~ ERROR invalid left-hand side of assignment
+ 1 += 2; //~ ERROR invalid left-hand side of assignment
+ (1, 2) = (3, 4); //~ ERROR invalid left-hand side of assignment
let (a, b) = (1, 2);
- (a, b) = (3, 4); //~ ERROR invalid left-hand side expression
+ (a, b) = (3, 4); //~ ERROR invalid left-hand side of assignment
- None = Some(3); //~ ERROR invalid left-hand side expression
+ None = Some(3); //~ ERROR invalid left-hand side of assignment
}
-error[E0070]: invalid left-hand side expression
- --> $DIR/bad-expr-lhs.rs:2:5
+error[E0070]: invalid left-hand side of assignment
+ --> $DIR/bad-expr-lhs.rs:2:7
|
LL | 1 = 2;
- | ^^^^^ left-hand of expression not valid
+ | - ^
+ | |
+ | cannot assign to this expression
-error[E0067]: invalid left-hand side expression
- --> $DIR/bad-expr-lhs.rs:3:5
+error[E0067]: invalid left-hand side of assignment
+ --> $DIR/bad-expr-lhs.rs:3:7
|
LL | 1 += 2;
- | ^ invalid expression for left-hand side
+ | - ^^
+ | |
+ | cannot assign to this expression
-error[E0070]: invalid left-hand side expression
- --> $DIR/bad-expr-lhs.rs:4:5
+error[E0070]: invalid left-hand side of assignment
+ --> $DIR/bad-expr-lhs.rs:4:12
|
LL | (1, 2) = (3, 4);
- | ^^^^^^^^^^^^^^^ left-hand of expression not valid
+ | ------ ^
+ | |
+ | cannot assign to this expression
-error[E0070]: invalid left-hand side expression
- --> $DIR/bad-expr-lhs.rs:7:5
+error[E0070]: invalid left-hand side of assignment
+ --> $DIR/bad-expr-lhs.rs:7:12
|
LL | (a, b) = (3, 4);
- | ^^^^^^^^^^^^^^^ left-hand of expression not valid
+ | ------ ^
+ | |
+ | cannot assign to this expression
+ |
+ = note: destructuring assignments are not currently supported
+ = note: for more information, see https://github.com/rust-lang/rfcs/issues/372
-error[E0070]: invalid left-hand side expression
- --> $DIR/bad-expr-lhs.rs:9:5
+error[E0070]: invalid left-hand side of assignment
+ --> $DIR/bad-expr-lhs.rs:9:10
|
LL | None = Some(3);
- | ^^^^^^^^^^^^^^ left-hand of expression not valid
+ | ---- ^
+ | |
+ | cannot assign to this expression
error: aborting due to 5 previous errors
--- /dev/null
+struct S { x: u8, y: u8 }
+
+fn main() {
+ let (a, b) = (1, 2);
+
+ (a, b) = (3, 4); //~ ERROR invalid left-hand side of assignment
+ (a, b) += (3, 4); //~ ERROR invalid left-hand side of assignment
+ //~^ ERROR binary assignment operation `+=` cannot be applied
+
+ [a, b] = [3, 4]; //~ ERROR invalid left-hand side of assignment
+ [a, b] += [3, 4]; //~ ERROR invalid left-hand side of assignment
+ //~^ ERROR binary assignment operation `+=` cannot be applied
+
+ let s = S { x: 3, y: 4 };
+
+ S { x: a, y: b } = s; //~ ERROR invalid left-hand side of assignment
+ S { x: a, y: b } += s; //~ ERROR invalid left-hand side of assignment
+ //~^ ERROR binary assignment operation `+=` cannot be applied
+
+ S { x: a, ..s } = S { x: 3, y: 4 }; //~ ERROR invalid left-hand side of assignment
+
+ let c = 3;
+
+ ((a, b), c) = ((3, 4), 5); //~ ERROR invalid left-hand side of assignment
+}
--- /dev/null
+error[E0070]: invalid left-hand side of assignment
+ --> $DIR/note-unsupported.rs:6:12
+ |
+LL | (a, b) = (3, 4);
+ | ------ ^
+ | |
+ | cannot assign to this expression
+ |
+ = note: destructuring assignments are not currently supported
+ = note: for more information, see https://github.com/rust-lang/rfcs/issues/372
+
+error[E0368]: binary assignment operation `+=` cannot be applied to type `({integer}, {integer})`
+ --> $DIR/note-unsupported.rs:7:5
+ |
+LL | (a, b) += (3, 4);
+ | ------^^^^^^^^^^
+ | |
+ | cannot use `+=` on type `({integer}, {integer})`
+ |
+ = note: an implementation of `std::ops::AddAssign` might be missing for `({integer}, {integer})`
+
+error[E0067]: invalid left-hand side of assignment
+ --> $DIR/note-unsupported.rs:7:12
+ |
+LL | (a, b) += (3, 4);
+ | ------ ^^
+ | |
+ | cannot assign to this expression
+ |
+ = note: destructuring assignments are not currently supported
+ = note: for more information, see https://github.com/rust-lang/rfcs/issues/372
+
+error[E0070]: invalid left-hand side of assignment
+ --> $DIR/note-unsupported.rs:10:12
+ |
+LL | [a, b] = [3, 4];
+ | ------ ^
+ | |
+ | cannot assign to this expression
+ |
+ = note: destructuring assignments are not currently supported
+ = note: for more information, see https://github.com/rust-lang/rfcs/issues/372
+
+error[E0368]: binary assignment operation `+=` cannot be applied to type `[{integer}; 2]`
+ --> $DIR/note-unsupported.rs:11:5
+ |
+LL | [a, b] += [3, 4];
+ | ------^^^^^^^^^^
+ | |
+ | cannot use `+=` on type `[{integer}; 2]`
+ |
+ = note: an implementation of `std::ops::AddAssign` might be missing for `[{integer}; 2]`
+
+error[E0067]: invalid left-hand side of assignment
+ --> $DIR/note-unsupported.rs:11:12
+ |
+LL | [a, b] += [3, 4];
+ | ------ ^^
+ | |
+ | cannot assign to this expression
+ |
+ = note: destructuring assignments are not currently supported
+ = note: for more information, see https://github.com/rust-lang/rfcs/issues/372
+
+error[E0070]: invalid left-hand side of assignment
+ --> $DIR/note-unsupported.rs:16:22
+ |
+LL | S { x: a, y: b } = s;
+ | ---------------- ^
+ | |
+ | cannot assign to this expression
+ |
+ = note: destructuring assignments are not currently supported
+ = note: for more information, see https://github.com/rust-lang/rfcs/issues/372
+
+error[E0368]: binary assignment operation `+=` cannot be applied to type `S`
+ --> $DIR/note-unsupported.rs:17:5
+ |
+LL | S { x: a, y: b } += s;
+ | ----------------^^^^^
+ | |
+ | cannot use `+=` on type `S`
+ |
+ = note: an implementation of `std::ops::AddAssign` might be missing for `S`
+
+error[E0067]: invalid left-hand side of assignment
+ --> $DIR/note-unsupported.rs:17:22
+ |
+LL | S { x: a, y: b } += s;
+ | ---------------- ^^
+ | |
+ | cannot assign to this expression
+ |
+ = note: destructuring assignments are not currently supported
+ = note: for more information, see https://github.com/rust-lang/rfcs/issues/372
+
+error[E0070]: invalid left-hand side of assignment
+ --> $DIR/note-unsupported.rs:20:21
+ |
+LL | S { x: a, ..s } = S { x: 3, y: 4 };
+ | --------------- ^
+ | |
+ | cannot assign to this expression
+ |
+ = note: destructuring assignments are not currently supported
+ = note: for more information, see https://github.com/rust-lang/rfcs/issues/372
+
+error[E0070]: invalid left-hand side of assignment
+ --> $DIR/note-unsupported.rs:24:17
+ |
+LL | ((a, b), c) = ((3, 4), 5);
+ | ----------- ^
+ | |
+ | cannot assign to this expression
+ |
+ = note: destructuring assignments are not currently supported
+ = note: for more information, see https://github.com/rust-lang/rfcs/issues/372
+
+error: aborting due to 11 previous errors
+
+Some errors have detailed explanations: E0067, E0070, E0368.
+For more information about an error, try `rustc --explain E0067`.
|
= note: an implementation of `std::ops::AddAssign` might be missing for `std::collections::LinkedList<_>`
-error[E0067]: invalid left-hand side expression
- --> $DIR/E0067.rs:4:5
+error[E0067]: invalid left-hand side of assignment
+ --> $DIR/E0067.rs:4:23
|
LL | LinkedList::new() += 1;
- | ^^^^^^^^^^^^^^^^^ invalid expression for left-hand side
+ | ----------------- ^^
+ | |
+ | cannot assign to this expression
error: aborting due to 2 previous errors
-error[E0070]: invalid left-hand side expression
- --> $DIR/E0070.rs:6:5
+error[E0070]: invalid left-hand side of assignment
+ --> $DIR/E0070.rs:6:16
|
LL | SOME_CONST = 14;
- | ^^^^^^^^^^^^^^^ left-hand of expression not valid
+ | ---------- ^
+ | |
+ | cannot assign to this expression
-error[E0070]: invalid left-hand side expression
- --> $DIR/E0070.rs:7:5
+error[E0070]: invalid left-hand side of assignment
+ --> $DIR/E0070.rs:7:7
|
LL | 1 = 3;
- | ^^^^^ left-hand of expression not valid
+ | - ^
+ | |
+ | cannot assign to this expression
error[E0308]: mismatched types
--> $DIR/E0070.rs:8:25
LL | some_other_func() = 4;
| ^ expected `()`, found integer
-error[E0070]: invalid left-hand side expression
- --> $DIR/E0070.rs:8:5
+error[E0070]: invalid left-hand side of assignment
+ --> $DIR/E0070.rs:8:23
|
LL | some_other_func() = 4;
- | ^^^^^^^^^^^^^^^^^^^^^ left-hand of expression not valid
+ | ----------------- ^
+ | |
+ | cannot assign to this expression
error: aborting due to 4 previous errors
fn main() {
A::C = 1;
- //~^ ERROR: invalid left-hand side expression
+ //~^ ERROR: invalid left-hand side of assignment
//~| ERROR: mismatched types
//~| ERROR: struct `C` is private
}
LL | A::C = 1;
| ^ expected struct `A::C`, found integer
-error[E0070]: invalid left-hand side expression
- --> $DIR/issue-13407.rs:6:5
+error[E0070]: invalid left-hand side of assignment
+ --> $DIR/issue-13407.rs:6:10
|
LL | A::C = 1;
- | ^^^^^^^^ left-hand of expression not valid
+ | ---- ^
+ | |
+ | cannot assign to this expression
error: aborting due to 3 previous errors
macro_rules! not_a_place {
($thing:expr) => {
$thing = 42;
- //~^ ERROR invalid left-hand side expression
+ //~^ ERROR invalid left-hand side of assignment
+ $thing += 42;
+ //~^ ERROR invalid left-hand side of assignment
}
}
-error[E0070]: invalid left-hand side expression
- --> $DIR/issue-26093.rs:3:9
+error[E0070]: invalid left-hand side of assignment
+ --> $DIR/issue-26093.rs:3:16
|
LL | $thing = 42;
- | ^^^^^^^^^^^ left-hand of expression not valid
+ | ^
...
LL | not_a_place!(99);
- | ----------------- in this macro invocation
+ | -----------------
+ | | |
+ | | cannot assign to this expression
+ | in this macro invocation
-error: aborting due to previous error
+error[E0067]: invalid left-hand side of assignment
+ --> $DIR/issue-26093.rs:5:16
+ |
+LL | $thing += 42;
+ | ^^
+...
+LL | not_a_place!(99);
+ | -----------------
+ | | |
+ | | cannot assign to this expression
+ | in this macro invocation
+
+error: aborting due to 2 previous errors
-For more information about this error, try `rustc --explain E0070`.
+Some errors have detailed explanations: E0067, E0070.
+For more information about an error, try `rustc --explain E0067`.
//~^ ERROR expected one of `,` or `>`, found `=`
//~| ERROR expected value, found struct `Vec`
//~| ERROR mismatched types
- //~| ERROR invalid left-hand side expression
+ //~| ERROR invalid left-hand side of assignment
//~| ERROR expected expression, found reserved identifier `_`
//~| ERROR expected expression, found reserved identifier `_`
let sr2: Vec<(u32, _, _)> = sr.iter().map(|(faction, th_sender, th_receiver)| {}).collect();
found struct `std::vec::Vec<_>`
= note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
-error[E0070]: invalid left-hand side expression
- --> $DIR/issue-34334.rs:2:13
+error[E0070]: invalid left-hand side of assignment
+ --> $DIR/issue-34334.rs:2:29
|
LL | let sr: Vec<(u32, _, _) = vec![];
- | ^^^^^^^^^^^^^^^^^^^^^^^^ left-hand of expression not valid
+ | --------------- ^
+ | |
+ | cannot assign to this expression
error[E0599]: no method named `iter` found for type `()` in the current scope
--> $DIR/issue-34334.rs:9:36
// A test to check that not expecting `bool` behaves well:
let _: usize = 0 = 0;
//~^ ERROR mismatched types [E0308]
- //~| ERROR invalid left-hand side expression [E0070]
+ //~| ERROR invalid left-hand side of assignment [E0070]
}
| expected `bool`, found `()`
| help: try comparing for equality: `0 == 0`
-error[E0070]: invalid left-hand side expression
- --> $DIR/assignment-expected-bool.rs:31:20
+error[E0070]: invalid left-hand side of assignment
+ --> $DIR/assignment-expected-bool.rs:31:22
|
LL | let _: usize = 0 = 0;
- | ^^^^^ left-hand of expression not valid
+ | - ^
+ | |
+ | cannot assign to this expression
error[E0308]: mismatched types
--> $DIR/assignment-expected-bool.rs:31:20
//~^ ERROR mismatched types
println!("{}", x);
}
- // "invalid left-hand side expression" error is suppresed
+ // "invalid left-hand side of assignment" error is suppresed
if 3 = x {
//~^ ERROR mismatched types
println!("{}", x);
fn f() where u8 = u16 {}
-//~^ ERROR equality constraints are not yet supported in where clauses
+//~^ ERROR equality constraints are not yet supported in `where` clauses
fn g() where for<'a> &'static (u8,) == u16, {}
-//~^ ERROR equality constraints are not yet supported in where clauses
+//~^ ERROR equality constraints are not yet supported in `where` clauses
fn main() {}
-error: equality constraints are not yet supported in where clauses (see #20041)
+error: equality constraints are not yet supported in `where` clauses
--> $DIR/where-equality-constraints.rs:1:14
|
LL | fn f() where u8 = u16 {}
| ^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/20041
-error: equality constraints are not yet supported in where clauses (see #20041)
+error: equality constraints are not yet supported in `where` clauses
--> $DIR/where-equality-constraints.rs:3:14
|
LL | fn g() where for<'a> &'static (u8,) == u16, {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/20041
error: aborting due to 2 previous errors
projects / rust.git / commitdiff