bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Rollup merge of #81909 - wcampbell0x2a:remove-unnecessary-refs, r=estebank

Browse source 
[compiler/rustc_typeck/src/check/expr.rs] Remove unnecessary refs in pattern matching
This commit is contained in:
Yuki Okushi 2021-02-10 12:24:25 +09:00 • committed by GitHub
commit fff36f199a
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
1 changed files with 34 additions and 36 deletions
Download patch file Download diff file Expand all files Collapse all files

70
compiler/rustc_typeck/src/check/expr.rs
View file

@ -168,7 +168,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// without the final expr (e.g. `try { return; }`). We don't want to generate an // without the final expr (e.g. `try { return; }`). We don't want to generate an
// unreachable_code lint for it since warnings for autogenerated code are confusing. // unreachable_code lint for it since warnings for autogenerated code are confusing.
let is_try_block_generated_unit_expr = match expr.kind { let is_try_block_generated_unit_expr = match expr.kind {
ExprKind::Call(_, ref args) if expr.span.is_desugaring(DesugaringKind::TryBlock) => { ExprKind::Call(_, args) if expr.span.is_desugaring(DesugaringKind::TryBlock) => {
args.len() == 1 && args[0].span.is_desugaring(DesugaringKind::TryBlock) args.len() == 1 && args[0].span.is_desugaring(DesugaringKind::TryBlock)
} }
@ -193,9 +193,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// diverging expression (e.g. it arose from desugaring of `try { return }`), // diverging expression (e.g. it arose from desugaring of `try { return }`),
// we skip issuing a warning because it is autogenerated code. // we skip issuing a warning because it is autogenerated code.
ExprKind::Call(..) if expr.span.is_desugaring(DesugaringKind::TryBlock) => {} ExprKind::Call(..) if expr.span.is_desugaring(DesugaringKind::TryBlock) => {}
ExprKind::Call(ref callee, _) => { ExprKind::Call(callee, _) => self.warn_if_unreachable(expr.hir_id, callee.span, "call"),
self.warn_if_unreachable(expr.hir_id, callee.span, "call")
}
ExprKind::MethodCall(_, ref span, _, _) => { ExprKind::MethodCall(_, ref span, _, _) => {
self.warn_if_unreachable(expr.hir_id, *span, "call") self.warn_if_unreachable(expr.hir_id, *span, "call")
} }
@ -231,15 +229,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let tcx = self.tcx; let tcx = self.tcx;
match expr.kind { match expr.kind {
ExprKind::Box(ref subexpr) => self.check_expr_box(subexpr, expected), ExprKind::Box(subexpr) => self.check_expr_box(subexpr, expected),
ExprKind::Lit(ref lit) => self.check_lit(&lit, 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::Binary(op, lhs, rhs) => self.check_binop(expr, op, lhs, rhs),
ExprKind::Assign(ref lhs, ref rhs, ref span) => { ExprKind::Assign(lhs, rhs, ref span) => {
self.check_expr_assign(expr, expected, lhs, rhs, 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::AssignOp(op, lhs, rhs) => self.check_binop_assign(expr, op, lhs, rhs),
ExprKind::Unary(unop, ref oprnd) => self.check_expr_unary(unop, oprnd, expected, expr), ExprKind::Unary(unop, oprnd) => self.check_expr_unary(unop, oprnd, expected, expr),
ExprKind::AddrOf(kind, mutbl, ref oprnd) => { ExprKind::AddrOf(kind, mutbl, oprnd) => {
self.check_expr_addr_of(kind, mutbl, oprnd, expected, expr) self.check_expr_addr_of(kind, mutbl, oprnd, expected, expr)
} }
ExprKind::Path(QPath::LangItem(lang_item, _)) => { ExprKind::Path(QPath::LangItem(lang_item, _)) => {
@ -247,7 +245,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
} }
ExprKind::Path(ref qpath) => self.check_expr_path(qpath, expr), ExprKind::Path(ref qpath) => self.check_expr_path(qpath, expr),
ExprKind::InlineAsm(asm) => self.check_expr_asm(asm), ExprKind::InlineAsm(asm) => self.check_expr_asm(asm),
ExprKind::LlvmInlineAsm(ref asm) => { ExprKind::LlvmInlineAsm(asm) => {
for expr in asm.outputs_exprs.iter().chain(asm.inputs_exprs.iter()) { for expr in asm.outputs_exprs.iter().chain(asm.inputs_exprs.iter()) {
self.check_expr(expr); self.check_expr(expr);
} }
@ -265,22 +263,22 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
} }
} }
ExprKind::Ret(ref expr_opt) => self.check_expr_return(expr_opt.as_deref(), expr), ExprKind::Ret(ref expr_opt) => self.check_expr_return(expr_opt.as_deref(), expr),
ExprKind::Loop(ref body, _, source, _) => { ExprKind::Loop(body, _, source, _) => {
self.check_expr_loop(body, source, expected, expr) self.check_expr_loop(body, source, expected, expr)
} }
ExprKind::Match(ref discrim, ref arms, match_src) => { ExprKind::Match(discrim, arms, match_src) => {
self.check_match(expr, &discrim, arms, expected, match_src) self.check_match(expr, &discrim, arms, expected, match_src)
} }
ExprKind::Closure(capture, ref decl, body_id, _, gen) => { ExprKind::Closure(capture, decl, body_id, _, gen) => {
self.check_expr_closure(expr, capture, &decl, body_id, gen, expected) self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
} }
ExprKind::Block(ref body, _) => self.check_block_with_expected(&body, expected), ExprKind::Block(body, _) => self.check_block_with_expected(&body, expected),
ExprKind::Call(ref callee, ref args) => self.check_call(expr, &callee, args, expected), ExprKind::Call(callee, args) => self.check_call(expr, &callee, args, expected),
ExprKind::MethodCall(ref segment, span, ref args, _) => { ExprKind::MethodCall(segment, span, args, _) => {
self.check_method_call(expr, segment, span, args, expected) self.check_method_call(expr, segment, span, args, expected)
} }
ExprKind::Cast(ref e, ref t) => self.check_expr_cast(e, t, expr), ExprKind::Cast(e, t) => self.check_expr_cast(e, t, expr),
ExprKind::Type(ref e, ref t) => { ExprKind::Type(e, t) => {
let ty = self.to_ty_saving_user_provided_ty(&t); let ty = self.to_ty_saving_user_provided_ty(&t);
self.check_expr_eq_type(&e, ty); self.check_expr_eq_type(&e, ty);
ty ty
@ -288,19 +286,19 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
ExprKind::If(cond, then_expr, opt_else_expr) => { ExprKind::If(cond, then_expr, opt_else_expr) => {
self.check_then_else(cond, then_expr, opt_else_expr, expr.span, expected) self.check_then_else(cond, then_expr, opt_else_expr, expr.span, expected)
} }
ExprKind::DropTemps(ref e) => self.check_expr_with_expectation(e, expected), ExprKind::DropTemps(e) => self.check_expr_with_expectation(e, expected),
ExprKind::Array(ref args) => self.check_expr_array(args, expected, expr), ExprKind::Array(args) => self.check_expr_array(args, expected, expr),
ExprKind::ConstBlock(ref anon_const) => self.to_const(anon_const).ty, ExprKind::ConstBlock(ref anon_const) => self.to_const(anon_const).ty,
ExprKind::Repeat(ref element, ref count) => { ExprKind::Repeat(element, ref count) => {
self.check_expr_repeat(element, count, expected, expr) self.check_expr_repeat(element, count, expected, expr)
} }
ExprKind::Tup(ref elts) => self.check_expr_tuple(elts, expected, expr), ExprKind::Tup(elts) => self.check_expr_tuple(elts, expected, expr),
ExprKind::Struct(ref qpath, fields, ref base_expr) => { ExprKind::Struct(qpath, fields, ref base_expr) => {
self.check_expr_struct(expr, expected, qpath, fields, base_expr) self.check_expr_struct(expr, expected, qpath, fields, base_expr)
} }
ExprKind::Field(ref base, field) => self.check_field(expr, &base, field), ExprKind::Field(base, field) => self.check_field(expr, &base, field),
ExprKind::Index(ref base, ref idx) => self.check_expr_index(base, idx, expr), ExprKind::Index(base, idx) => self.check_expr_index(base, idx, expr),
ExprKind::Yield(ref value, ref src) => self.check_expr_yield(value, expr, src), ExprKind::Yield(value, ref src) => self.check_expr_yield(value, expr, src),
hir::ExprKind::Err => tcx.ty_error(), hir::ExprKind::Err => tcx.ty_error(),
} }
} }
@ -541,7 +539,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let tcx = self.tcx; let tcx = self.tcx;
if let Ok(target_id) = destination.target_id { if let Ok(target_id) = destination.target_id {
let (e_ty, cause); let (e_ty, cause);
if let Some(ref e) = expr_opt { if let Some(e) = expr_opt {
// If this is a break with a value, we need to type-check // If this is a break with a value, we need to type-check
// the expression. Get an expected type from the loop context. // the expression. Get an expected type from the loop context.
let opt_coerce_to = { let opt_coerce_to = {
@ -650,12 +648,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// We still need to assign a type to the inner expression to // We still need to assign a type to the inner expression to
// prevent the ICE in #43162. // prevent the ICE in #43162.
if let Some(ref e) = expr_opt { if let Some(e) = expr_opt {
self.check_expr_with_hint(e, err); self.check_expr_with_hint(e, err);
// ... except when we try to 'break rust;'. // ... except when we try to 'break rust;'.
// ICE this expression in particular (see #43162). // ICE this expression in particular (see #43162).
if let ExprKind::Path(QPath::Resolved(_, ref path)) = e.kind { if let ExprKind::Path(QPath::Resolved(_, path)) = e.kind {
if path.segments.len() == 1 && path.segments[0].ident.name == sym::rust { if path.segments.len() == 1 && path.segments[0].ident.name == sym::rust {
fatally_break_rust(self.tcx.sess); fatally_break_rust(self.tcx.sess);
} }
@ -674,7 +672,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
) -> Ty<'tcx> { ) -> Ty<'tcx> {
if self.ret_coercion.is_none() { if self.ret_coercion.is_none() {
self.tcx.sess.emit_err(ReturnStmtOutsideOfFnBody { span: expr.span }); self.tcx.sess.emit_err(ReturnStmtOutsideOfFnBody { span: expr.span });
} else if let Some(ref e) = expr_opt { } else if let Some(e) = expr_opt {
if self.ret_coercion_span.get().is_none() { if self.ret_coercion_span.get().is_none() {
self.ret_coercion_span.set(Some(e.span)); self.ret_coercion_span.set(Some(e.span));
} }
@ -1133,13 +1131,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let flds = expected.only_has_type(self).and_then(|ty| { let flds = expected.only_has_type(self).and_then(|ty| {
let ty = self.resolve_vars_with_obligations(ty); let ty = self.resolve_vars_with_obligations(ty);
match ty.kind() { match ty.kind() {
ty::Tuple(ref flds) => Some(&flds[..]), ty::Tuple(flds) => Some(&flds[..]),
_ => None, _ => None,
} }
}); });
let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| match flds { let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| match flds {
Some(ref fs) if i < fs.len() => { Some(fs) if i < fs.len() => {
let ety = fs[i].expect_ty(); let ety = fs[i].expect_ty();
self.check_expr_coercable_to_type(&e, ety, None); self.check_expr_coercable_to_type(&e, ety, None);
ety ety
@ -1328,7 +1326,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
for field in fields { for field in fields {
self.check_expr(&field.expr); self.check_expr(&field.expr);
} }
if let Some(ref base) = *base_expr { if let Some(base) = *base_expr {
self.check_expr(&base); self.check_expr(&base);
} }
} }
@ -1488,7 +1486,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}, },
_ => { _ => {
// prevent all specified fields from being suggested // prevent all specified fields from being suggested
let skip_fields = skip_fields.iter().map(|ref x| x.ident.name); let skip_fields = skip_fields.iter().map(|x| x.ident.name);
if let Some(field_name) = if let Some(field_name) =
Self::suggest_field_name(variant, field.ident.name, skip_fields.collect()) Self::suggest_field_name(variant, field.ident.name, skip_fields.collect())
{ {
@ -1617,7 +1615,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
private_candidate = Some((base_def.did, field_ty)); private_candidate = Some((base_def.did, field_ty));
} }
} }
ty::Tuple(ref tys) => { ty::Tuple(tys) => {
let fstr = field.as_str(); let fstr = field.as_str();
if let Ok(index) = fstr.parse::<usize>() { if let Ok(index) = fstr.parse::<usize>() {
if fstr == index.to_string() { if fstr == index.to_string() {