Upgrade rustc crates

Changes:
 - `const_of_item()` was added to `Interner`, analogous to `type_of()`. No strongly-typed ID (yet).
 - New solver trait lang item: `TrivialClone`.
 - `TypeRelation` changed a bit, the code was copied from rustc.

Author: ChayimFriedman2

Cargo.lock

@@ -86,14 +86,14 @@ vfs-notify = { path = "./crates/vfs-notify", version = "0.0.0" }
 vfs = { path = "./crates/vfs", version = "0.0.0" }
 edition = { path = "./crates/edition", version = "0.0.0" }
 
-ra-ap-rustc_lexer = { version = "0.139", default-features = false }
-ra-ap-rustc_parse_format = { version = "0.139", default-features = false }
-ra-ap-rustc_index = { version = "0.139", default-features = false }
-ra-ap-rustc_abi = { version = "0.139", default-features = false }
-ra-ap-rustc_pattern_analysis = { version = "0.139", default-features = false }
-ra-ap-rustc_ast_ir = { version = "0.139", default-features = false }
-ra-ap-rustc_type_ir = { version = "0.139", default-features = false }
-ra-ap-rustc_next_trait_solver = { version = "0.139", default-features = false }
+ra-ap-rustc_lexer = { version = "0.143", default-features = false }
+ra-ap-rustc_parse_format = { version = "0.143", default-features = false }
+ra-ap-rustc_index = { version = "0.143", default-features = false }
+ra-ap-rustc_abi = { version = "0.143", default-features = false }
+ra-ap-rustc_pattern_analysis = { version = "0.143", default-features = false }
+ra-ap-rustc_ast_ir = { version = "0.143", default-features = false }
+ra-ap-rustc_type_ir = { version = "0.143", default-features = false }
+ra-ap-rustc_next_trait_solver = { version = "0.143", default-features = false }
 
 # local crates that aren't published to crates.io. These should not have versions.
 

Cargo.toml

@@ -237,6 +237,7 @@ language_item_table! { LangItems =>
     StructuralTeq,           sym::structural_teq,      structural_teq_trait,       TraitId,                GenericRequirement::None;
     Copy,                    sym::copy,                copy_trait,                 TraitId,                GenericRequirement::Exact(0);
     Clone,                   sym::clone,               clone_trait,                TraitId,                GenericRequirement::None;
+    TrivialClone,            sym::trivial_clone,       clone_trait,                TraitId,                GenericRequirement::None;
     Sync,                    sym::sync,                sync_trait,                 TraitId,                GenericRequirement::Exact(0);
     DiscriminantKind,        sym::discriminant_kind,   discriminant_kind_trait,    TraitId,                GenericRequirement::None;
     /// The associated item of the `DiscriminantKind` trait.

crates/hir-def/src/lang_item.rs

@@ -16,14 +16,14 @@ use tracing::{debug, instrument, warn};
 use super::{
     PredicateEmittingRelation, Relate, RelateResult, StructurallyRelateAliases, TypeRelation,
 };
-use crate::next_solver::infer::type_variable::TypeVariableValue;
 use crate::next_solver::infer::unify_key::ConstVariableValue;
 use crate::next_solver::infer::{InferCtxt, relate};
 use crate::next_solver::util::MaxUniverse;
 use crate::next_solver::{
-    AliasTy, Binder, ClauseKind, Const, ConstKind, DbInterner, GenericArgs, PredicateKind, Region,
-    SolverDefId, Term, TermVid, Ty, TyKind, TypingMode, UnevaluatedConst,
+    AliasTy, Binder, ClauseKind, Const, ConstKind, DbInterner, PredicateKind, Region, SolverDefId,
+    Term, TermVid, Ty, TyKind, TypingMode, UnevaluatedConst,
 };
+use crate::next_solver::{GenericArgs, infer::type_variable::TypeVariableValue};
 
 impl<'db> InferCtxt<'db> {
     /// The idea is that we should ensure that the type variable `target_vid`
@@ -384,29 +384,26 @@ impl<'db> TypeRelation<DbInterner<'db>> for Generalizer<'_, 'db> {
         self.infcx.interner
     }
 
-    fn relate_item_args(
+    fn relate_ty_args(
         &mut self,
-        item_def_id: SolverDefId,
-        a_arg: GenericArgs<'db>,
-        b_arg: GenericArgs<'db>,
-    ) -> RelateResult<'db, GenericArgs<'db>> {
-        if self.ambient_variance == Variance::Invariant {
+        a_ty: Ty<'db>,
+        _: Ty<'db>,
+        def_id: SolverDefId,
+        a_args: GenericArgs<'db>,
+        b_args: GenericArgs<'db>,
+        mk: impl FnOnce(GenericArgs<'db>) -> Ty<'db>,
+    ) -> RelateResult<'db, Ty<'db>> {
+        let args = if self.ambient_variance == Variance::Invariant {
             // Avoid fetching the variance if we are in an invariant
             // context; no need, and it can induce dependency cycles
             // (e.g., #41849).
-            relate::relate_args_invariantly(self, a_arg, b_arg)
+            relate::relate_args_invariantly(self, a_args, b_args)
         } else {
-            let tcx = self.cx();
-            let opt_variances = tcx.variances_of(item_def_id);
-            relate::relate_args_with_variances(
-                self,
-                item_def_id,
-                opt_variances,
-                a_arg,
-                b_arg,
-                false,
-            )
-        }
+            let interner = self.cx();
+            let variances = interner.variances_of(def_id);
+            relate::relate_args_with_variances(self, variances, a_args, b_args)
+        }?;
+        if args == a_args { Ok(a_ty) } else { Ok(mk(args)) }
     }
 
     #[instrument(level = "debug", skip(self, variance, b), ret)]

crates/hir-ty/src/next_solver/infer/relate/generalize.rs

@@ -18,17 +18,19 @@
 //! [lattices]: https://en.wikipedia.org/wiki/Lattice_(order)
 
 use rustc_type_ir::{
-    AliasRelationDirection, TypeVisitableExt, Upcast, Variance,
+    AliasRelationDirection, Interner, TypeVisitableExt, Upcast, Variance,
     inherent::{IntoKind, Span as _},
     relate::{
         Relate, StructurallyRelateAliases, TypeRelation, VarianceDiagInfo,
-        combine::{PredicateEmittingRelation, super_combine_consts, super_combine_tys},
+        combine::{
+            PredicateEmittingRelation, combine_ty_args, super_combine_consts, super_combine_tys,
+        },
     },
 };
 
 use crate::next_solver::{
-    AliasTy, Binder, Const, DbInterner, Goal, ParamEnv, Predicate, PredicateKind, Region, Span, Ty,
-    TyKind,
+    AliasTy, Binder, Const, DbInterner, GenericArgs, Goal, ParamEnv, Predicate, PredicateKind,
+    Region, SolverDefId, Span, Ty, TyKind,
     infer::{
         InferCtxt, TypeTrace,
         relate::RelateResult,
@@ -82,6 +84,19 @@ impl<'db> TypeRelation<DbInterner<'db>> for LatticeOp<'_, 'db> {
         self.infcx.interner
     }
 
+    fn relate_ty_args(
+        &mut self,
+        a_ty: Ty<'db>,
+        b_ty: Ty<'db>,
+        def_id: SolverDefId,
+        a_args: GenericArgs<'db>,
+        b_args: GenericArgs<'db>,
+        mk: impl FnOnce(GenericArgs<'db>) -> Ty<'db>,
+    ) -> RelateResult<'db, Ty<'db>> {
+        let variances = self.cx().variances_of(def_id);
+        combine_ty_args(self.infcx, self, a_ty, b_ty, variances, a_args, b_args, mk)
+    }
+
     fn relate_with_variance<T: Relate<DbInterner<'db>>>(
         &mut self,
         variance: Variance,

crates/hir-ty/src/next_solver/infer/relate/lattice.rs

@@ -25,7 +25,7 @@ use rustc_type_ir::{
     elaborate::elaborate,
     error::TypeError,
     fast_reject,
-    inherent::{self, GenericsOf, IntoKind, SliceLike as _, Span as _, Ty as _},
+    inherent::{self, Const as _, GenericsOf, IntoKind, SliceLike as _, Span as _, Ty as _},
     lang_items::{SolverAdtLangItem, SolverLangItem, SolverTraitLangItem},
     solve::SizedTraitKind,
 };
@@ -39,7 +39,7 @@ use crate::{
         AdtIdWrapper, BoundConst, CallableIdWrapper, CanonicalVarKind, ClosureIdWrapper,
         CoroutineIdWrapper, Ctor, FnSig, FxIndexMap, GeneralConstIdWrapper, ImplIdWrapper,
         OpaqueTypeKey, RegionAssumptions, SimplifiedType, SolverContext, SolverDefIds,
-        TraitIdWrapper, TypeAliasIdWrapper, util::explicit_item_bounds,
+        TraitIdWrapper, TypeAliasIdWrapper, UnevaluatedConst, util::explicit_item_bounds,
     },
 };
 
@@ -1512,6 +1512,7 @@ impl<'db> Interner for DbInterner<'db> {
             SolverTraitLangItem::BikeshedGuaranteedNoDrop => {
                 unimplemented!()
             }
+            SolverTraitLangItem::TrivialClone => lang_items.TrivialClone,
         };
         lang_item.expect("Lang item required but not found.").into()
     }
@@ -1565,6 +1566,7 @@ impl<'db> Interner for DbInterner<'db> {
             AsyncFn,
             AsyncFnMut,
             AsyncFnOnce,
+            TrivialClone,
         )
     }
 
@@ -1651,6 +1653,7 @@ impl<'db> Interner for DbInterner<'db> {
             AsyncFn,
             AsyncFnMut,
             AsyncFnOnce,
+            TrivialClone,
         )
     }
 
@@ -2167,6 +2170,18 @@ impl<'db> Interner for DbInterner<'db> {
             Some(SolverTraitLangItem::Sized | SolverTraitLangItem::MetaSized)
         )
     }
+
+    fn const_of_item(self, def_id: Self::DefId) -> rustc_type_ir::EarlyBinder<Self, Self::Const> {
+        let id = match def_id {
+            SolverDefId::StaticId(id) => id.into(),
+            SolverDefId::ConstId(id) => id.into(),
+            _ => unreachable!(),
+        };
+        EarlyBinder::bind(Const::new_unevaluated(
+            self,
+            UnevaluatedConst { def: GeneralConstIdWrapper(id), args: GenericArgs::empty(self) },
+        ))
+    }
 }
 
 impl<'db> DbInterner<'db> {

crates/hir-ty/src/next_solver/interner.rs

@@ -161,6 +161,7 @@ define_symbols! {
     cfg_select,
     char,
     clone,
+    trivial_clone,
     Clone,
     coerce_unsized,
     column,