Remove a bunch of Span args and some other diagnostic-related things from next-solver code

Author: jackh726

crates/hir-ty/src/next_solver/infer/canonical/instantiate.rs

@@ -8,10 +8,10 @@
 
 use crate::next_solver::{
     AliasTy, Binder, BoundRegion, BoundTy, Canonical, CanonicalVarValues, Const, DbInterner, DbIr,
-    Goal, ParamEnv, Predicate, PredicateKind, Region, Span, Ty, TyKind,
+    Goal, ParamEnv, Predicate, PredicateKind, Region, Ty, TyKind,
     fold::FnMutDelegate,
     infer::{
-        DefineOpaqueTypes, InferCtxt, SubregionOrigin, TypeTrace,
+        DefineOpaqueTypes, InferCtxt, TypeTrace,
         traits::{Obligation, PredicateObligations},
     },
 };

crates/hir-ty/src/next_solver/infer/canonical/mod.rs

@@ -24,9 +24,9 @@
 use crate::next_solver::{
     AliasTy, Binder, Canonical, CanonicalVarValues, CanonicalVars, Const, DbInterner, DbIr,
     GenericArg, Goal, ParamEnv, PlaceholderConst, PlaceholderRegion, PlaceholderTy, Predicate,
-    PredicateKind, Region, Span, Ty, TyKind,
+    PredicateKind, Region, Ty, TyKind,
     infer::{
-        DefineOpaqueTypes, InferCtxt, SubregionOrigin, TypeTrace,
+        DefineOpaqueTypes, InferCtxt, TypeTrace,
         traits::{Obligation, PredicateObligations},
     },
 };
@@ -42,8 +42,6 @@ use rustc_type_ir::{
     },
 };
 
-use super::RegionVariableOrigin;
-
 pub mod instantiate;
 
 impl<'db> InferCtxt<'db> {
@@ -61,7 +59,6 @@ impl<'db> InferCtxt<'db> {
     /// for each of the canonical inputs to your query.
     pub fn instantiate_canonical<T>(
         &self,
-        span: Span,
         canonical: &Canonical<'db, T>,
     ) -> (T, CanonicalVarValues<'db>)
     where
@@ -81,7 +78,7 @@ impl<'db> InferCtxt<'db> {
             .collect();
 
         let canonical_inference_vars =
-            self.instantiate_canonical_vars(span, canonical.variables.clone(), |ui| universes[ui]);
+            self.instantiate_canonical_vars(canonical.variables.clone(), |ui| universes[ui]);
         let result = canonical.instantiate(self.interner, &canonical_inference_vars);
         (result, canonical_inference_vars)
     }
@@ -93,15 +90,12 @@ impl<'db> InferCtxt<'db> {
     /// canonical variable with these inference variables.
     fn instantiate_canonical_vars(
         &self,
-        span: Span,
         variables: CanonicalVars<'db>,
         universe_map: impl Fn(UniverseIndex) -> UniverseIndex,
     ) -> CanonicalVarValues<'db> {
         CanonicalVarValues {
             var_values: self.interner.mk_args_from_iter(
-                variables
-                    .iter()
-                    .map(|info| self.instantiate_canonical_var(span, info, &universe_map)),
+                variables.iter().map(|info| self.instantiate_canonical_var(info, &universe_map)),
             ),
         }
     }
@@ -116,15 +110,14 @@ impl<'db> InferCtxt<'db> {
     /// We should somehow deduplicate all of this.
     pub fn instantiate_canonical_var(
         &self,
-        span: Span,
         cv_info: CanonicalVarKind<DbInterner<'db>>,
         universe_map: impl Fn(UniverseIndex) -> UniverseIndex,
     ) -> GenericArg<'db> {
         match cv_info {
             CanonicalVarKind::Ty(ty_kind) => {
                 let ty = match ty_kind {
                     CanonicalTyVarKind::General(ui) => {
-                        self.next_ty_var_in_universe(span, universe_map(ui))
+                        self.next_ty_var_in_universe(universe_map(ui))
                     }
 
                     CanonicalTyVarKind::Int => self.next_int_var(),
@@ -140,12 +133,9 @@ impl<'db> InferCtxt<'db> {
                 Ty::new_placeholder(self.interner, placeholder_mapped).into()
             }
 
-            CanonicalVarKind::Region(ui) => self
-                .next_region_var_in_universe(
-                    RegionVariableOrigin::MiscVariable(span),
-                    universe_map(ui),
-                )
-                .into(),
+            CanonicalVarKind::Region(ui) => {
+                self.next_region_var_in_universe(universe_map(ui)).into()
+            }
 
             CanonicalVarKind::PlaceholderRegion(PlaceholderRegion { universe, bound }) => {
                 let universe_mapped = universe_map(universe);
@@ -155,9 +145,7 @@ impl<'db> InferCtxt<'db> {
                 Region::new_placeholder(self.interner, placeholder_mapped).into()
             }
 
-            CanonicalVarKind::Const(ui) => {
-                self.next_const_var_in_universe(span, universe_map(ui)).into()
-            }
+            CanonicalVarKind::Const(ui) => self.next_const_var_in_universe(universe_map(ui)).into(),
             CanonicalVarKind::PlaceholderConst(PlaceholderConst { universe, bound }) => {
                 let universe_mapped = universe_map(universe);
                 let placeholder_mapped = PlaceholderConst { universe: universe_mapped, bound };

crates/hir-ty/src/next_solver/infer/context.rs

@@ -12,10 +12,7 @@ use crate::next_solver::{
 };
 
 ///! Definition of `InferCtxtLike` from the librarified type layer.
-use super::{
-    BoundRegionConversionTime, InferCtxt, SubregionOrigin, relate::RelateResult,
-    traits::ObligationCause,
-};
+use super::{BoundRegionConversionTime, InferCtxt, relate::RelateResult, traits::ObligationCause};
 
 impl<'db> rustc_type_ir::InferCtxtLike for InferCtxt<'db> {
     type Interner = DbInterner<'db>;
@@ -150,30 +147,26 @@ impl<'db> rustc_type_ir::InferCtxtLike for InferCtxt<'db> {
     }
 
     fn next_ty_infer(&self) -> Ty<'db> {
-        self.next_ty_var(Span::dummy())
+        self.next_ty_var()
     }
 
     fn next_region_infer(&self) -> <Self::Interner as rustc_type_ir::Interner>::Region {
-        self.next_region_var(super::RegionVariableOrigin::MiscVariable(Span::dummy()))
+        self.next_region_var()
     }
 
     fn next_const_infer(&self) -> Const<'db> {
-        self.next_const_var(Span::dummy())
+        self.next_const_var()
     }
 
     fn fresh_args_for_item(&self, def_id: SolverDefId) -> GenericArgs<'db> {
-        self.fresh_args_for_item(Span::dummy(), def_id)
+        self.fresh_args_for_item(def_id)
     }
 
     fn instantiate_binder_with_infer<T: TypeFoldable<DbInterner<'db>> + Clone>(
         &self,
         value: Binder<'db, T>,
     ) -> T {
-        self.instantiate_binder_with_fresh_vars(
-            Span::dummy(),
-            BoundRegionConversionTime::HigherRankedType,
-            value,
-        )
+        self.instantiate_binder_with_fresh_vars(BoundRegionConversionTime::HigherRankedType, value)
     }
 
     fn enter_forall<T: TypeFoldable<DbInterner<'db>> + Clone, U>(
@@ -266,19 +259,11 @@ impl<'db> rustc_type_ir::InferCtxtLike for InferCtxt<'db> {
     }
 
     fn sub_regions(&self, sub: Region<'db>, sup: Region<'db>, span: Span) {
-        self.inner.borrow_mut().unwrap_region_constraints().make_subregion(
-            SubregionOrigin::RelateRegionParamBound(span, None),
-            sub,
-            sup,
-        );
+        self.inner.borrow_mut().unwrap_region_constraints().make_subregion(sub, sup);
     }
 
     fn equate_regions(&self, a: Region<'db>, b: Region<'db>, span: Span) {
-        self.inner.borrow_mut().unwrap_region_constraints().make_eqregion(
-            SubregionOrigin::RelateRegionParamBound(span, None),
-            a,
-            b,
-        );
+        self.inner.borrow_mut().unwrap_region_constraints().make_eqregion(a, b);
     }
 
     fn register_ty_outlives(&self, ty: Ty<'db>, r: Region<'db>, span: Span) {