Merge pull request #22237 from ChayimFriedman2/infcx-ty-lowering

fix: Provide an InferCtxt to TyLoweringContext

Author: ChayimFriedman2

crates/hir-ty/src/consteval.rs

@@ -25,23 +25,15 @@ use crate::{
     generics::Generics,
     mir::{MirEvalError, MirLowerError, pad16},
     next_solver::{
-        Allocation, Const, ConstKind, Consts, DbInterner, DefaultAny, ErrorGuaranteed, GenericArg,
-        GenericArgs, ParamConst, ScalarInt, StoredAllocation, StoredEarlyBinder, StoredGenericArgs,
-        Ty, TyKind, UnevaluatedConst, ValTreeKind, default_types, infer::InferCtxt,
+        Allocation, Const, ConstKind, Consts, DbInterner, DefaultAny, GenericArgs, ParamConst,
+        ScalarInt, StoredAllocation, StoredEarlyBinder, StoredGenericArgs, Ty, TyKind,
+        UnevaluatedConst, ValTreeKind, default_types, infer::InferCtxt,
     },
     traits::StoredParamEnvAndCrate,
 };
 
 use super::mir::interpret_mir;
 
-pub fn unknown_const<'db>(_ty: Ty<'db>) -> Const<'db> {
-    Const::new(DbInterner::conjure(), rustc_type_ir::ConstKind::Error(ErrorGuaranteed))
-}
-
-pub fn unknown_const_as_generic<'db>(ty: Ty<'db>) -> GenericArg<'db> {
-    unknown_const(ty).into()
-}
-
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ConstEvalError {
     MirLowerError(MirLowerError),

crates/hir-ty/src/generics.rs

@@ -39,7 +39,7 @@ pub(crate) fn generics(db: &dyn DefDatabase, def: GenericDefId) -> Generics<'_>
 }
 
 #[derive(Debug)]
-pub(crate) struct Generics<'db> {
+pub struct Generics<'db> {
     chain: ArrayVec<SingleGenerics<'db>, 2>,
 }
 

crates/hir-ty/src/infer.rs

@@ -23,9 +23,9 @@ use crate::{
     db::{InternedClosure, InternedClosureId, InternedCoroutineClosureId, InternedCoroutineId},
     infer::{BreakableKind, Diverges, coerce::CoerceMany, pat::PatOrigin},
     next_solver::{
-        AliasTy, Binder, ClauseKind, DbInterner, ErrorGuaranteed, FnSig, GenericArg, GenericArgs,
-        PolyFnSig, PolyProjectionPredicate, Predicate, PredicateKind, SolverDefId, TermId, Ty,
-        TyKind, Unnormalized,
+        AliasTy, Binder, ClauseKind, DbInterner, ErrorGuaranteed, FnSig, GenericArg, PolyFnSig,
+        PolyProjectionPredicate, Predicate, PredicateKind, SolverDefId, TermId, Ty, TyKind,
+        Unnormalized,
         abi::Safety,
         infer::{
             BoundRegionConversionTime, InferOk, InferResult,
@@ -99,7 +99,7 @@ impl<'db> InferenceContext<'_, 'db> {
 
         debug!(?bound_sig, ?liberated_sig);
 
-        let parent_args = GenericArgs::identity_for_item(interner, self.store_owner.into());
+        let parent_args = self.identity_args();
 
         let tupled_upvars_ty = self.table.next_ty_var(closure_expr.into());
 

crates/hir-ty/src/infer/closure.rs

@@ -2,7 +2,7 @@
 //! and a wrapper around [`TyLoweringContext`] ([`InferenceTyLoweringContext`]) that replaces
 //! it and takes care of diagnostics in inference.
 
-use std::cell::RefCell;
+use std::cell::{OnceCell, RefCell};
 use std::ops::{Deref, DerefMut};
 
 use either::Either;
@@ -16,8 +16,9 @@ use thin_vec::ThinVec;
 use crate::{
     InferenceDiagnostic, InferenceTyDiagnosticSource, TyLoweringDiagnostic,
     db::{AnonConstId, HirDatabase},
+    generics::Generics,
     lower::{
-        ForbidParamsAfterReason, LifetimeElisionKind, TyLoweringContext,
+        ForbidParamsAfterReason, LifetimeElisionKind, TyLoweringContext, TyLoweringInferVarsCtx,
         path::{PathDiagnosticCallback, PathLoweringContext},
     },
 };
@@ -71,12 +72,22 @@ impl<'db, 'a> InferenceTyLoweringContext<'db, 'a> {
         source: InferenceTyDiagnosticSource,
         def: ExpressionStoreOwnerId,
         generic_def: GenericDefId,
+        generics: &'a OnceCell<Generics<'db>>,
         lifetime_elision: LifetimeElisionKind<'db>,
         allow_using_generic_params: bool,
+        infer_vars: Option<TyLoweringInferVarsCtx<'a, 'db>>,
         defined_anon_consts: &'a RefCell<ThinVec<AnonConstId>>,
     ) -> Self {
-        let mut ctx =
-            TyLoweringContext::new(db, resolver, store, def, generic_def, lifetime_elision);
+        let mut ctx = TyLoweringContext::new(
+            db,
+            resolver,
+            store,
+            def,
+            generic_def,
+            generics,
+            lifetime_elision,
+        )
+        .with_infer_vars_behavior(infer_vars);
         if !allow_using_generic_params {
             ctx.forbid_params_after(0, ForbidParamsAfterReason::AnonConst);
         }

crates/hir-ty/src/infer/diagnostics.rs

@@ -13,7 +13,7 @@ use stdx::never;
 use crate::{
     InferenceDiagnostic, Span, ValueTyDefId,
     infer::diagnostics::InferenceTyLoweringContext as TyLoweringContext,
-    lower::{GenericPredicates, LifetimeElisionKind},
+    lower::{GenericPredicates, LifetimeElisionKind, TyLoweringInferVarsCtx},
     method_resolution::{self, CandidateId, MethodError},
     next_solver::{
         GenericArg, GenericArgs, TraitRef, Ty, Unnormalized, infer::traits::ObligationCause,
@@ -38,7 +38,7 @@ impl<'db> InferenceContext<'_, 'db> {
                 }
                 ValuePathResolution::NonGeneric(ty) => return Some((value, ty)),
             };
-        let args = self.insert_type_vars(substs, id.into());
+        let args = self.insert_type_vars(substs);
 
         self.add_required_obligations_for_value_path(id, generic_def, args);
 
@@ -117,7 +117,7 @@ impl<'db> InferenceContext<'_, 'db> {
                 if let Some(last_segment) = last_segment {
                     path_ctx.set_current_segment(last_segment)
                 }
-                path_ctx.substs_from_path(value_def, true, false)
+                path_ctx.substs_from_path(value_def, true, false, id.into())
             })
         };
 
@@ -147,8 +147,13 @@ impl<'db> InferenceContext<'_, 'db> {
             InferenceTyDiagnosticSource::Body,
             self.store_owner,
             self.generic_def,
+            &self.generics,
             LifetimeElisionKind::Infer,
             self.allow_using_generic_params,
+            Some(TyLoweringInferVarsCtx {
+                table: &mut self.table,
+                type_of_placeholder: &mut self.result.type_of_type_placeholder,
+            }),
             &self.defined_anon_consts,
         );
         let mut path_ctx = if no_diagnostics {
@@ -160,12 +165,12 @@ impl<'db> InferenceContext<'_, 'db> {
             let last = path.segments().last()?;
 
             let (ty, orig_ns) = path_ctx.ty_ctx().lower_ty_ext(type_ref);
-            let ty = self.table.process_user_written_ty(type_ref.into(), ty);
+            let ty = path_ctx.expect_table().process_user_written_ty(ty);
 
             path_ctx.ignore_last_segment();
-            let (ty, _) = path_ctx.lower_ty_relative_path(ty, orig_ns, true);
+            let (ty, _) = path_ctx.lower_ty_relative_path(ty, orig_ns, true, id.into());
             drop_ctx(ctx, no_diagnostics);
-            let ty = self.table.process_user_written_ty(id.into(), ty);
+            let ty = self.table.process_user_written_ty(ty);
             self.resolve_ty_assoc_item(ty, last.name, id).map(|(it, substs)| (it, Some(substs)))?
         } else {
             let hygiene = self.store.expr_or_pat_path_hygiene(id);
@@ -190,9 +195,13 @@ impl<'db> InferenceContext<'_, 'db> {
 
                     let (resolution, substs) = match (def, is_before_last) {
                         (TypeNs::TraitId(trait_), true) => {
-                            let self_ty = self.table.next_ty_var(id.into());
-                            let trait_ref =
-                                path_ctx.lower_trait_ref_from_resolved_path(trait_, self_ty, true);
+                            let self_ty = path_ctx.expect_table().next_ty_var(id.into());
+                            let trait_ref = path_ctx.lower_trait_ref_from_resolved_path(
+                                trait_,
+                                self_ty,
+                                true,
+                                id.into(),
+                            );
                             drop_ctx(ctx, no_diagnostics);
                             self.resolve_trait_assoc_item(trait_ref, last_segment, id)
                         }
@@ -202,13 +211,13 @@ impl<'db> InferenceContext<'_, 'db> {
                             // should resolve to an associated type of that trait (e.g. `<T
                             // as Iterator>::Item::default`)
                             path_ctx.ignore_last_segment();
-                            let (ty, _) = path_ctx.lower_partly_resolved_path(def, true);
+                            let (ty, _) = path_ctx.lower_partly_resolved_path(def, true, id.into());
                             drop_ctx(ctx, no_diagnostics);
                             if ty.is_ty_error() {
                                 return None;
                             }
 
-                            let ty = self.process_user_written_ty(id.into(), ty);
+                            let ty = self.process_user_written_ty(ty);
 
                             self.resolve_ty_assoc_item(ty, last_segment.name, id)
                         }

crates/hir-ty/src/infer/path.rs

@@ -442,23 +442,22 @@ impl<'db> InferenceTable<'db> {
         }
     }
 
-    pub(super) fn insert_type_vars<T>(&mut self, ty: T, span: Span) -> T
+    pub(super) fn insert_type_vars<T>(&mut self, ty: T) -> T
     where
         T: TypeFoldable<DbInterner<'db>>,
     {
-        self.infer_ctxt.insert_type_vars(ty, span)
+        self.infer_ctxt.insert_type_vars(ty)
     }
 
     /// Whenever you lower a user-written type, you should call this.
-    pub(crate) fn process_user_written_ty(&mut self, span: Span, ty: Ty<'db>) -> Ty<'db> {
-        let ty = self.insert_type_vars(ty, span);
-        self.try_structurally_resolve_type(span, ty)
+    pub(crate) fn process_user_written_ty(&mut self, ty: Ty<'db>) -> Ty<'db> {
+        self.process_remote_user_written_ty(ty)
     }
 
     /// The difference of this method from `process_user_written_ty()` is that this method doesn't register a well-formed obligation,
     /// while `process_user_written_ty()` should (but doesn't currently).
     pub(crate) fn process_remote_user_written_ty(&mut self, ty: Ty<'db>) -> Ty<'db> {
-        let ty = self.insert_type_vars(ty, Span::Dummy);
+        let ty = self.insert_type_vars(ty);
         // See https://github.com/rust-lang/rust/blob/cdb45c87e2cd43495379f7e867e3cc15dcee9f93/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs#L487-L495:
         // Even though the new solver only lazily normalizes usually, here we eagerly normalize so that not everything needs
         // to normalize before inspecting the `TyKind`.

crates/hir-ty/src/infer/unify.rs

@@ -502,35 +502,6 @@ where
     Vec::from_iter(collector.params)
 }
 
-struct TypeInferenceVarCollector<'db> {
-    type_inference_vars: Vec<Ty<'db>>,
-}
-
-impl<'db> rustc_type_ir::TypeVisitor<DbInterner<'db>> for TypeInferenceVarCollector<'db> {
-    type Result = ();
-
-    fn visit_ty(&mut self, ty: Ty<'db>) -> Self::Result {
-        use crate::rustc_type_ir::Flags;
-        if ty.is_ty_var() {
-            self.type_inference_vars.push(ty);
-        } else if ty.flags().intersects(rustc_type_ir::TypeFlags::HAS_TY_INFER) {
-            ty.super_visit_with(self);
-        } else {
-            // Fast path: don't visit inner types (e.g. generic arguments) when `flags` indicate
-            // that there are no placeholders.
-        }
-    }
-}
-
-pub fn collect_type_inference_vars<'db, T>(value: &T) -> Vec<Ty<'db>>
-where
-    T: ?Sized + rustc_type_ir::TypeVisitable<DbInterner<'db>>,
-{
-    let mut collector = TypeInferenceVarCollector { type_inference_vars: vec![] };
-    value.visit_with(&mut collector);
-    collector.type_inference_vars
-}
-
 pub fn known_const_to_ast<'db>(
     konst: Const<'db>,
     db: &'db dyn HirDatabase,