move over all other function definitions from sty.rs

Author: Jamesbarford

compiler/rustc_codegen_gcc/src/intrinsic/simd.rs

@@ -538,7 +538,7 @@ pub fn generic_simd_intrinsic<'a, 'gcc, 'tcx>(
 
         match *in_elem.kind() {
             ty::RawPtr(p_ty, _) => {
-                let metadata = p_ty.ptr_metadata_ty(bx.tcx, |ty| {
+                let metadata = p_ty.ptr_metadata_ty(bx.tcx, &ObligationCause::dummy(), |ty| {
                     bx.tcx.normalize_erasing_regions(ty::TypingEnv::fully_monomorphized(), ty)
                 });
                 require!(
@@ -552,7 +552,7 @@ pub fn generic_simd_intrinsic<'a, 'gcc, 'tcx>(
         }
         match *out_elem.kind() {
             ty::RawPtr(p_ty, _) => {
-                let metadata = p_ty.ptr_metadata_ty(bx.tcx, |ty| {
+                let metadata = p_ty.ptr_metadata_ty(bx.tcx, &ObligationCause::dummy(), |ty| {
                     bx.tcx.normalize_erasing_regions(ty::TypingEnv::fully_monomorphized(), ty)
                 });
                 require!(

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -16,6 +16,7 @@ use rustc_data_structures::assert_matches;
 use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_hir::{self as hir};
 use rustc_middle::mir::BinOp;
+use rustc_middle::traits::ObligationCause;
 use rustc_middle::ty::layout::{FnAbiOf, HasTyCtxt, HasTypingEnv, LayoutOf};
 use rustc_middle::ty::offload_meta::OffloadMetadata;
 use rustc_middle::ty::{self, GenericArgsRef, Instance, SimdAlign, Ty, TyCtxt, TypingEnv};
@@ -2558,7 +2559,7 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
 
         match in_elem.kind() {
             ty::RawPtr(p_ty, _) => {
-                let metadata = p_ty.ptr_metadata_ty(bx.tcx, |ty| {
+                let metadata = p_ty.ptr_metadata_ty(bx.tcx, &ObligationCause::dummy(), |ty| {
                     bx.tcx.normalize_erasing_regions(bx.typing_env(), ty)
                 });
                 require!(
@@ -2572,7 +2573,7 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
         }
         match out_elem.kind() {
             ty::RawPtr(p_ty, _) => {
-                let metadata = p_ty.ptr_metadata_ty(bx.tcx, |ty| {
+                let metadata = p_ty.ptr_metadata_ty(bx.tcx, &ObligationCause::dummy(), |ty| {
                     bx.tcx.normalize_erasing_regions(bx.typing_env(), ty)
                 });
                 require!(

compiler/rustc_const_eval/src/interpret/call.rs

@@ -9,6 +9,7 @@ use rustc_data_structures::assert_matches;
 use rustc_errors::msg;
 use rustc_hir::def_id::DefId;
 use rustc_hir::find_attr;
+use rustc_infer::traits::ObligationCause;
 use rustc_middle::ty::layout::{IntegerExt, TyAndLayout};
 use rustc_middle::ty::{self, AdtDef, Instance, Ty, VariantDef};
 use rustc_middle::{bug, mir, span_bug};
@@ -221,7 +222,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 // to fields, which can yield non-normalized types. So we need to provide a
                 // normalization function.
                 let normalize = |ty| self.tcx.normalize_erasing_regions(self.typing_env, ty);
-                ty.ptr_metadata_ty(*self.tcx, normalize)
+                ty.ptr_metadata_ty(*self.tcx, &ObligationCause::dummy(), normalize)
             };
             return interp_ok(meta_ty(caller) == meta_ty(callee));
         }

compiler/rustc_lint/src/gpukernel_abi.rs

@@ -2,6 +2,7 @@ use std::iter;
 
 use rustc_abi::ExternAbi;
 use rustc_hir::{self as hir, find_attr};
+use rustc_infer::traits::ObligationCause;
 use rustc_middle::ty::{self, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeSuperFoldable};
 use rustc_session::{declare_lint, declare_lint_pass};
 use rustc_span::Span;
@@ -109,7 +110,10 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for CheckGpuKernelTypes<'tcx> {
             ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) => {}
             // Thin pointers are allowed but fat pointers with metadata are not
             ty::RawPtr(_, _) => {
-                if !ty.pointee_metadata_ty_or_projection(self.tcx).is_unit() {
+                if !ty
+                    .pointee_metadata_ty_or_projection(&ObligationCause::dummy(), self.tcx)
+                    .is_unit()
+                {
                     self.has_invalid = true;
                 }
             }

compiler/rustc_middle/src/middle/lang_items.rs

@@ -12,7 +12,7 @@ use rustc_hir::def_id::DefId;
 use rustc_span::Span;
 use rustc_target::spec::PanicStrategy;
 
-use crate::ty::{self, TyCtxt};
+use crate::ty::{self, AdtDef, TyCtxt};
 
 impl<'tcx> TyCtxt<'tcx> {
     /// Returns the `DefId` for a given `LangItem`.
@@ -27,6 +27,10 @@ impl<'tcx> TyCtxt<'tcx> {
         self.lang_items().get(lang_item) == Some(def_id)
     }
 
+    pub fn is_c_void(self, adt: AdtDef) -> bool {
+        self.is_lang_item(adt.did(), LangItem::CVoid)
+    }
+
     pub fn as_lang_item(self, def_id: DefId) -> Option<LangItem> {
         self.lang_items().from_def_id(def_id)
     }

compiler/rustc_middle/src/mir/statement.rs

@@ -6,6 +6,7 @@ use tracing::{debug, instrument};
 
 use super::interpret::GlobalAlloc;
 use super::*;
+use crate::traits::ObligationCause;
 use crate::ty::CoroutineArgsExt;
 
 ///////////////////////////////////////////////////////////////////////////
@@ -870,7 +871,9 @@ impl<'tcx> UnOp {
     pub fn ty(&self, tcx: TyCtxt<'tcx>, arg_ty: Ty<'tcx>) -> Ty<'tcx> {
         match self {
             UnOp::Not | UnOp::Neg => arg_ty,
-            UnOp::PtrMetadata => arg_ty.pointee_metadata_ty_or_projection(tcx),
+            UnOp::PtrMetadata => {
+                arg_ty.pointee_metadata_ty_or_projection(&ObligationCause::dummy(), tcx)
+            }
         }
     }
 }

compiler/rustc_middle/src/ty/adt.rs

@@ -288,6 +288,18 @@ impl<'tcx> rustc_type_ir::inherent::AdtDef<TyCtxt<'tcx>> for AdtDef<'tcx> {
             None
         }
     }
+
+    fn discriminant_for_variant(self, tcx: TyCtxt<'tcx>, variant_index: VariantIdx) -> Discr<'tcx> {
+        self.discriminant_for_variant(tcx, variant_index)
+    }
+
+    fn variant_range(self) -> Range<VariantIdx> {
+        self.variant_range()
+    }
+
+    fn repr_discr_type_to_ty(self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
+        self.repr().discr_type().to_ty(tcx)
+    }
 }
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq, HashStable, TyEncodable, TyDecodable)]

compiler/rustc_middle/src/ty/context/impl_interner.rs

@@ -18,10 +18,12 @@ use rustc_type_ir::{CollectAndApply, Interner, TypeFoldable, search_graph};
 use crate::dep_graph::{DepKind, DepNodeIndex};
 use crate::infer::canonical::CanonicalVarKinds;
 use crate::query::IntoQueryParam;
+use crate::traits::ObligationCause;
 use crate::traits::cache::WithDepNode;
 use crate::traits::solve::{
     self, CanonicalInput, ExternalConstraints, ExternalConstraintsData, QueryResult, inspect,
 };
+use crate::ty::util::Discr;
 use crate::ty::{
     self, AdtDef, Clause, Const, List, ParamTy, Pattern, PolyExistentialPredicate, Predicate,
     Region, Ty, TyCtxt, VariantDef,
@@ -50,6 +52,8 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
     type Interned<T: Copy + Clone + std::fmt::Debug + std::hash::Hash + Eq + PartialEq> =
         Interned<'tcx, T>;
     type VariantIdx = VariantIdx;
+    type Discr = Discr;
+    type ObligationCause = ObligationCause;
 
     type GenericArgs = ty::GenericArgsRef<'tcx>;
 
@@ -471,6 +475,10 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
         self.is_lang_item(def_id, solver_lang_item_to_lang_item(lang_item))
     }
 
+    pub fn is_c_void(self, adt: AdtDef) -> bool {
+        self.is_c_void(adt)
+    }
+
     fn is_trait_lang_item(self, def_id: DefId, lang_item: SolverTraitLangItem) -> bool {
         self.is_lang_item(def_id, solver_trait_lang_item_to_lang_item(lang_item))
     }
@@ -743,10 +751,36 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
         })
     }
 
+    #[inline]
+    fn i8_type(self) -> Ty<'tcx> {
+        self.types.i8
+    }
+
+    #[inline]
+    fn i16_type(self) -> Ty<'tcx> {
+        self.types.i16
+    }
+
+    #[inline]
+    fn i32_type(self) -> Ty<'tcx> {
+        self.types.i32
+    }
+
+    #[inline]
     fn u8_type(self) -> Ty<'tcx> {
         self.types.u8
     }
 
+    #[inline]
+    fn usize_type(self) -> Ty<'tcx> {
+        self.types.usize
+    }
+
+    #[inline]
+    fn unit_type(self) -> Ty<'tcx> {
+        self.types.unit
+    }
+
     fn is_async_drop_in_place_coroutine(self, def_id: DefId) -> bool {
         self.is_lang_item(self.parent(def_id), LangItem::AsyncDropInPlace)
     }
@@ -759,6 +793,16 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
     ) -> Range<VariantIdx> {
         self.coroutine_variant_range(def_id, coroutine_args)
     }
+
+    fn struct_tail_raw(
+        self,
+        mut ty: Ty<'tcx>,
+        cause: &ObligationCause<'tcx>,
+        mut normalize: impl FnMut(Ty<'tcx>) -> Ty<'tcx>,
+        mut f: impl FnMut() -> (),
+    ) -> Ty<'tcx> {
+        self.struct_tail_raw(ty, cause, normalize, f)
+    }
 }
 
 /// Defines trivial conversion functions between the main [`LangItem`] enum,

compiler/rustc_middle/src/ty/generic_args.rs

@@ -5,6 +5,7 @@ use std::marker::PhantomData;
 use std::num::NonZero;
 use std::ptr::NonNull;
 
+use rustc_abi::VariantIdx;
 use rustc_data_structures::intern::Interned;
 use rustc_errors::{DiagArgValue, IntoDiagArg};
 use rustc_hir::def_id::DefId;
@@ -15,6 +16,7 @@ use rustc_type_ir::walk::TypeWalker;
 use smallvec::SmallVec;
 
 use crate::ty::codec::{TyDecoder, TyEncoder};
+use crate::ty::util::Discr;
 use crate::ty::{
     self, ClosureArgs, CoroutineArgs, CoroutineClosureArgs, FallibleTypeFolder, InlineConstArgs,
     Lift, List, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeVisitable, TypeVisitor, VisitorResult,
@@ -122,6 +124,19 @@ impl<'tcx> rustc_type_ir::inherent::GenericArgs<TyCtxt<'tcx>> for ty::GenericArg
             _ => bug!("coroutine args missing synthetics"),
         }
     }
+
+    fn coroutine_discriminant_for_variant(
+        self,
+        def_id: DefId,
+        tcx: TyCtxt<'tcx>,
+        variant_index: VariantIdx,
+    ) -> Discr {
+        self.as_coroutine().discriminant_for_variant(def_id, tcxt, variant_index)
+    }
+
+    fn as_coroutine_discr_ty(self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
+        self.as_coroutine().discr_ty(tcxt)
+    }
 }
 
 impl<'tcx> rustc_type_ir::inherent::IntoKind for GenericArg<'tcx> {