Address low hanging fruit review comments, more to come

strottos · strottos · commit d121a7fd01fc · 2024-02-26T09:51:26.000Z
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -512,7 +512,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     .borrow()
                     .expr_ty_adjusted_opt(*expr)
                     .unwrap_or_else(|| Ty::new_misc_error(tcx));
-                (ty, normalize_span(expr.span))
+                (self.resolve_vars_if_possible(ty), normalize_span(expr.span))
             })
             .collect();
         let callee_expr = match &call_expr.peel_blocks().kind {
@@ -649,7 +649,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             }
 
             let (arg_ty, arg_span) = provided_arg_tys[provided_idx];
-            let arg_ty = self.resolve_vars_if_possible(arg_ty);
 
             let expectation = Expectation::rvalue_hint(self, expected_input_ty);
             let coerced_ty = expectation.only_has_type(self).unwrap_or(formal_input_ty);
@@ -722,11 +721,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 // Wrap up the N provided arguments starting at this position in a tuple.
                 let provided_as_tuple = Ty::new_tup_from_iter(
                     tcx,
-                    provided_arg_tys
-                        .iter()
-                        .map(|(ty, _)| self.resolve_vars_if_possible(*ty))
-                        .skip(mismatch_idx)
-                        .take(tys.len()),
+                    provided_arg_tys.iter().map(|(ty, _)| *ty).skip(mismatch_idx).take(tys.len()),
                 );
 
                 let mut satisfied = true;
@@ -737,10 +732,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         provided_arg_tys.iter().map(|(ty, _)| *ty).skip(mismatch_idx + tys.len()),
                     ),
                 ) {
-                    if !self.can_coerce(
-                        self.resolve_vars_if_possible(provided_ty),
-                        self.resolve_vars_if_possible(*expected_ty),
-                    ) {
+                    if !self.can_coerce(provided_ty, self.resolve_vars_if_possible(*expected_ty)) {
                         satisfied = false;
                         break;
                     }
@@ -767,10 +759,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             mk_trace(
                                 *lo,
                                 (formal_ty, expected_ty),
-                                self.resolve_vars_if_possible(
-                                    provided_arg_tys[mismatch_idx.into()],
-                                )
-                                .0,
+                                provided_arg_tys[mismatch_idx.into()].0,
                             ),
                             terr,
                         );
@@ -853,7 +842,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 return true;
             };
             let (provided_ty, provided_span) = provided_arg_tys[*provided_idx];
-            let provided_ty = self.resolve_vars_if_possible(provided_ty);
             let (formal_ty, expected_ty) = formal_and_expected_inputs[*expected_idx];
             let formal_ty = self.resolve_vars_if_possible(formal_ty);
             let expected_ty = self.resolve_vars_if_possible(expected_ty);
@@ -888,7 +876,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             let formal_ty = self.resolve_vars_if_possible(formal_ty);
             let expected_ty = self.resolve_vars_if_possible(expected_ty);
             let (provided_ty, provided_arg_span) = provided_arg_tys[*provided_idx];
-            let provided_ty = self.resolve_vars_if_possible(provided_ty);
             let trace = mk_trace(provided_arg_span, (formal_ty, expected_ty), provided_ty);
             let mut err = self.err_ctxt().report_and_explain_type_error(trace, *err);
             self.emit_coerce_suggestions(
@@ -903,7 +890,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             );
             err.span_label(full_call_span, format!("arguments to this {call_name} are incorrect"));
 
-            self.emit_generic_mismatches(
+            self.label_generic_mismatches(
                 &mut err,
                 fn_def_id,
                 &matched_inputs,
@@ -1019,7 +1006,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     let formal_ty = self.resolve_vars_if_possible(formal_ty);
                     let expected_ty = self.resolve_vars_if_possible(expected_ty);
                     let (provided_ty, provided_span) = provided_arg_tys[provided_idx];
-                    let provided_ty = self.resolve_vars_if_possible(provided_ty);
                     if let Compatibility::Incompatible(error) = compatibility {
                         let trace = mk_trace(provided_span, (formal_ty, expected_ty), provided_ty);
                         if let Some(e) = error {
@@ -1048,7 +1034,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 }
                 Error::Extra(arg_idx) => {
                     let (provided_ty, provided_span) = provided_arg_tys[arg_idx];
-                    let provided_ty = self.resolve_vars_if_possible(provided_ty);
                     let provided_ty_name = if !has_error_or_infer([provided_ty]) {
                         // FIXME: not suggestable, use something else
                         format!(" of type `{provided_ty}`")
@@ -1132,12 +1117,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             } else {
                                 args_span
                             };
-                            let rendered =
-                                if !has_error_or_infer([self.resolve_vars_if_possible(input_ty)]) {
-                                    format!(" of type `{input_ty}`")
-                                } else {
-                                    "".to_string()
-                                };
+                            let rendered = if !has_error_or_infer([input_ty]) {
+                                format!(" of type `{input_ty}`")
+                            } else {
+                                "".to_string()
+                            };
                             labels.push((span, format!("an argument{rendered} is missing")));
                             suggestion_text = match suggestion_text {
                                 SuggestionText::None => SuggestionText::Provide(false),
@@ -1244,7 +1228,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     second_expected_idx,
                 ) => {
                     let (first_provided_ty, first_span) = provided_arg_tys[first_provided_idx];
-                    let first_provided_ty = self.resolve_vars_if_possible(first_provided_ty);
                     let (_, first_expected_ty) = formal_and_expected_inputs[first_expected_idx];
                     let first_expected_ty = self.resolve_vars_if_possible(first_expected_ty);
                     let first_provided_ty_name = if !has_error_or_infer([first_provided_ty]) {
@@ -1258,7 +1241,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     ));
 
                     let (second_provided_ty, second_span) = provided_arg_tys[second_provided_idx];
-                    let second_provided_ty = self.resolve_vars_if_possible(second_provided_ty);
                     let (_, second_expected_ty) = formal_and_expected_inputs[second_expected_idx];
                     let second_provided_ty = self.resolve_vars_if_possible(second_provided_ty);
                     let second_provided_ty_name = if !has_error_or_infer([second_provided_ty]) {
@@ -1281,7 +1263,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         let (_, expected_ty) = formal_and_expected_inputs[dst_arg];
                         let expected_ty = self.resolve_vars_if_possible(expected_ty);
                         let (provided_ty, provided_span) = provided_arg_tys[dest_input];
-                        let provided_ty = self.resolve_vars_if_possible(provided_ty);
                         let provided_ty_name = if !has_error_or_infer([provided_ty]) {
                             format!(", found `{provided_ty}`")
                         } else {
@@ -1301,7 +1282,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             }
         }
 
-        self.emit_generic_mismatches(
+        self.label_generic_mismatches(
             &mut err,
             fn_def_id,
             &matched_inputs,
@@ -2259,7 +2240,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 .collect();
 
             if params.len() == param_generics.len() {
-                // TODO: IndexVec or something like that from data structures better?
                 let mut generics_map: Vec<(usize, &hir::GenericParam<'_>)> = Vec::new();
                 // This is a map from the index of the generic to the index of the parameter and the
                 // parameter
@@ -2480,7 +2460,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
-    fn emit_generic_mismatches(
+    fn label_generic_mismatches(
         &self,
         err: &mut DiagnosticBuilder<'_>,
         callable_def_id: Option<DefId>,
@@ -2516,7 +2496,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 .filter(|(idx, _)| *idx > matched_idx)
             {
                 if let ty::Infer(ty::TyVar(b)) = formal_ty.kind() {
-                    if self.check_ty_vars_equal(*a, *b) {
+                    if self.root_var(*a) == self.root_var(*b) {
                         formal_ty_idxs_matched.push(input_idx.into());
                         if expected_ty_matched.is_none() {
                             expected_ty_matched = Some(expected_ty);
diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
@@ -1370,11 +1370,6 @@ impl<'tcx> InferCtxt<'tcx> {
         self.inner.borrow_mut().effect_unification_table().find(var).vid
     }
 
-    /// Check variables are equal
-    pub fn check_ty_vars_equal(&self, a: ty::TyVid, b: ty::TyVid) -> bool {
-        self.inner.borrow_mut().type_variables().check_equal(a, b)
-    }
-
     /// Resolves an int var to a rigid int type, if it was constrained to one,
     /// or else the root int var in the unification table.
     pub fn opportunistic_resolve_int_var(&self, vid: ty::IntVid) -> Ty<'tcx> {
diff --git a/compiler/rustc_infer/src/infer/type_variable.rs b/compiler/rustc_infer/src/infer/type_variable.rs
@@ -191,23 +191,6 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
         self.eq_relations().find(vid).vid
     }
 
-    /// Returns the "root" variable of `vid` in the `sub_relations`
-    /// equivalence table. All type variables that have been are
-    /// related via equality or subtyping will yield the same root
-    /// variable (per the union-find algorithm), so `sub_root_var(a)
-    /// == sub_root_var(b)` implies that:
-    /// ```text
-    /// exists X. (a <: X || X <: a) && (b <: X || X <: b)
-    /// ```
-    pub fn sub_root_var(&mut self, vid: ty::TyVid) -> ty::TyVid {
-        self.sub_relations().find(vid)
-    }
-
-    /// Returns `true` if `a` and `b` have same "root" (i.e., `a == b`).
-    pub fn check_equal(&mut self, a: ty::TyVid, b: ty::TyVid) -> bool {
-        self.root_var(a) == self.root_var(b)
-    }
-
     /// Retrieves the type to which `vid` has been instantiated, if
     /// any.
     pub fn probe(&mut self, vid: ty::TyVid) -> TypeVariableValue<'tcx> {
