fn lower_expr(&mut self, e: &Expr) -> hir::Expr {
let kind = match e.node {
ExprKind::Box(ref inner) => hir::ExprKind::Box(P(self.lower_expr(inner))),
- ExprKind::ObsoleteInPlace(..) => {
- self.sess.abort_if_errors();
- span_bug!(e.span, "encountered ObsoleteInPlace expr during lowering");
- }
ExprKind::Array(ref exprs) => {
hir::ExprKind::Array(exprs.iter().map(|x| self.lower_expr(x)).collect())
}
ExprKind::InlineAsm(..) if !self.session.target.target.options.allow_asm => {
span_err!(self.session, expr.span, E0472, "asm! is unsupported on this target");
}
- ExprKind::ObsoleteInPlace(ref place, ref val) => {
- let mut err = self.err_handler().struct_span_err(
- expr.span,
- "emplacement syntax is obsolete (for now, anyway)",
- );
- err.note(
- "for more information, see \
- <https://github.com/rust-lang/rust/issues/27779#issuecomment-378416911>"
- );
- match val.node {
- ExprKind::Lit(ref v) if v.node.is_numeric() => {
- err.span_suggestion(
- place.span.between(val.span),
- "if you meant to write a comparison against a negative value, add a \
- space in between `<` and `-`",
- "< -".to_string(),
- Applicability::MaybeIncorrect
- );
- }
- _ => {}
- }
- err.emit();
- }
_ => {}
}
pub fn precedence(&self) -> ExprPrecedence {
match self.node {
ExprKind::Box(_) => ExprPrecedence::Box,
- ExprKind::ObsoleteInPlace(..) => ExprPrecedence::ObsoleteInPlace,
ExprKind::Array(_) => ExprPrecedence::Array,
ExprKind::Call(..) => ExprPrecedence::Call,
ExprKind::MethodCall(..) => ExprPrecedence::MethodCall,
pub enum ExprKind {
/// A `box x` expression.
Box(P<Expr>),
- /// First expr is the place; second expr is the value.
- ObsoleteInPlace(P<Expr>, P<Expr>),
/// An array (`[a, b, c, d]`)
Array(Vec<P<Expr>>),
/// A function call
"type ascription is experimental");
}
}
- ast::ExprKind::ObsoleteInPlace(..) => {
- // these get a hard error in ast-validation
- }
ast::ExprKind::Yield(..) => {
gate_feature_post!(&self, generators,
e.span,
pub fn noop_visit_expr<T: MutVisitor>(Expr { node, id, span, attrs }: &mut Expr, vis: &mut T) {
match node {
ExprKind::Box(expr) => vis.visit_expr(expr),
- ExprKind::ObsoleteInPlace(a, b) => {
- vis.visit_expr(a);
- vis.visit_expr(b);
- }
ExprKind::Array(exprs) => visit_exprs(exprs, vis),
ExprKind::Repeat(expr, count) => {
vis.visit_expr(expr);
let (span, e) = self.interpolated_or_expr_span(e)?;
(lo.to(span), ExprKind::AddrOf(m, e))
}
- token::Ident(..) if self.token.is_keyword(kw::In) => {
- self.bump();
- let place = self.parse_expr_res(
- Restrictions::NO_STRUCT_LITERAL,
- None,
- )?;
- let blk = self.parse_block()?;
- let span = blk.span;
- let blk_expr = self.mk_expr(span, ExprKind::Block(blk, None), ThinVec::new());
- (lo.to(span), ExprKind::ObsoleteInPlace(place, blk_expr))
- }
token::Ident(..) if self.token.is_keyword(kw::Box) => {
self.bump();
let e = self.parse_prefix_expr(None);
self.mk_expr(span, binary, ThinVec::new())
}
AssocOp::Assign => self.mk_expr(span, ExprKind::Assign(lhs, rhs), ThinVec::new()),
- AssocOp::ObsoleteInPlace =>
- self.mk_expr(span, ExprKind::ObsoleteInPlace(lhs, rhs), ThinVec::new()),
AssocOp::AssignOp(k) => {
let aop = match k {
token::Plus => BinOpKind::Add,
String::new(),
Applicability::MachineApplicable,
);
- err.note("if you meant to use emplacement syntax, it is obsolete (for now, anyway)");
- err.note("for more information on the status of emplacement syntax, see <\
- https://github.com/rust-lang/rust/issues/27779#issuecomment-378416911>");
err.emit();
}
let expr = self.parse_expr_res(Restrictions::NO_STRUCT_LITERAL, None)?;
self.word_space("box")?;
self.print_expr_maybe_paren(expr, parser::PREC_PREFIX)?;
}
- ast::ExprKind::ObsoleteInPlace(ref place, ref expr) => {
- let prec = AssocOp::ObsoleteInPlace.precedence() as i8;
- self.print_expr_maybe_paren(place, prec + 1)?;
- self.s.space()?;
- self.word_space("<-")?;
- self.print_expr_maybe_paren(expr, prec)?;
- }
ast::ExprKind::Array(ref exprs) => {
self.print_expr_vec(&exprs[..], attrs)?;
}
GreaterEqual,
/// `=`
Assign,
- /// `<-`
- ObsoleteInPlace,
/// `?=` where ? is one of the BinOpToken
AssignOp(BinOpToken),
/// `as`
use AssocOp::*;
match *t {
Token::BinOpEq(k) => Some(AssignOp(k)),
- Token::LArrow => Some(ObsoleteInPlace),
Token::Eq => Some(Assign),
Token::BinOp(BinOpToken::Star) => Some(Multiply),
Token::BinOp(BinOpToken::Slash) => Some(Divide),
LAnd => 6,
LOr => 5,
DotDot | DotDotEq => 4,
- ObsoleteInPlace => 3,
Assign | AssignOp(_) => 2,
}
}
use AssocOp::*;
// NOTE: it is a bug to have an operators that has same precedence but different fixities!
match *self {
- ObsoleteInPlace | Assign | AssignOp(_) => Fixity::Right,
+ Assign | AssignOp(_) => Fixity::Right,
As | Multiply | Divide | Modulus | Add | Subtract | ShiftLeft | ShiftRight | BitAnd |
BitXor | BitOr | Less | Greater | LessEqual | GreaterEqual | Equal | NotEqual |
LAnd | LOr | Colon => Fixity::Left,
use AssocOp::*;
match *self {
Less | Greater | LessEqual | GreaterEqual | Equal | NotEqual => true,
- ObsoleteInPlace | Assign | AssignOp(_) | As | Multiply | Divide | Modulus | Add |
+ Assign | AssignOp(_) | As | Multiply | Divide | Modulus | Add |
Subtract | ShiftLeft | ShiftRight | BitAnd | BitXor | BitOr | LAnd | LOr |
DotDot | DotDotEq | Colon => false
}
pub fn is_assign_like(&self) -> bool {
use AssocOp::*;
match *self {
- Assign | AssignOp(_) | ObsoleteInPlace => true,
+ Assign | AssignOp(_) => true,
Less | Greater | LessEqual | GreaterEqual | Equal | NotEqual | As | Multiply | Divide |
Modulus | Add | Subtract | ShiftLeft | ShiftRight | BitAnd | BitXor | BitOr | LAnd |
LOr | DotDot | DotDotEq | Colon => false
BitOr => Some(BinOpKind::BitOr),
LAnd => Some(BinOpKind::And),
LOr => Some(BinOpKind::Or),
- ObsoleteInPlace | Assign | AssignOp(_) | As | DotDot | DotDotEq | Colon => None
+ Assign | AssignOp(_) | As | DotDot | DotDotEq | Colon => None
}
}
Binary(BinOpKind),
- ObsoleteInPlace,
Cast,
Type,
// Binop-like expr kinds, handled by `AssocOp`.
ExprPrecedence::Binary(op) => AssocOp::from_ast_binop(op).precedence() as i8,
- ExprPrecedence::ObsoleteInPlace => AssocOp::ObsoleteInPlace.precedence() as i8,
ExprPrecedence::Cast => AssocOp::As.precedence() as i8,
ExprPrecedence::Type => AssocOp::Colon.precedence() as i8,
ExprKind::Box(ref subexpression) => {
visitor.visit_expr(subexpression)
}
- ExprKind::ObsoleteInPlace(ref place, ref subexpression) => {
- visitor.visit_expr(place);
- visitor.visit_expr(subexpression)
- }
ExprKind::Array(ref subexpressions) => {
walk_list!(visitor, visit_expr, subexpressions);
}