Record for each MIR local where it has been introduced.

cjgillot · cjgillot · commit a385a43197f9 · 2023-07-05T16:39:33.000Z
diff --git a/compiler/rustc_borrowck/src/diagnostics/move_errors.rs b/compiler/rustc_borrowck/src/diagnostics/move_errors.rs
@@ -105,9 +105,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
                         // whether or not the right-hand side is a place expression
                         if let LocalInfo::User(BindingForm::Var(VarBindingForm {
                             opt_match_place: Some((opt_match_place, match_span)),
-                            binding_mode: _,
-                            opt_ty_info: _,
-                            pat_span: _,
+                            ..
                         })) = *local_decl.local_info()
                         {
                             let stmt_source_info = self.body.source_info(location);
diff --git a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
@@ -305,8 +305,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
                         LocalInfo::User(BindingForm::Var(mir::VarBindingForm {
                             binding_mode: ty::BindingMode::BindByValue(Mutability::Not),
                             opt_ty_info: Some(sp),
-                            opt_match_place: _,
-                            pat_span: _,
+                            ..
                         })) => {
                             if suggest {
                                 err.span_note(sp, "the binding is already a mutable borrow");
diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs
@@ -694,6 +694,8 @@ pub struct VarBindingForm<'tcx> {
     pub opt_match_place: Option<(Option<Place<'tcx>>, Span)>,
     /// The span of the pattern in which this variable was bound.
     pub pat_span: Span,
+    /// For each introduction place, record here the span and whether this was a shorthand pattern.
+    pub introductions: Vec<(Span, /* is_shorthand */ bool)>,
 }
 
 #[derive(Clone, Debug, TyEncodable, TyDecodable)]
@@ -921,9 +923,7 @@ impl<'tcx> LocalDecl<'tcx> {
             LocalInfo::User(
                 BindingForm::Var(VarBindingForm {
                     binding_mode: ty::BindingMode::BindByValue(_),
-                    opt_ty_info: _,
-                    opt_match_place: _,
-                    pat_span: _,
+                    ..
                 }) | BindingForm::ImplicitSelf(ImplicitSelfKind::Imm),
             )
         )
@@ -938,9 +938,7 @@ impl<'tcx> LocalDecl<'tcx> {
             LocalInfo::User(
                 BindingForm::Var(VarBindingForm {
                     binding_mode: ty::BindingMode::BindByValue(_),
-                    opt_ty_info: _,
-                    opt_match_place: _,
-                    pat_span: _,
+                    ..
                 }) | BindingForm::ImplicitSelf(_),
             )
         )
diff --git a/compiler/rustc_middle/src/thir.rs b/compiler/rustc_middle/src/thir.rs
@@ -707,6 +707,7 @@ pub enum PatKind<'tcx> {
         /// Is this the leftmost occurrence of the binding, i.e., is `var` the
         /// `HirId` of this pattern?
         is_primary: bool,
+        is_shorthand: bool,
     },
 
     /// `Foo(...)` or `Foo{...}` or `Foo`, where `Foo` is a variant name from an ADT with
diff --git a/compiler/rustc_middle/src/thir/visit.rs b/compiler/rustc_middle/src/thir/visit.rs
@@ -224,6 +224,7 @@ pub fn walk_pat<'a, 'tcx: 'a, V: Visitor<'a, 'tcx>>(visitor: &mut V, pat: &Pat<'
             var: _,
             ty: _,
             is_primary: _,
+            is_shorthand: _,
             name: _,
         } => visitor.visit_pat(&subpattern),
         Binding { .. } | Wild => {}
diff --git a/compiler/rustc_mir_build/src/build/block.rs b/compiler/rustc_mir_build/src/build/block.rs
@@ -242,6 +242,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                                                 block,
                                                 node,
                                                 span,
+                                                false,
                                                 OutsideGuard,
                                                 true,
                                             );
@@ -336,7 +337,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                             pattern,
                             UserTypeProjections::none(),
                             &mut |this, _, _, _, node, span, _, _| {
-                                this.storage_live_binding(block, node, span, OutsideGuard, true);
+                                this.storage_live_binding(
+                                    block,
+                                    node,
+                                    span,
+                                    false,
+                                    OutsideGuard,
+                                    true,
+                                );
                                 this.schedule_drop_for_binding(node, span, OutsideGuard);
                             },
                         )
diff --git a/compiler/rustc_mir_build/src/build/matches/mod.rs b/compiler/rustc_mir_build/src/build/matches/mod.rs
@@ -482,8 +482,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         match irrefutable_pat.kind {
             // Optimize the case of `let x = ...` to write directly into `x`
             PatKind::Binding { mode: BindingMode::ByValue, var, subpattern: None, .. } => {
-                let place =
-                    self.storage_live_binding(block, var, irrefutable_pat.span, OutsideGuard, true);
+                let place = self.storage_live_binding(
+                    block,
+                    var,
+                    irrefutable_pat.span,
+                    false,
+                    OutsideGuard,
+                    true,
+                );
                 unpack!(block = self.expr_into_dest(place, block, initializer));
 
                 // Inject a fake read, see comments on `FakeReadCause::ForLet`.
@@ -513,8 +519,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     },
                 ascription: thir::Ascription { ref annotation, variance: _ },
             } => {
-                let place =
-                    self.storage_live_binding(block, var, irrefutable_pat.span, OutsideGuard, true);
+                let place = self.storage_live_binding(
+                    block,
+                    var,
+                    irrefutable_pat.span,
+                    false,
+                    OutsideGuard,
+                    true,
+                );
                 unpack!(block = self.expr_into_dest(place, block, initializer));
 
                 // Inject a fake read, see comments on `FakeReadCause::ForLet`.
@@ -682,6 +694,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         block: BasicBlock,
         var: LocalVarId,
         span: Span,
+        is_shorthand: bool,
         for_guard: ForGuard,
         schedule_drop: bool,
     ) -> Place<'tcx> {
@@ -693,6 +706,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         if let Some(region_scope) = self.region_scope_tree.var_scope(var.0.local_id) && schedule_drop {
             self.schedule_drop(span, region_scope, local_id, DropKind::Storage);
         }
+        let local_info = self.local_decls[local_id].local_info.as_mut().assert_crate_local();
+        if let LocalInfo::User(BindingForm::Var(var_info)) = &mut **local_info {
+            var_info.introductions.push((span, is_shorthand));
+        }
         Place::from(local_id)
     }
 
@@ -914,6 +931,7 @@ struct Binding<'tcx> {
     source: Place<'tcx>,
     var_id: LocalVarId,
     binding_mode: BindingMode,
+    is_shorthand: bool,
 }
 
 /// Indicates that the type of `source` must be a subtype of the
@@ -2124,6 +2142,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 block,
                 binding.var_id,
                 binding.span,
+                binding.is_shorthand,
                 RefWithinGuard,
                 schedule_drops,
             );
@@ -2137,6 +2156,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         block,
                         binding.var_id,
                         binding.span,
+                        binding.is_shorthand,
                         OutsideGuard,
                         schedule_drops,
                     );
@@ -2175,6 +2195,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     block,
                     binding.var_id,
                     binding.span,
+                    binding.is_shorthand,
                     OutsideGuard,
                     schedule_drops,
                 )
@@ -2234,6 +2255,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     opt_ty_info: None,
                     opt_match_place,
                     pat_span,
+                    introductions: Vec::new(),
                 },
             )))),
         };
diff --git a/compiler/rustc_mir_build/src/build/matches/simplify.rs b/compiler/rustc_mir_build/src/build/matches/simplify.rs
@@ -181,13 +181,15 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 ty: _,
                 ref subpattern,
                 is_primary: _,
+                is_shorthand,
             } => {
                 if let Some(source) = match_pair.place.try_to_place(self) {
                     candidate.bindings.push(Binding {
                         span: match_pair.pattern.span,
                         source,
                         var_id: var,
                         binding_mode: mode,
+                        is_shorthand,
                     });
                 }
 
diff --git a/compiler/rustc_mir_build/src/build/mod.rs b/compiler/rustc_mir_build/src/build/mod.rs
@@ -897,6 +897,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                                 opt_ty_info: param.ty_span,
                                 opt_match_place: Some((None, span)),
                                 pat_span: span,
+                                introductions: vec![(span, false)],
                             }))
                         };
                     self.var_indices.insert(var, LocalsForNode::One(local));
diff --git a/compiler/rustc_mir_build/src/thir/pattern/mod.rs b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
@@ -313,6 +313,7 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
                     ty: var_ty,
                     subpattern: self.lower_opt_pattern(sub),
                     is_primary: id == pat.hir_id,
+                    is_shorthand: false,
                 }
             }
 
@@ -330,9 +331,13 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
                 let res = self.typeck_results.qpath_res(qpath, pat.hir_id);
                 let subpatterns = fields
                     .iter()
-                    .map(|field| FieldPat {
-                        field: self.typeck_results.field_index(field.hir_id),
-                        pattern: self.lower_pattern(&field.pat),
+                    .map(|field| {
+                        let mut pattern = self.lower_pattern(&field.pat);
+                        if let PatKind::Binding { ref mut is_shorthand, .. } = pattern.kind {
+                            *is_shorthand = field.is_shorthand;
+                        }
+                        let field = self.typeck_results.field_index(field.hir_id);
+                        FieldPat { field, pattern }
                     })
                     .collect();
 
@@ -793,17 +798,25 @@ impl<'tcx> PatternFoldable<'tcx> for PatKind<'tcx> {
                 subpattern: subpattern.fold_with(folder),
                 ascription: Ascription { annotation: annotation.fold_with(folder), variance },
             },
-            PatKind::Binding { mutability, name, mode, var, ty, ref subpattern, is_primary } => {
-                PatKind::Binding {
-                    mutability: mutability.fold_with(folder),
-                    name: name.fold_with(folder),
-                    mode: mode.fold_with(folder),
-                    var: var.fold_with(folder),
-                    ty: ty.fold_with(folder),
-                    subpattern: subpattern.fold_with(folder),
-                    is_primary,
-                }
-            }
+            PatKind::Binding {
+                mutability,
+                name,
+                mode,
+                var,
+                ty,
+                ref subpattern,
+                is_primary,
+                is_shorthand,
+            } => PatKind::Binding {
+                mutability: mutability.fold_with(folder),
+                name: name.fold_with(folder),
+                mode: mode.fold_with(folder),
+                var: var.fold_with(folder),
+                ty: ty.fold_with(folder),
+                subpattern: subpattern.fold_with(folder),
+                is_primary,
+                is_shorthand,
+            },
             PatKind::Variant { adt_def, substs, variant_index, ref subpatterns } => {
                 PatKind::Variant {
                     adt_def: adt_def.fold_with(folder),
diff --git a/compiler/rustc_mir_build/src/thir/print.rs b/compiler/rustc_mir_build/src/thir/print.rs
@@ -643,14 +643,24 @@ impl<'a, 'tcx> ThirPrinter<'a, 'tcx> {
                 self.print_pat(subpattern, depth_lvl + 3);
                 print_indented!(self, "}", depth_lvl + 1);
             }
-            PatKind::Binding { mutability, name, mode, var, ty, subpattern, is_primary } => {
+            PatKind::Binding {
+                mutability,
+                name,
+                mode,
+                var,
+                ty,
+                subpattern,
+                is_primary,
+                is_shorthand,
+            } => {
                 print_indented!(self, "Binding {", depth_lvl + 1);
                 print_indented!(self, format!("mutability: {:?}", mutability), depth_lvl + 2);
                 print_indented!(self, format!("name: {:?}", name), depth_lvl + 2);
                 print_indented!(self, format!("mode: {:?}", mode), depth_lvl + 2);
                 print_indented!(self, format!("var: {:?}", var), depth_lvl + 2);
                 print_indented!(self, format!("ty: {:?}", ty), depth_lvl + 2);
                 print_indented!(self, format!("is_primary: {:?}", is_primary), depth_lvl + 2);
+                print_indented!(self, format!("is_shorthand: {:?}", is_shorthand), depth_lvl + 2);
 
                 if let Some(subpattern) = subpattern {
                     print_indented!(self, "subpattern: Some( ", depth_lvl + 2);
diff --git a/tests/ui/thir-print/thir-tree-match.stdout b/tests/ui/thir-print/thir-tree-match.stdout
@@ -17,6 +17,7 @@ params: [
                         var: LocalVarId(HirId(DefId(0:16 ~ thir_tree_match[fcf8]::has_match).2))
                         ty: Foo
                         is_primary: true
+                        is_shorthand: false
                         subpattern: None
                     }
                 }

Original file line number	Diff line number	Diff line change
`@@ -694,6 +694,8 @@ pub struct VarBindingForm<'tcx> {`
`694`	`694`	`pub opt_match_place: Option<(Option<Place<'tcx>>, Span)>,`
`695`	`695`	`/// The span of the pattern in which this variable was bound.`
`696`	`696`	`pub pat_span: Span,`
	`697`	`+ /// For each introduction place, record here the span and whether this was a shorthand pattern.`
	`698`	`+ pub introductions: Vec<(Span, /* is_shorthand */ bool)>,`
`697`	`699`	`}`
`698`	`700`
`699`	`701`	`#[derive(Clone, Debug, TyEncodable, TyDecodable)]`
`@@ -921,9 +923,7 @@ impl<'tcx> LocalDecl<'tcx> {`
`921`	`923`	`LocalInfo::User(`
`922`	`924`	`BindingForm::Var(VarBindingForm {`
`923`	`925`	`binding_mode: ty::BindingMode::BindByValue(_),`
`924`		`- opt_ty_info: _,`
`925`		`- opt_match_place: _,`
`926`		`- pat_span: _,`
	`926`	`+ ..`
`927`	`927`	`}) \| BindingForm::ImplicitSelf(ImplicitSelfKind::Imm),`
`928`	`928`	`)`
`929`	`929`	`)`
`@@ -938,9 +938,7 @@ impl<'tcx> LocalDecl<'tcx> {`
`938`	`938`	`LocalInfo::User(`
`939`	`939`	`BindingForm::Var(VarBindingForm {`
`940`	`940`	`binding_mode: ty::BindingMode::BindByValue(_),`
`941`		`- opt_ty_info: _,`
`942`		`- opt_match_place: _,`
`943`		`- pat_span: _,`
	`941`	`+ ..`
`944`	`942`	`}) \| BindingForm::ImplicitSelf(_),`
`945`	`943`	`)`
`946`	`944`	`)`