Remove lint allows from new solver stuff

Author: ChayimFriedman2

src/tools/rust-analyzer/crates/hir-ty/src/builder.rs

@@ -1,10 +1,10 @@
 //! `TyBuilder`, a helper for building instances of `Ty` and related types.
 
 use chalk_ir::{
-    DebruijnIndex, Scalar,
+    DebruijnIndex,
     cast::{Cast, Caster},
 };
-use hir_def::{GenericDefId, GenericParamId, TraitId, builtin_type::BuiltinType};
+use hir_def::{GenericDefId, GenericParamId, TraitId};
 use smallvec::SmallVec;
 
 use crate::{
@@ -18,7 +18,7 @@ use crate::{
         DbInterner, EarlyBinder,
         mapping::{ChalkToNextSolver, NextSolverToChalk},
     },
-    primitive, to_chalk_trait_id,
+    to_chalk_trait_id,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -137,23 +137,6 @@ impl TyBuilder<()> {
         TyKind::Scalar(chalk_ir::Scalar::Uint(chalk_ir::UintTy::Usize)).intern(Interner)
     }
 
-    pub(crate) fn builtin(builtin: BuiltinType) -> Ty {
-        match builtin {
-            BuiltinType::Char => TyKind::Scalar(Scalar::Char).intern(Interner),
-            BuiltinType::Bool => TyKind::Scalar(Scalar::Bool).intern(Interner),
-            BuiltinType::Str => TyKind::Str.intern(Interner),
-            BuiltinType::Int(t) => {
-                TyKind::Scalar(Scalar::Int(primitive::int_ty_from_builtin(t))).intern(Interner)
-            }
-            BuiltinType::Uint(t) => {
-                TyKind::Scalar(Scalar::Uint(primitive::uint_ty_from_builtin(t))).intern(Interner)
-            }
-            BuiltinType::Float(t) => {
-                TyKind::Scalar(Scalar::Float(primitive::float_ty_from_builtin(t))).intern(Interner)
-            }
-        }
-    }
-
     pub(crate) fn unknown_subst(
         db: &dyn HirDatabase,
         def: impl Into<GenericDefId>,

src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs

@@ -6,74 +6,28 @@ mod tests;
 use base_db::Crate;
 use hir_def::{
     EnumVariantId, GeneralConstId, HasModule, StaticId,
-    expr_store::{Body, HygieneId, path::Path},
+    expr_store::Body,
     hir::{Expr, ExprId},
-    resolver::{Resolver, ValueNs},
     type_ref::LiteralConstRef,
 };
 use hir_expand::Lookup;
-use rustc_type_ir::{UnevaluatedConst, inherent::IntoKind};
-use stdx::never;
+use rustc_type_ir::inherent::IntoKind;
 use triomphe::Arc;
 
 use crate::{
-    MemoryMap, TraitEnvironment,
+    LifetimeElisionKind, MemoryMap, TraitEnvironment, TyLoweringContext,
     db::HirDatabase,
     display::DisplayTarget,
-    generics::Generics,
     infer::InferenceContext,
     mir::{MirEvalError, MirLowerError},
     next_solver::{
         Const, ConstBytes, ConstKind, DbInterner, ErrorGuaranteed, GenericArg, GenericArgs,
-        ParamConst, SolverDefId, Ty, ValueConst,
+        SolverDefId, Ty, ValueConst,
     },
 };
 
 use super::mir::{interpret_mir, lower_to_mir, pad16};
 
-pub(crate) fn path_to_const<'a, 'g>(
-    db: &'a dyn HirDatabase,
-    resolver: &Resolver<'a>,
-    path: &Path,
-    args: impl FnOnce() -> &'g Generics,
-    _expected_ty: Ty<'a>,
-) -> Option<Const<'a>> {
-    let interner = DbInterner::new_with(db, Some(resolver.krate()), None);
-    match resolver.resolve_path_in_value_ns_fully(db, path, HygieneId::ROOT) {
-        Some(ValueNs::GenericParam(p)) => {
-            let args = args();
-            match args
-                .type_or_const_param(p.into())
-                .and_then(|(idx, p)| p.const_param().map(|p| (idx, p.clone())))
-            {
-                Some((idx, _param)) => {
-                    Some(Const::new_param(interner, ParamConst { index: idx as u32, id: p }))
-                }
-                None => {
-                    never!(
-                        "Generic list doesn't contain this param: {:?}, {:?}, {:?}",
-                        args,
-                        path,
-                        p
-                    );
-                    None
-                }
-            }
-        }
-        Some(ValueNs::ConstId(c)) => {
-            let args = GenericArgs::new_from_iter(interner, []);
-            Some(Const::new(
-                interner,
-                rustc_type_ir::ConstKind::Unevaluated(UnevaluatedConst::new(
-                    SolverDefId::ConstId(c),
-                    args,
-                )),
-            ))
-        }
-        _ => None,
-    }
-}
-
 pub fn unknown_const<'db>(_ty: Ty<'db>) -> Const<'db> {
     Const::new(DbInterner::conjure(), rustc_type_ir::ConstKind::Error(ErrorGuaranteed))
 }
@@ -279,8 +233,14 @@ pub(crate) fn eval_to_const<'db>(expr: ExprId, ctx: &mut InferenceContext<'_, 'd
         return unknown_const(infer[expr]);
     }
     if let Expr::Path(p) = &ctx.body[expr] {
-        let resolver = &ctx.resolver;
-        if let Some(c) = path_to_const(ctx.db, resolver, p, || ctx.generics(), infer[expr]) {
+        let mut ctx = TyLoweringContext::new(
+            ctx.db,
+            &ctx.resolver,
+            ctx.body,
+            ctx.generic_def,
+            LifetimeElisionKind::Infer,
+        );
+        if let Some(c) = ctx.path_to_const(p) {
             return c;
         }
     }

src/tools/rust-analyzer/crates/hir-ty/src/display.rs

@@ -1062,9 +1062,9 @@ impl<'db> HirDisplay<'db> for Ty<'db> {
             TyKind::Str => write!(f, "str")?,
             TyKind::Bool => write!(f, "bool")?,
             TyKind::Char => write!(f, "char")?,
-            TyKind::Float(t) => write!(f, "{}", primitive::float_ty_to_string_ns(t))?,
-            TyKind::Int(t) => write!(f, "{}", primitive::int_ty_to_string_ns(t))?,
-            TyKind::Uint(t) => write!(f, "{}", primitive::uint_ty_to_string_ns(t))?,
+            TyKind::Float(t) => write!(f, "{}", primitive::float_ty_to_string(t))?,
+            TyKind::Int(t) => write!(f, "{}", primitive::int_ty_to_string(t))?,
+            TyKind::Uint(t) => write!(f, "{}", primitive::uint_ty_to_string(t))?,
             TyKind::Slice(t) => {
                 write!(f, "[")?;
                 t.hir_fmt(f)?;

src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs

@@ -7,7 +7,6 @@ use hir_def::{
     TypeAliasId, TypeOrConstParamId, TypeParamId, hir::generics::LocalTypeOrConstParamId,
     lang_item::LangItem, signatures::TraitFlags,
 };
-use intern::Symbol;
 use rustc_hash::FxHashSet;
 use rustc_type_ir::{
     AliasTyKind, ClauseKind, PredicatePolarity, TypeSuperVisitable as _, TypeVisitable as _,
@@ -441,8 +440,7 @@ fn receiver_is_dispatchable<'db>(
 
     // Type `U`
     // FIXME: That seems problematic to fake a generic param like that?
-    let unsized_self_ty =
-        crate::next_solver::Ty::new_param(interner, self_param_id, u32::MAX, Symbol::empty());
+    let unsized_self_ty = crate::next_solver::Ty::new_param(interner, self_param_id, u32::MAX);
     // `Receiver[Self => U]`
     let unsized_receiver_ty = receiver_for_self_ty(interner, func, receiver_ty, unsized_self_ty);
 
@@ -454,8 +452,8 @@ fn receiver_is_dispatchable<'db>(
             TraitRef::new(interner, unsize_did.into(), [self_param_ty, unsized_self_ty]);
 
         // U: Trait<Arg1, ..., ArgN>
-        let args = GenericArgs::for_item(interner, trait_.into(), |name, index, kind, _| {
-            if index == 0 { unsized_self_ty.into() } else { mk_param(interner, index, name, kind) }
+        let args = GenericArgs::for_item(interner, trait_.into(), |index, kind, _| {
+            if index == 0 { unsized_self_ty.into() } else { mk_param(interner, index, kind) }
         });
         let trait_predicate = TraitRef::new_from_args(interner, trait_.into(), args);
 
@@ -494,8 +492,8 @@ fn receiver_for_self_ty<'db>(
     let args = crate::next_solver::GenericArgs::for_item(
         interner,
         SolverDefId::FunctionId(func),
-        |name, index, kind, _| {
-            if index == 0 { self_ty.into() } else { mk_param(interner, index, name, kind) }
+        |index, kind, _| {
+            if index == 0 { self_ty.into() } else { mk_param(interner, index, kind) }
         },
     );
 

src/tools/rust-analyzer/crates/hir-ty/src/generics.rs

@@ -258,7 +258,7 @@ impl Generics {
     }
 
     /// Returns a Substitution that replaces each parameter by itself (i.e. `Ty::Param`).
-    pub fn placeholder_subst(&self, db: &dyn HirDatabase) -> Substitution {
+    pub(crate) fn placeholder_subst(&self, db: &dyn HirDatabase) -> Substitution {
         Substitution::from_iter(
             Interner,
             self.iter_id().enumerate().map(|(index, id)| match id {

src/tools/rust-analyzer/crates/hir-ty/src/infer.rs

@@ -57,7 +57,6 @@ use triomphe::Arc;
 use crate::{
     ImplTraitId, IncorrectGenericsLenKind, PathLoweringDiagnostic, TargetFeatures,
     db::{HirDatabase, InternedClosureId, InternedOpaqueTyId},
-    generics::Generics,
     infer::{
         coerce::{CoerceMany, DynamicCoerceMany},
         diagnostics::{Diagnostics, InferenceTyLoweringContext as TyLoweringContext},
@@ -72,10 +71,7 @@ use crate::{
         Tys,
         abi::Safety,
         fold::fold_tys,
-        infer::{
-            DefineOpaqueTypes,
-            traits::{Obligation, ObligationCause},
-        },
+        infer::traits::{Obligation, ObligationCause},
         mapping::ChalkToNextSolver,
     },
     traits::FnTrait,
@@ -763,8 +759,7 @@ pub(crate) struct InferenceContext<'body, 'db> {
     /// and resolve the path via its methods. This will ensure proper error reporting.
     pub(crate) resolver: Resolver<'db>,
     target_features: OnceCell<(TargetFeatures, TargetFeatureIsSafeInTarget)>,
-    generic_def: GenericDefId,
-    generics: OnceCell<Generics>,
+    pub(crate) generic_def: GenericDefId,
     table: unify::InferenceTable<'db>,
     /// The traits in scope, disregarding block modules. This is used for caching purposes.
     traits_in_scope: FxHashSet<TraitId>,
@@ -873,7 +868,6 @@ impl<'body, 'db> InferenceContext<'body, 'db> {
             return_ty: types.error, // set in collect_* calls
             types,
             target_features: OnceCell::new(),
-            generics: OnceCell::new(),
             table,
             tuple_field_accesses_rev: Default::default(),
             resume_yield_tys: None,
@@ -902,10 +896,6 @@ impl<'body, 'db> InferenceContext<'body, 'db> {
         }
     }
 
-    pub(crate) fn generics(&self) -> &Generics {
-        self.generics.get_or_init(|| crate::generics::generics(self.db, self.generic_def))
-    }
-
     #[inline]
     fn krate(&self) -> Crate {
         self.resolver.krate()
@@ -1133,7 +1123,7 @@ impl<'body, 'db> InferenceContext<'body, 'db> {
                     GenericArgs::for_item_with_defaults(
                         self.interner(),
                         va_list.into(),
-                        |_, _, id, _| self.table.next_var_for_param(id),
+                        |_, id, _| self.table.next_var_for_param(id),
                     ),
                 ),
                 None => self.err_ty(),
@@ -1676,7 +1666,7 @@ impl<'body, 'db> InferenceContext<'body, 'db> {
             .table
             .infer_ctxt
             .at(&ObligationCause::new(), self.table.trait_env.env)
-            .eq(DefineOpaqueTypes::Yes, expected, actual)
+            .eq(expected, actual)
             .map(|infer_ok| self.table.register_infer_ok(infer_ok));
         if let Err(_err) = result {
             // FIXME: Emit diagnostic.

src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs

@@ -26,7 +26,7 @@ use crate::{
         PolyProjectionPredicate, Predicate, PredicateKind, SolverDefId, Ty, TyKind,
         abi::Safety,
         infer::{
-            BoundRegionConversionTime, DefineOpaqueTypes, InferOk, InferResult,
+            BoundRegionConversionTime, InferOk, InferResult,
             traits::{ObligationCause, PredicateObligations},
         },
         util::explicit_item_bounds,
@@ -307,7 +307,7 @@ impl<'db> InferenceContext<'_, 'db> {
                         .table
                         .infer_ctxt
                         .at(&ObligationCause::new(), self.table.trait_env.env)
-                        .eq(DefineOpaqueTypes::Yes, inferred_fnptr_sig, generalized_fnptr_sig)
+                        .eq(inferred_fnptr_sig, generalized_fnptr_sig)
                         .map(|infer_ok| self.table.register_infer_ok(infer_ok));
 
                     let resolved_sig =
@@ -692,18 +692,16 @@ impl<'db> InferenceContext<'_, 'db> {
                 let InferOk { value: (), obligations } = table
                     .infer_ctxt
                     .at(&cause, table.trait_env.env)
-                    .eq(DefineOpaqueTypes::Yes, expected_ty, supplied_ty)?;
+                    .eq(expected_ty, supplied_ty)?;
                 all_obligations.extend(obligations);
             }
 
             let supplied_output_ty = supplied_sig.output();
             let cause = ObligationCause::new();
-            let InferOk { value: (), obligations } =
-                table.infer_ctxt.at(&cause, table.trait_env.env).eq(
-                    DefineOpaqueTypes::Yes,
-                    expected_sigs.liberated_sig.output(),
-                    supplied_output_ty,
-                )?;
+            let InferOk { value: (), obligations } = table
+                .infer_ctxt
+                .at(&cause, table.trait_env.env)
+                .eq(expected_sigs.liberated_sig.output(), supplied_output_ty)?;
             all_obligations.extend(obligations);
 
             let inputs = supplied_sig

src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs

@@ -63,7 +63,7 @@ use crate::{
         GenericArgs, PolyFnSig, PredicateKind, Region, RegionKind, SolverDefId, TraitRef, Ty,
         TyKind,
         infer::{
-            DefineOpaqueTypes, InferCtxt, InferOk, InferResult,
+            InferCtxt, InferOk, InferResult,
             relate::RelateResult,
             select::{ImplSource, SelectionError},
             traits::{Obligation, ObligationCause, PredicateObligation, PredicateObligations},
@@ -149,7 +149,7 @@ impl<'a, 'b, 'db> Coerce<'a, 'b, 'db> {
             let res = if this.use_lub {
                 at.lub(b, a)
             } else {
-                at.sup(DefineOpaqueTypes::Yes, b, a)
+                at.sup(b, a)
                     .map(|InferOk { value: (), obligations }| InferOk { value: b, obligations })
             };
 
@@ -1460,19 +1460,12 @@ impl<'db, 'exprs> CoerceMany<'db, 'exprs> {
             //
             // Another example is `break` with no argument expression.
             assert!(expression_ty.is_unit(), "if let hack without unit type");
-            icx.table
-                .infer_ctxt
-                .at(cause, icx.table.trait_env.env)
-                .eq(
-                    // needed for tests/ui/type-alias-impl-trait/issue-65679-inst-opaque-ty-from-val-twice.rs
-                    DefineOpaqueTypes::Yes,
-                    expected,
-                    found,
-                )
-                .map(|infer_ok| {
+            icx.table.infer_ctxt.at(cause, icx.table.trait_env.env).eq(expected, found).map(
+                |infer_ok| {
                     icx.table.register_infer_ok(infer_ok);
                     expression_ty
-                })
+                },
+            )
         };
 
         debug!(?result);

src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs

@@ -46,7 +46,7 @@ use crate::{
         AliasTy, Const, DbInterner, ErrorGuaranteed, GenericArg, GenericArgs, TraitRef, Ty, TyKind,
         TypeError,
         infer::{
-            DefineOpaqueTypes, InferOk,
+            InferOk,
             traits::{Obligation, ObligationCause},
         },
         obligation_ctxt::ObligationCtxt,
@@ -1333,7 +1333,7 @@ impl<'db> InferenceContext<'_, 'db> {
                     self.interner(),
                     box_id.into(),
                     [inner_ty.into()],
-                    |_, _, id, _| self.table.next_var_for_param(id),
+                    |_, id, _| self.table.next_var_for_param(id),
                 ),
             )
         } else {
@@ -2122,7 +2122,7 @@ impl<'db> InferenceContext<'_, 'db> {
                 .table
                 .infer_ctxt
                 .at(&ObligationCause::new(), this.table.trait_env.env)
-                .eq(DefineOpaqueTypes::Yes, formal_input_ty, coerced_ty);
+                .eq(formal_input_ty, coerced_ty);
 
             // If neither check failed, the types are compatible
             match formal_ty_error {

src/tools/rust-analyzer/crates/hir-ty/src/infer/pat.rs

@@ -358,7 +358,7 @@ impl<'db> InferenceContext<'_, 'db> {
                             self.interner(),
                             box_adt.into(),
                             std::iter::once(inner_ty.into()).chain(alloc_ty.map(Into::into)),
-                            |_, _, id, _| self.table.next_var_for_param(id),
+                            |_, id, _| self.table.next_var_for_param(id),
                         ),
                     )
                 }