Uplift AliasTy

Author: compiler-errors

compiler/rustc_errors/src/diagnostic_impls.rs

@@ -106,6 +106,12 @@ impl<I: rustc_type_ir::Interner> IntoDiagArg for rustc_type_ir::ExistentialTrait
 }
 }
 
+impl<I: rustc_type_ir::Interner>IntoDiagArgfor rustc_type_ir::UnevaluatedConst<I>{
+fninto_diag_arg(self) -> rustc_errors::DiagArgValue{
+format!("{self:?}").into_diag_arg()
+}
+}
+
 into_diag_arg_for_number!(i8,u8,i16,u16,i32,u32,i64,u64,i128,u128,isize,usize);
 
 implIntoDiagArgforbool{

compiler/rustc_middle/src/ty/consts.rs

@@ -7,8 +7,7 @@ use rustc_hir as hir;
 use rustc_hir::def::{DefKind,Res};
 use rustc_hir::def_id::LocalDefId;
 use rustc_macros::{HashStable,TyDecodable,TyEncodable};
-use rustc_type_ir::ConstKindasIrConstKind;
-use rustc_type_ir::{TypeFlags,WithCachedTypeInfo};
+use rustc_type_ir::{selfas ir,TypeFlags,WithCachedTypeInfo};
 
 mod int;
 mod kind;
@@ -20,7 +19,8 @@ use rustc_span::Span;
 use rustc_span::DUMMY_SP;
 pubuse valtree::*;
 
-pubtypeConstKind<'tcx> = IrConstKind<TyCtxt<'tcx>>;
+pubtypeConstKind<'tcx> = ir::ConstKind<TyCtxt<'tcx>>;
+pubtypeUnevaluatedConst<'tcx> = ir::UnevaluatedConst<TyCtxt<'tcx>>;
 
 #[cfg(target_pointer_width = "64")]
 rustc_data_structures::static_assert_size!(ConstKind<'_>,32);
@@ -184,9 +184,21 @@ impl<'tcx> rustc_type_ir::inherent::Const<TyCtxt<'tcx>> for Const<'tcx> {
 Const::new_bound(tcx, debruijn, var, ty)
 }
 
+fnnew_unevaluated(
+interner:TyCtxt<'tcx>,
+uv: ty::UnevaluatedConst<'tcx>,
+ty:Ty<'tcx>,
+) -> Self{
+Const::new_unevaluated(interner, uv, ty)
+}
+
 fnty(self) -> Ty<'tcx>{
 self.ty()
 }
+
+fninto_term(self) -> ty::Term<'tcx>{
+self.into()
+}
 }
 
 impl<'tcx>Const<'tcx>{

compiler/rustc_middle/src/ty/consts/kind.rs

@@ -1,30 +1,15 @@
 usesuper::Const;
 usecrate::mir;
 usecrate::ty::abstract_const::CastKind;
-usecrate::ty::GenericArgsRef;
 usecrate::ty::{self, visit::TypeVisitableExtas _,List,Ty,TyCtxt};
-use rustc_hir::def_id::DefId;
-use rustc_macros::{HashStable,TyDecodable,TyEncodable,TypeFoldable,TypeVisitable};
+use rustc_macros::{extension,HashStable,TyDecodable,TyEncodable,TypeFoldable,TypeVisitable};
 
-/// An unevaluated (potentially generic) constant used in the type-system.
-#[derive(Copy,Clone,Eq,PartialEq,TyEncodable,TyDecodable)]
-#[derive(Hash,HashStable,TypeFoldable,TypeVisitable)]
-pubstructUnevaluatedConst<'tcx>{
-pubdef:DefId,
-pubargs:GenericArgsRef<'tcx>,
-}
-
-impl rustc_errors::IntoDiagArgforUnevaluatedConst<'_>{
-fninto_diag_arg(self) -> rustc_errors::DiagArgValue{
-format!("{self:?}").into_diag_arg()
-}
-}
-
-impl<'tcx>UnevaluatedConst<'tcx>{
+#[extension(pub(crate)traitUnevaluatedConstEvalExt<'tcx>)]
+impl<'tcx> ty::UnevaluatedConst<'tcx>{
 /// FIXME(RalfJung): I cannot explain what this does or why it makes sense, but not doing this
 /// hurts performance.
 #[inline]
-pub(crate)fnprepare_for_eval(
+fnprepare_for_eval(
 self,
 tcx:TyCtxt<'tcx>,
 param_env: ty::ParamEnv<'tcx>,
@@ -55,13 +40,6 @@ impl<'tcx> UnevaluatedConst<'tcx> {
 }
 }
 
-impl<'tcx>UnevaluatedConst<'tcx>{
-#[inline]
-pubfnnew(def:DefId,args:GenericArgsRef<'tcx>) -> UnevaluatedConst<'tcx>{
-UnevaluatedConst{ def, args }
-}
-}
-
 #[derive(Copy,Clone,Eq,PartialEq,Hash)]
 #[derive(HashStable,TyEncodable,TyDecodable,TypeVisitable,TypeFoldable)]
 pubenumExpr<'tcx>{

compiler/rustc_middle/src/ty/context.rs

@@ -76,6 +76,7 @@ use rustc_type_ir::TyKind::*;
 use rustc_type_ir::WithCachedTypeInfo;
 use rustc_type_ir::{CollectAndApply,Interner,TypeFlags};
 
+use std::assert_matches::assert_matches;
 use std::borrow::Borrow;
 use std::cmp::Ordering;
 use std::fmt;
@@ -91,67 +92,124 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
 typeDefiningOpaqueTypes = &'tcx ty::List<LocalDefId>;
 typeAdtDef = ty::AdtDef<'tcx>;
 typeGenericArgs = ty::GenericArgsRef<'tcx>;
+typeGenericArgsSlice = &'tcx[ty::GenericArg<'tcx>];
 typeGenericArg = ty::GenericArg<'tcx>;
-typeTerm = ty::Term<'tcx>;
 
+typeTerm = ty::Term<'tcx>;
 typeBinder<T:TypeVisitable<TyCtxt<'tcx>>> = Binder<'tcx,T>;
 typeBoundVars = &'tcxList<ty::BoundVariableKind>;
 typeBoundVar = ty::BoundVariableKind;
-typeCanonicalVars = CanonicalVarInfos<'tcx>;
 
+typeCanonicalVars = CanonicalVarInfos<'tcx>;
 typeTy = Ty<'tcx>;
 typeTys = &'tcxList<Ty<'tcx>>;
-typeAliasTy = ty::AliasTy<'tcx>;
 typeParamTy = ParamTy;
 typeBoundTy = ty::BoundTy;
 typePlaceholderTy = ty::PlaceholderType;
-typeErrorGuaranteed = ErrorGuaranteed;
 
+typeErrorGuaranteed = ErrorGuaranteed;
 typeBoundExistentialPredicates = &'tcxList<PolyExistentialPredicate<'tcx>>;
 typePolyFnSig = PolyFnSig<'tcx>;
 typeAllocId = crate::mir::interpret::AllocId;
-typePat = Pattern<'tcx>;
 
+typePat = Pattern<'tcx>;
 typeConst = ty::Const<'tcx>;
 typeAliasConst = ty::UnevaluatedConst<'tcx>;
 typePlaceholderConst = ty::PlaceholderConst;
 typeParamConst = ty::ParamConst;
 typeBoundConst = ty::BoundVar;
 typeValueConst = ty::ValTree<'tcx>;
-typeExprConst = ty::Expr<'tcx>;
 
+typeExprConst = ty::Expr<'tcx>;
 typeRegion = Region<'tcx>;
 typeEarlyParamRegion = ty::EarlyParamRegion;
 typeLateParamRegion = ty::LateParamRegion;
 typeBoundRegion = ty::BoundRegion;
 typeInferRegion = ty::RegionVid;
-typePlaceholderRegion = ty::PlaceholderRegion;
 
+typePlaceholderRegion = ty::PlaceholderRegion;
 typePredicate = Predicate<'tcx>;
 typeTraitPredicate = ty::TraitPredicate<'tcx>;
 typeRegionOutlivesPredicate = ty::RegionOutlivesPredicate<'tcx>;
 typeTypeOutlivesPredicate = ty::TypeOutlivesPredicate<'tcx>;
 typeProjectionPredicate = ty::ProjectionPredicate<'tcx>;
-typeAliasTerm = ty::AliasTerm<'tcx>;
 typeNormalizesTo = ty::NormalizesTo<'tcx>;
 typeSubtypePredicate = ty::SubtypePredicate<'tcx>;
 typeCoercePredicate = ty::CoercePredicate<'tcx>;
 typeClosureKind = ty::ClosureKind;
-typeClauses = ty::Clauses<'tcx>;
 
+typeClauses = ty::Clauses<'tcx>;
 fnmk_canonical_var_infos(self,infos:&[ty::CanonicalVarInfo<Self>]) -> Self::CanonicalVars{
 self.mk_canonical_var_infos(infos)
 }
 
 typeGenericsOf = &'tcx ty::Generics;
+
 fngenerics_of(self,def_id:DefId) -> &'tcx ty::Generics{
 self.generics_of(def_id)
 }
 
+fntype_of_instantiated(self,def_id:DefId,args: ty::GenericArgsRef<'tcx>) -> Ty<'tcx>{
+self.type_of(def_id).instantiate(self, args)
+}
+
+fnalias_ty_kind(self,alias: ty::AliasTy<'tcx>) -> ty::AliasTyKind{
+matchself.def_kind(alias.def_id){
+DefKind::AssocTy => {
+ifletDefKind::Impl{of_trait:false} = self.def_kind(self.parent(alias.def_id))
+{
+ ty::Inherent
+}else{
+ ty::Projection
+}
+}
+DefKind::OpaqueTy => ty::Opaque,
+DefKind::TyAlias => ty::Weak,
+ kind => bug!("unexpected DefKind in AliasTy: {kind:?}"),
+}
+}
+
+fnalias_term_kind(self,alias: ty::AliasTerm<'tcx>) -> ty::AliasTermKind{
+matchself.def_kind(alias.def_id){
+DefKind::AssocTy => {
+ifletDefKind::Impl{of_trait:false} = self.def_kind(self.parent(alias.def_id))
+{
+ ty::AliasTermKind::InherentTy
+}else{
+ ty::AliasTermKind::ProjectionTy
+}
+}
+DefKind::OpaqueTy => ty::AliasTermKind::OpaqueTy,
+DefKind::TyAlias => ty::AliasTermKind::WeakTy,
+DefKind::AssocConst => ty::AliasTermKind::ProjectionConst,
+DefKind::AnonConst => ty::AliasTermKind::UnevaluatedConst,
+ kind => bug!("unexpected DefKind in AliasTy: {kind:?}"),
+}
+}
+
+fntrait_ref_and_own_args_for_alias(
+self,
+def_id:Self::DefId,
+args:Self::GenericArgs,
+) -> (rustc_type_ir::TraitRef<Self>,Self::GenericArgsSlice){
+assert_matches!(self.def_kind(def_id),DefKind::AssocTy | DefKind::AssocConst);
+let trait_def_id = self.parent(def_id);
+assert_matches!(self.def_kind(trait_def_id),DefKind::Trait);
+let trait_generics = self.generics_of(trait_def_id);
+(
+ ty::TraitRef::new(self, trait_def_id, args.truncate_to(self, trait_generics)),
+&args[trait_generics.count()..],
+)
+}
+
 fnmk_args(self,args:&[Self::GenericArg]) -> Self::GenericArgs{
 self.mk_args(args)
 }
 
+fnmk_args_from_iter(self,args:implIterator<Item = Self::GenericArg>) -> Self::GenericArgs{
+self.mk_args_from_iter(args)
+}
+
 fncheck_and_mk_args(
 self,
 def_id:DefId,

compiler/rustc_middle/src/ty/mod.rs

@@ -96,9 +96,9 @@ pub use self::list::{List, ListWithCachedTypeInfo};
 pubuseself::parameterized::ParameterizedOverTcx;
 pubuseself::pattern::{Pattern,PatternKind};
 pubuseself::predicate::{
-Clause,ClauseKind,CoercePredicate,ExistentialPredicate,ExistentialPredicateStableCmpExt,
-ExistentialProjection,ExistentialTraitRef,NormalizesTo,OutlivesPredicate,
-PolyCoercePredicate,PolyExistentialPredicate,PolyExistentialProjection,
+AliasTerm,Clause,ClauseKind,CoercePredicate,ExistentialPredicate,
+ExistentialPredicateStableCmpExt,ExistentialProjection,ExistentialTraitRef,NormalizesTo,
+OutlivesPredicate,PolyCoercePredicate,PolyExistentialPredicate,PolyExistentialProjection,
 PolyExistentialTraitRef,PolyProjectionPredicate,PolyRegionOutlivesPredicate,
 PolySubtypePredicate,PolyTraitPredicate,PolyTraitRef,PolyTypeOutlivesPredicate,Predicate,
 PredicateKind,ProjectionPredicate,RegionOutlivesPredicate,SubtypePredicate,ToPolyTraitRef,
@@ -110,11 +110,11 @@ pub use self::region::{
 };
 pubuseself::rvalue_scopes::RvalueScopes;
 pubuseself::sty::{
-AliasTerm,AliasTy,Article,Binder,BoundTy,BoundTyKind,BoundVariableKind,
-CanonicalPolyFnSig,ClosureArgs,ClosureArgsParts,CoroutineArgs,CoroutineArgsParts,
-CoroutineClosureArgs,CoroutineClosureArgsParts,CoroutineClosureSignature,FnSig,GenSig,
-InlineConstArgs,InlineConstArgsParts,ParamConst,ParamTy,PolyFnSig,TyKind,TypeAndMut,
-UpvarArgs,VarianceDiagInfo,
+AliasTy,Article,Binder,BoundTy,BoundTyKind,BoundVariableKind,CanonicalPolyFnSig,
+ClosureArgs,ClosureArgsParts,CoroutineArgs,CoroutineArgsParts,CoroutineClosureArgs,
+CoroutineClosureArgsParts,CoroutineClosureSignature,FnSig,GenSig,InlineConstArgs,
+InlineConstArgsParts,ParamConst,ParamTy,PolyFnSig,TyKind,TypeAndMut,UpvarArgs,
+VarianceDiagInfo,
 };
 pubuseself::trait_def::TraitDef;
 pubuseself::typeck_results::{

compiler/rustc_middle/src/ty/predicate.rs

@@ -13,6 +13,7 @@ use crate::ty::{
 };
 
 pubtypeTraitRef<'tcx> = ir::TraitRef<TyCtxt<'tcx>>;
+pubtypeAliasTerm<'tcx> = ir::AliasTerm<TyCtxt<'tcx>>;
 pubtypeProjectionPredicate<'tcx> = ir::ProjectionPredicate<TyCtxt<'tcx>>;
 pubtypeExistentialPredicate<'tcx> = ir::ExistentialPredicate<TyCtxt<'tcx>>;
 pubtypeExistentialTraitRef<'tcx> = ir::ExistentialTraitRef<TyCtxt<'tcx>>;

compiler/rustc_middle/src/ty/print/pretty.rs

@@ -3038,6 +3038,33 @@ define_print! {
  p!(write("<{} as {}>",self.self_ty(),self.print_only_trait_path()))
 }
 
+ ty::AliasTy<'tcx> {
+let alias_term: ty::AliasTerm<'tcx> = (*self).into();
+ p!(print(alias_term))
+}
+
+ ty::AliasTerm<'tcx> {
+matchself.kind(cx.tcx()){
+ ty::AliasTermKind::InherentTy => p!(pretty_print_inherent_projection(*self)),
+ ty::AliasTermKind::ProjectionTy
+ | ty::AliasTermKind::WeakTy
+ | ty::AliasTermKind::OpaqueTy
+ | ty::AliasTermKind::UnevaluatedConst
+ | ty::AliasTermKind::ProjectionConst => {
+// If we're printing verbosely, or don't want to invoke queries
+// (`is_impl_trait_in_trait`), then fall back to printing the def path.
+// This is likely what you want if you're debugging the compiler anyways.
+if !(cx.should_print_verbose() || with_reduced_queries())
+ && cx.tcx().is_impl_trait_in_trait(self.def_id)
+{
+return cx.pretty_print_opaque_impl_type(self.def_id,self.args);
+} else {
+ p!(print_def_path(self.def_id,self.args));
+}
+}
+}
+}
+
  ty::TraitPredicate<'tcx> {
  p!(print(self.trait_ref.self_ty()),": ");
  p!(pretty_print_bound_constness(self.trait_ref));
@@ -3205,33 +3232,6 @@ define_print_and_forward_display! {
 }
 }
 
- ty::AliasTy<'tcx> {
-let alias_term: ty::AliasTerm<'tcx> = (*self).into();
- p!(print(alias_term))
-}
-
- ty::AliasTerm<'tcx> {
-matchself.kind(cx.tcx()){
- ty::AliasTermKind::InherentTy => p!(pretty_print_inherent_projection(*self)),
- ty::AliasTermKind::ProjectionTy
- | ty::AliasTermKind::WeakTy
- | ty::AliasTermKind::OpaqueTy
- | ty::AliasTermKind::UnevaluatedConst
- | ty::AliasTermKind::ProjectionConst => {
-// If we're printing verbosely, or don't want to invoke queries
-// (`is_impl_trait_in_trait`), then fall back to printing the def path.
-// This is likely what you want if you're debugging the compiler anyways.
-if !(cx.should_print_verbose() || with_reduced_queries())
- && cx.tcx().is_impl_trait_in_trait(self.def_id)
-{
-return cx.pretty_print_opaque_impl_type(self.def_id,self.args);
-} else {
- p!(print_def_path(self.def_id,self.args));
-}
-}
-}
-}
-
  ty::Predicate<'tcx> {
  p!(print(self.kind()))
 }