Stop relying on rustc_type_ir in non-type-system crates

Author: compiler-errors

Cargo.lock

@@ -3440,7 +3440,6 @@ dependencies = [
 "rustc_symbol_mangling",
 "rustc_target",
 "rustc_trait_selection",
-"rustc_type_ir",
 "serde_json",
 "smallvec",
 "tempfile",
@@ -3473,7 +3472,6 @@ dependencies = [
 "rustc_span",
 "rustc_target",
 "rustc_trait_selection",
-"rustc_type_ir",
 "tracing",
 ]
 
@@ -3736,7 +3734,6 @@ dependencies = [
 "rustc_span",
 "rustc_target",
 "rustc_trait_selection",
-"rustc_type_ir",
 "smallvec",
 "tracing",
 ]
@@ -3775,7 +3772,6 @@ dependencies = [
 "rustc_session",
 "rustc_span",
 "rustc_trait_selection",
-"rustc_type_ir",
 "smallvec",
 "tracing",
 ]
@@ -3922,7 +3918,6 @@ dependencies = [
 "rustc_span",
 "rustc_target",
 "rustc_trait_selection",
-"rustc_type_ir",
 "smallvec",
 "tracing",
 "unicode-security",
@@ -3998,7 +3993,6 @@ dependencies = [
 "rustc_session",
 "rustc_span",
 "rustc_target",
-"rustc_type_ir",
 "tempfile",
 "tracing",
 ]
@@ -4114,7 +4108,6 @@ dependencies = [
 "rustc_span",
 "rustc_target",
 "rustc_trait_selection",
-"rustc_type_ir",
 "smallvec",
 "tracing",
 ]
@@ -4538,7 +4531,6 @@ dependencies = [
 "rustc_span",
 "rustc_target",
 "rustc_trait_selection",
-"rustc_type_ir",
 "tracing",
 ]
 

compiler/rustc_codegen_ssa/Cargo.toml

@@ -40,7 +40,6 @@ rustc_span = { path = "../rustc_span" }
 rustc_symbol_mangling = { path = "../rustc_symbol_mangling" }
 rustc_target = { path = "../rustc_target" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }
-rustc_type_ir = { path = "../rustc_type_ir" }
 serde_json = "1.0.59"
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
 tempfile = "3.2"

compiler/rustc_codegen_ssa/src/errors.rs

@@ -12,10 +12,9 @@ use rustc_errors::{
 Diag,DiagArgValue,DiagCtxtHandle,Diagnostic,EmissionGuarantee,IntoDiagArg,Level,
 };
 use rustc_macros::{Diagnostic,LintDiagnostic,Subdiagnostic};
-use rustc_middle::ty::Ty;
 use rustc_middle::ty::layout::LayoutError;
+use rustc_middle::ty::{FloatTy,Ty};
 use rustc_span::{Span,Symbol};
-use rustc_type_ir::FloatTy;
 
 usecrate::assert_module_sources::CguReuse;
 usecrate::back::command::Command;

compiler/rustc_codegen_ssa/src/mir/constant.rs

@@ -43,7 +43,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
  mir::Const::Ty(_, c) => match c.kind(){
 // A constant that came from a const generic but was then used as an argument to
 // old-style simd_shuffle (passing as argument instead of as a generic param).
-rustc_type_ir::ConstKind::Value(cv) => returnOk(Ok(cv.valtree)),
+ty::ConstKind::Value(cv) => returnOk(Ok(cv.valtree)),
  other => span_bug!(constant.span,"{other:#?}"),
 },
 // We should never encounter `Const::Val` unless MIR opts (like const prop) evaluate

compiler/rustc_const_eval/Cargo.toml

@@ -23,6 +23,5 @@ rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }
-rustc_type_ir = { path = "../rustc_type_ir" }
 tracing = "0.1"
 # tidy-alphabetical-end

compiler/rustc_const_eval/src/interpret/cast.rs

@@ -9,7 +9,6 @@ use rustc_middle::ty::adjustment::PointerCoercion;
 use rustc_middle::ty::layout::{IntegerExt,LayoutOf,TyAndLayout};
 use rustc_middle::ty::{self,FloatTy,Ty};
 use rustc_middle::{bug, span_bug};
-use rustc_type_ir::TyKind::*;
 use tracing::trace;
 
 usesuper::util::ensure_monomorphic_enough;
@@ -182,9 +181,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
 src:&ImmTy<'tcx,M::Provenance>,
 cast_to:TyAndLayout<'tcx>,
 ) -> InterpResult<'tcx,ImmTy<'tcx,M::Provenance>>{
-use rustc_type_ir::TyKind::*;
-
-letFloat(fty) = src.layout.ty.kind()else{
+let ty::Float(fty) = src.layout.ty.kind()else{
 bug!("FloatToFloat/FloatToInt cast: source type {} is not a float type", src.layout.ty)
 };
 let val = match fty {
@@ -277,27 +274,27 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
 let signed = src_layout.backend_repr.is_signed();// Also asserts that abi is `Scalar`.
 
 let v = match src_layout.ty.kind(){
-Uint(_) | RawPtr(..) | FnPtr(..) => scalar.to_uint(src_layout.size)?,
-Int(_) => scalar.to_int(src_layout.size)? asu128,// we will cast back to `i128` below if the sign matters
-Bool => scalar.to_bool()?.into(),
-Char => scalar.to_char()?.into(),
+ty::Uint(_) | ty::RawPtr(..) | ty::FnPtr(..) => scalar.to_uint(src_layout.size)?,
+ty::Int(_) => scalar.to_int(src_layout.size)? asu128,// we will cast back to `i128` below if the sign matters
+ty::Bool => scalar.to_bool()?.into(),
+ty::Char => scalar.to_char()?.into(),
  _ => span_bug!(self.cur_span(),"invalid int-like cast from {}", src_layout.ty),
 };
 
 interp_ok(match*cast_ty.kind(){
 // int -> int
-Int(_) | Uint(_) => {
+ty::Int(_) | ty::Uint(_) => {
 let size = match*cast_ty.kind(){
-Int(t) => Integer::from_int_ty(self, t).size(),
-Uint(t) => Integer::from_uint_ty(self, t).size(),
+ty::Int(t) => Integer::from_int_ty(self, t).size(),
+ty::Uint(t) => Integer::from_uint_ty(self, t).size(),
  _ => bug!(),
 };
 let v = size.truncate(v);
 Scalar::from_uint(v, size)
 }
 
 // signed int -> float
-Float(fty)if signed => {
+ty::Float(fty)if signed => {
 let v = v asi128;
 match fty {
 FloatTy::F16 => Scalar::from_f16(Half::from_i128(v).value),
@@ -307,15 +304,15 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
 }
 }
 // unsigned int -> float
-Float(fty) => match fty {
+ty::Float(fty) => match fty {
 FloatTy::F16 => Scalar::from_f16(Half::from_u128(v).value),
 FloatTy::F32 => Scalar::from_f32(Single::from_u128(v).value),
 FloatTy::F64 => Scalar::from_f64(Double::from_u128(v).value),
 FloatTy::F128 => Scalar::from_f128(Quad::from_u128(v).value),
 },
 
 // u8 -> char
-Char => Scalar::from_u32(u8::try_from(v).unwrap().into()),
+ty::Char => Scalar::from_u32(u8::try_from(v).unwrap().into()),
 
 // Casts to bool are not permitted by rustc, no need to handle them here.
  _ => span_bug!(self.cur_span(),"invalid int to {} cast", cast_ty),
@@ -332,11 +329,9 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
  + FloatConvert<Double>
  + FloatConvert<Quad>,
 {
-use rustc_type_ir::TyKind::*;
-
 match*dest_ty.kind(){
 // float -> uint
-Uint(t) => {
+ty::Uint(t) => {
 let size = Integer::from_uint_ty(self, t).size();
 // `to_u128` is a saturating cast, which is what we need
 // (https://doc.rust-lang.org/nightly/nightly-rustc/rustc_apfloat/trait.Float.html#method.to_i128_r).
@@ -345,15 +340,15 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
 Scalar::from_uint(v, size)
 }
 // float -> int
-Int(t) => {
+ty::Int(t) => {
 let size = Integer::from_int_ty(self, t).size();
 // `to_i128` is a saturating cast, which is what we need
 // (https://doc.rust-lang.org/nightly/nightly-rustc/rustc_apfloat/trait.Float.html#method.to_i128_r).
 let v = f.to_i128(size.bits_usize()).value;
 Scalar::from_int(v, size)
 }
 // float -> float
-Float(fty) => match fty {
+ty::Float(fty) => match fty {
 FloatTy::F16 => {
 Scalar::from_f16(self.adjust_nan(f.convert(&mutfalse).value,&[f]))
 }

compiler/rustc_hir_analysis/Cargo.toml

@@ -28,7 +28,6 @@ rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }
-rustc_type_ir = { path = "../rustc_type_ir" }
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
 tracing = "0.1"
 # tidy-alphabetical-end

compiler/rustc_hir_analysis/src/check/check.rs

@@ -21,15 +21,14 @@ use rustc_middle::ty::error::TypeErrorToStringExt;
 use rustc_middle::ty::layout::{LayoutError,MAX_SIMD_LANES};
 use rustc_middle::ty::util::{Discr,IntTypeExt};
 use rustc_middle::ty::{
-AdtDef,BottomUpFolder,GenericArgKind,RegionKind,TypeSuperVisitable,TypeVisitable,
-TypeVisitableExt, fold_regions,
+AdtDef,BottomUpFolder,GenericArgKind,RegionKind,TypeFoldable,TypeSuperVisitable,
+TypeVisitable,TypeVisitableExt, fold_regions,
 };
 use rustc_session::lint::builtin::UNINHABITED_STATIC;
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::error_reporting::traits::on_unimplemented::OnUnimplementedDirective;
 use rustc_trait_selection::traits;
 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt;
-use rustc_type_ir::TypeFoldable;
 use tracing::{debug, instrument};
 use ty::TypingMode;
 use{rustc_attr_parsing as attr, rustc_hir as hir};

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -16,10 +16,12 @@ use rustc_lint_defs::builtin::SUPERTRAIT_ITEM_SHADOWING_DEFINITION;
 use rustc_macros::LintDiagnostic;
 use rustc_middle::mir::interpret::ErrorHandled;
 use rustc_middle::query::Providers;
+use rustc_middle::traits::solve::NoSolution;
 use rustc_middle::ty::trait_def::TraitSpecializationKind;
 use rustc_middle::ty::{
-self,AdtKind,GenericArgKind,GenericArgs,GenericParamDefKind,Ty,TyCtxt,TypeFoldable,
-TypeSuperVisitable,TypeVisitable,TypeVisitableExt,TypeVisitor,TypingMode,Upcast,
+self,AdtKind,GenericArgKind,GenericArgs,GenericParamDefKind,Ty,TyCtxt,TypeFlags,
+TypeFoldable,TypeSuperVisitable,TypeVisitable,TypeVisitableExt,TypeVisitor,TypingMode,
+Upcast,
 };
 use rustc_middle::{bug, span_bug};
 use rustc_session::parse::feature_err;
@@ -34,8 +36,6 @@ use rustc_trait_selection::traits::{
 self,FulfillmentError,Obligation,ObligationCause,ObligationCauseCode,ObligationCtxt,
 WellFormedLoc,
 };
-use rustc_type_ir::TypeFlags;
-use rustc_type_ir::solve::NoSolution;
 use tracing::{debug, instrument};
 use{rustc_ast as ast, rustc_hir as hir};
 

compiler/rustc_hir_analysis/src/coherence/builtin.rs

@@ -250,13 +250,16 @@ fn visit_implementation_of_dispatch_from_dyn(checker: &Checker<'_>) -> Result<()
 // trait, they *do* satisfy the repr(transparent) rules, and then we assume that everything else
 // in the compiler (in particular, all the call ABI logic) will treat them as repr(transparent)
 // even if they do not carry that attribute.
-use rustc_type_ir::TyKind::*;
 match(source.kind(), target.kind()){
-(&Ref(r_a, _, mutbl_a),Ref(r_b, _, mutbl_b))if r_a == *r_b && mutbl_a == *mutbl_b => {
+(&ty::Ref(r_a, _, mutbl_a), ty::Ref(r_b, _, mutbl_b))
+if r_a == *r_b && mutbl_a == *mutbl_b =>
+{
 Ok(())
 }
-(&RawPtr(_, a_mutbl),&RawPtr(_, b_mutbl))if a_mutbl == b_mutbl => Ok(()),
-(&Adt(def_a, args_a),&Adt(def_b, args_b))if def_a.is_struct() && def_b.is_struct() => {
+(&ty::RawPtr(_, a_mutbl),&ty::RawPtr(_, b_mutbl))if a_mutbl == b_mutbl => Ok(()),
+(&ty::Adt(def_a, args_a),&ty::Adt(def_b, args_b))
+if def_a.is_struct() && def_b.is_struct() =>
+{
 if def_a != def_b {
 let source_path = tcx.def_path_str(def_a.did());
 let target_path = tcx.def_path_str(def_b.did());