drive-by: move field_index to typeck results

compiler-errors · compiler-errors · commit 26b24cd7558c · 2022-12-04T17:59:21.000Z
diff --git a/compiler/rustc_hir_typeck/src/expr_use_visitor.rs b/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
@@ -540,9 +540,9 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> {
             ty::Adt(adt, substs) if adt.is_struct() => {
                 // Consume those fields of the with expression that are needed.
                 for (f_index, with_field) in adt.non_enum_variant().fields.iter().enumerate() {
-                    let is_mentioned = fields.iter().any(|f| {
-                        self.tcx().field_index(f.hir_id, self.mc.typeck_results) == f_index
-                    });
+                    let is_mentioned = fields
+                        .iter()
+                        .any(|f| self.mc.typeck_results.field_index(f.hir_id) == f_index);
                     if !is_mentioned {
                         let field_place = self.mc.cat_projection(
                             &*with_expr,
diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs
@@ -259,7 +259,7 @@ impl<'tcx> LateLintPass<'tcx> for NonShorthandFieldPatterns {
                 }
                 if let PatKind::Binding(binding_annot, _, ident, None) = fieldpat.pat.kind {
                     if cx.tcx.find_field_index(ident, &variant)
-                        == Some(cx.tcx.field_index(fieldpat.hir_id, cx.typeck_results()))
+                        == Some(cx.typeck_results().field_index(fieldpat.hir_id))
                     {
                         cx.struct_span_lint(
                             NON_SHORTHAND_FIELD_PATTERNS,
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
@@ -671,6 +671,14 @@ impl<'tcx> TypeckResults<'tcx> {
         LocalTableInContextMut { hir_owner: self.hir_owner, data: &mut self.field_indices }
     }
 
+    pub fn field_index(&self, id: hir::HirId) -> usize {
+        self.field_indices().get(id).cloned().expect("no index for a field")
+    }
+
+    pub fn opt_field_index(&self, id: hir::HirId) -> Option<usize> {
+        self.field_indices().get(id).cloned()
+    }
+
     pub fn user_provided_types(&self) -> LocalTableInContext<'_, CanonicalUserType<'tcx>> {
         LocalTableInContext { hir_owner: self.hir_owner, data: &self.user_provided_types }
     }
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
@@ -2228,10 +2228,6 @@ impl<'tcx> TyCtxt<'tcx> {
         }
     }
 
-    pub fn field_index(self, hir_id: hir::HirId, typeck_results: &TypeckResults<'_>) -> usize {
-        typeck_results.field_indices().get(hir_id).cloned().expect("no index for a field")
-    }
-
     pub fn find_field_index(self, ident: Ident, variant: &VariantDef) -> Option<usize> {
         variant
             .fields
diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs
@@ -704,7 +704,7 @@ impl<'tcx> Cx<'tcx> {
             hir::ExprKind::Field(ref source, ..) => ExprKind::Field {
                 lhs: self.mirror_expr(source),
                 variant_index: VariantIdx::new(0),
-                name: Field::new(tcx.field_index(expr.hir_id, self.typeck_results)),
+                name: Field::new(self.typeck_results.field_index(expr.hir_id)),
             },
             hir::ExprKind::Cast(ref source, ref cast_ty) => {
                 // Check for a user-given type annotation on this `cast`
@@ -1079,7 +1079,7 @@ impl<'tcx> Cx<'tcx> {
         fields
             .iter()
             .map(|field| FieldExpr {
-                name: Field::new(self.tcx.field_index(field.hir_id, self.typeck_results)),
+                name: Field::new(self.typeck_results.field_index(field.hir_id)),
                 expr: self.mirror_expr(field.expr),
             })
             .collect()
diff --git a/compiler/rustc_mir_build/src/thir/pattern/mod.rs b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
@@ -321,7 +321,7 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
                 let subpatterns = fields
                     .iter()
                     .map(|field| FieldPat {
-                        field: Field::new(self.tcx.field_index(field.hir_id, self.typeck_results)),
+                        field: Field::new(self.typeck_results.field_index(field.hir_id)),
                         pattern: self.lower_pattern(&field.pat),
                     })
                     .collect();
diff --git a/compiler/rustc_passes/src/dead.rs b/compiler/rustc_passes/src/dead.rs
@@ -124,7 +124,7 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
     fn handle_field_access(&mut self, lhs: &hir::Expr<'_>, hir_id: hir::HirId) {
         match self.typeck_results().expr_ty_adjusted(lhs).kind() {
             ty::Adt(def, _) => {
-                let index = self.tcx.field_index(hir_id, self.typeck_results());
+                let index = self.typeck_results().field_index(hir_id);
                 self.insert_def_id(def.non_enum_variant().fields[index].did);
             }
             ty::Tuple(..) => {}
@@ -208,7 +208,7 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
             if let PatKind::Wild = pat.pat.kind {
                 continue;
             }
-            let index = self.tcx.field_index(pat.hir_id, self.typeck_results());
+            let index = self.typeck_results().field_index(pat.hir_id);
             self.insert_def_id(variant.fields[index].did);
         }
     }
@@ -341,7 +341,7 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
     fn mark_as_used_if_union(&mut self, adt: ty::AdtDef<'tcx>, fields: &[hir::ExprField<'_>]) {
         if adt.is_union() && adt.non_enum_variant().fields.len() > 1 && adt.did().is_local() {
             for field in fields {
-                let index = self.tcx.field_index(field.hir_id, self.typeck_results());
+                let index = self.typeck_results().field_index(field.hir_id);
                 self.insert_def_id(adt.non_enum_variant().fields[index].did);
             }
         }
diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
@@ -1065,9 +1065,9 @@ impl<'tcx> Visitor<'tcx> for NamePrivacyVisitor<'tcx> {
                 // are checked for privacy (RFC 736). Rather than computing the set of
                 // unmentioned fields, just check them all.
                 for (vf_index, variant_field) in variant.fields.iter().enumerate() {
-                    let field = fields.iter().find(|f| {
-                        self.tcx.field_index(f.hir_id, self.typeck_results()) == vf_index
-                    });
+                    let field = fields
+                        .iter()
+                        .find(|f| self.typeck_results().field_index(f.hir_id) == vf_index);
                     let (use_ctxt, span) = match field {
                         Some(field) => (field.ident.span, field.span),
                         None => (base.span, base.span),
@@ -1077,7 +1077,7 @@ impl<'tcx> Visitor<'tcx> for NamePrivacyVisitor<'tcx> {
             } else {
                 for field in fields {
                     let use_ctxt = field.ident.span;
-                    let index = self.tcx.field_index(field.hir_id, self.typeck_results());
+                    let index = self.typeck_results().field_index(field.hir_id);
                     self.check_field(use_ctxt, field.span, adt, &variant.fields[index], false);
                 }
             }
@@ -1093,7 +1093,7 @@ impl<'tcx> Visitor<'tcx> for NamePrivacyVisitor<'tcx> {
             let variant = adt.variant_of_res(res);
             for field in fields {
                 let use_ctxt = field.ident.span;
-                let index = self.tcx.field_index(field.hir_id, self.typeck_results());
+                let index = self.typeck_results().field_index(field.hir_id);
                 self.check_field(use_ctxt, field.span, adt, &variant.fields[index], false);
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -259,7 +259,7 @@ impl<'tcx> LateLintPass<'tcx> for NonShorthandFieldPatterns {`
`259`	`259`	`}`
`260`	`260`	`if let PatKind::Binding(binding_annot, _, ident, None) = fieldpat.pat.kind {`
`261`	`261`	`if cx.tcx.find_field_index(ident, &variant)`
`262`		`- == Some(cx.tcx.field_index(fieldpat.hir_id, cx.typeck_results()))`
	`262`	`+ == Some(cx.typeck_results().field_index(fieldpat.hir_id))`
`263`	`263`	`{`
`264`	`264`	`cx.struct_span_lint(`
`265`	`265`	`NON_SHORTHAND_FIELD_PATTERNS,`
Original file line number	Diff line number	Diff line change
`@@ -671,6 +671,14 @@ impl<'tcx> TypeckResults<'tcx> {`
`671`	`671`	`LocalTableInContextMut { hir_owner: self.hir_owner, data: &mut self.field_indices }`
`672`	`672`	`}`
`673`	`673`
	`674`	`+ pub fn field_index(&self, id: hir::HirId) -> usize {`
	`675`	`+ self.field_indices().get(id).cloned().expect("no index for a field")`
	`676`	`+ }`
	`677`	`+`
	`678`	`+ pub fn opt_field_index(&self, id: hir::HirId) -> Option<usize> {`
	`679`	`+ self.field_indices().get(id).cloned()`
	`680`	`+ }`
	`681`	`+`
`674`	`682`	`pub fn user_provided_types(&self) -> LocalTableInContext<'_, CanonicalUserType<'tcx>> {`
`675`	`683`	`LocalTableInContext { hir_owner: self.hir_owner, data: &self.user_provided_types }`
`676`	`684`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2228,10 +2228,6 @@ impl<'tcx> TyCtxt<'tcx> {`
`2228`	`2228`	`}`
`2229`	`2229`	`}`
`2230`	`2230`
`2231`		`- pub fn field_index(self, hir_id: hir::HirId, typeck_results: &TypeckResults<'_>) -> usize {`
`2232`		`- typeck_results.field_indices().get(hir_id).cloned().expect("no index for a field")`
`2233`		`- }`
`2234`		`-`
`2235`	`2231`	`pub fn find_field_index(self, ident: Ident, variant: &VariantDef) -> Option<usize> {`
`2236`	`2232`	`variant`
`2237`	`2233`	`.fields`
Original file line number	Diff line number	Diff line change
`@@ -124,7 +124,7 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {`
`124`	`124`	`fn handle_field_access(&mut self, lhs: &hir::Expr<'_>, hir_id: hir::HirId) {`
`125`	`125`	`match self.typeck_results().expr_ty_adjusted(lhs).kind() {`
`126`	`126`	`ty::Adt(def, _) => {`
`127`		`- let index = self.tcx.field_index(hir_id, self.typeck_results());`
	`127`	`+ let index = self.typeck_results().field_index(hir_id);`
`128`	`128`	`self.insert_def_id(def.non_enum_variant().fields[index].did);`
`129`	`129`	`}`
`130`	`130`	`ty::Tuple(..) => {}`
`@@ -208,7 +208,7 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {`
`208`	`208`	`if let PatKind::Wild = pat.pat.kind {`
`209`	`209`	`continue;`
`210`	`210`	`}`
`211`		`- let index = self.tcx.field_index(pat.hir_id, self.typeck_results());`
	`211`	`+ let index = self.typeck_results().field_index(pat.hir_id);`
`212`	`212`	`self.insert_def_id(variant.fields[index].did);`
`213`	`213`	`}`
`214`	`214`	`}`
`@@ -341,7 +341,7 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {`
`341`	`341`	`fn mark_as_used_if_union(&mut self, adt: ty::AdtDef<'tcx>, fields: &[hir::ExprField<'_>]) {`
`342`	`342`	`if adt.is_union() && adt.non_enum_variant().fields.len() > 1 && adt.did().is_local() {`
`343`	`343`	`for field in fields {`
`344`		`- let index = self.tcx.field_index(field.hir_id, self.typeck_results());`
	`344`	`+ let index = self.typeck_results().field_index(field.hir_id);`
`345`	`345`	`self.insert_def_id(adt.non_enum_variant().fields[index].did);`
`346`	`346`	`}`
`347`	`347`	`}`