Swathes of errors solved

Author: Jamesbarford

compiler/rustc_middle/src/middle/deduced_param_attrs.rs

@@ -1,5 +1,6 @@
 use rustc_macros::{Decodable, Encodable, HashStable};
 
+use crate::ty::util::TyUtil;
 use crate::ty::{Ty, TyCtxt, TypingEnv};
 
 /// Summarizes how a parameter (a return place or an argument) is used inside a MIR body.

compiler/rustc_middle/src/mir/interpret/mod.rs

@@ -45,6 +45,7 @@ pub use self::value::Scalar;
 use crate::mir;
 use crate::ty::codec::{TyDecoder, TyEncoder};
 use crate::ty::print::with_no_trimmed_paths;
+use crate::ty::util::TyUtil;
 use crate::ty::{self, Instance, Ty, TyCtxt};
 
 /// Uniquely identifies one of the following:

compiler/rustc_middle/src/query/keys.rs

@@ -9,7 +9,6 @@ use rustc_data_structures::stable_hasher::HashStable;
 use rustc_hir::def_id::{CrateNum, DefId, LOCAL_CRATE, LocalDefId, LocalModDefId};
 use rustc_hir::hir_id::OwnerId;
 use rustc_span::{DUMMY_SP, Ident, LocalExpnId, Span, Symbol};
-use rustc_type_ir::inherent::IntoKind;
 
 use crate::dep_graph::DepNodeIndex;
 use crate::ich::StableHashingContext;
@@ -270,7 +269,7 @@ impl<'tcx> QueryKey for Ty<'tcx> {
     fn def_id_for_ty_in_cycle(&self) -> Option<DefId> {
         match self.kind() {
             ty::Adt(adt, _) => Some(adt.did()),
-            ty::Coroutine(def_id, ..) => Some(def_id),
+            ty::Coroutine(def_id, ..) => Some(*def_id),
             _ => None,
         }
     }

compiler/rustc_middle/src/query/on_disk_cache.rs

@@ -21,6 +21,7 @@ use rustc_span::{
     BlobDecoder, BytePos, ByteSymbol, CachingSourceMapView, ExpnData, ExpnHash, RelativeBytePos,
     SourceFile, Span, SpanDecoder, SpanEncoder, Spanned, StableSourceFileId, Symbol,
 };
+use rustc_type_ir::{TyDecoder, TyEncoder};
 
 use crate::dep_graph::{DepNodeIndex, QuerySideEffect, SerializedDepNodeIndex};
 use crate::mir::interpret::{AllocDecodingSession, AllocDecodingState};

compiler/rustc_middle/src/thir.rs

@@ -31,6 +31,7 @@ use crate::mir::{self, AssignOp, BinOp, BorrowKind, FakeReadCause, UnOp};
 use crate::thir::visit::for_each_immediate_subpat;
 use crate::ty::adjustment::PointerCoercion;
 use crate::ty::layout::IntegerExt;
+use crate::ty::util::TyUtil;
 use crate::ty::{
     self, AdtDef, CanonicalUserType, CanonicalUserTypeAnnotation, FnSig, GenericArgsRef, Ty,
     TyCtxt, UpvarArgs,

compiler/rustc_middle/src/ty/adt.rs

@@ -207,6 +207,12 @@ impl<'tcx> AdtDef<'tcx> {
         self.0.0.repr
     }
 
+    /// Asserts this is a struct or union and returns its unique variant.
+    pub fn non_enum_variant(self) -> &'tcx VariantDef {
+        assert!(self.is_struct() || self.is_union());
+        self.variant(FIRST_VARIANT)
+    }
+
     pub fn field_representing_type_info(
         self,
         tcx: TyCtxt<'tcx>,
@@ -336,8 +342,7 @@ impl<'tcx> rustc_type_ir::inherent::AdtDef<TyCtxt<'tcx>> for AdtDef<'tcx> {
 
     /// Asserts this is a struct or union and returns its unique variant.
     fn non_enum_variant(self) -> &'tcx VariantDef {
-        assert!(self.is_struct() || self.is_union());
-        self.variant(FIRST_VARIANT)
+        self.non_enum_variant()
     }
 
     fn repr_is_simd(self) -> bool {

compiler/rustc_middle/src/ty/consts.rs

@@ -6,6 +6,7 @@ use rustc_macros::HashStable;
 use rustc_type_ir::walk::TypeWalker;
 use rustc_type_ir::{self as ir, TypeFlags, WithCachedTypeInfo};
 
+use crate::mir::ConstValue;
 use crate::mir::interpret::Scalar;
 use crate::ty::{self, Ty, TyCtxt};
 
@@ -215,7 +216,7 @@ impl<'tcx> rustc_type_ir::inherent::Const<TyCtxt<'tcx>> for Const<'tcx> {
     }
 
     fn try_to_target_usize(&self, tcx: TyCtxt<'tcx>) -> Option<u64> {
-        Some(self.try_to_scalar_int()?.to_target_usize(tcx))
+        self.try_to_value()?.try_to_target_usize(tcx)
     }
 
     #[inline]

compiler/rustc_middle/src/ty/context.rs

@@ -2298,7 +2298,9 @@ impl<'tcx> TyCtxt<'tcx> {
             GenericParamDefKind::Lifetime => {
                 ty::Region::new_early_param(self, param.to_early_bound_region_data()).into()
             }
-            GenericParamDefKind::Type { .. } => Ty::new_param(self, param.index, param.name).into(),
+            GenericParamDefKind::Type { .. } => {
+                Ty::new_param(self, ty::ParamTy::new(param.index, param.name)).into()
+            }
             GenericParamDefKind::Const { .. } => {
                 ty::Const::new_param(self, ParamConst { index: param.index, name: param.name })
                     .into()

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

@@ -312,18 +312,8 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
         }
     }
 
-    /// Given the `DefId`, returns the `DefId` of the innermost item that
-    /// has its own type-checking context or "inference environment".
-    ///
-    /// For example, a closure has its own `DefId`, but it is type-checked
-    /// with the containing item. Therefore, when we fetch the `typeck` of the closure,
-    /// for example, we really wind up fetching the `typeck` of the enclosing fn item.
     fn typeck_root_def_id(self, def_id: DefId) -> DefId {
-        let mut def_id = def_id;
-        while self.is_typeck_child(def_id) {
-            def_id = self.parent(def_id);
-        }
-        def_id
+        self.typeck_root_def_id(def_id)
     }
 
     fn debug_assert_new_dynamic_compatible(
@@ -909,11 +899,11 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
     }
 
     fn get_anon_bound_ty(self, id: usize) -> Option<Vec<Ty<'tcx>>> {
-        self.types.anon_bound_tys.get(id).copied()
+        self.types.anon_bound_tys.get(id).cloned()
     }
 
     fn get_anon_canonical_bound_ty(self, id: usize) -> Option<Ty<'tcx>> {
-        self.types.anon_canonical_bound_tys.get(id.as_usize()).copied()
+        self.types.anon_canonical_bound_tys.get(id).copied()
     }
 
     fn get_generic_args_for_item(
@@ -1047,6 +1037,19 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
         let context_ty = Ty::new_adt(self, context_adt_ref, context_args);
         Ty::new_mut_ref(self, self.lifetimes.re_erased, context_ty)
     }
+
+    fn new_fn_def(
+        self,
+        def_id: DefId,
+        args: impl IntoIterator<Item: Into<ty::GenericArg<'tcx>>>,
+    ) -> Ty<'tcx> {
+        debug_assert_matches!(
+            self.def_kind(def_id),
+            DefKind::AssocFn | DefKind::Fn | DefKind::Ctor(_, CtorKind::Fn)
+        );
+        let args = self.check_and_mk_args(def_id, args);
+        Ty::new(self, ty::FnDef(def_id, args))
+    }
 }
 
 /// Defines trivial conversion functions between the main [`LangItem`] enum,

compiler/rustc_middle/src/ty/diagnostics.rs

@@ -13,6 +13,7 @@ use rustc_hir::{self as hir, AmbigArg, LangItem, PredicateOrigin, WherePredicate
 use rustc_span::{BytePos, Span};
 use rustc_type_ir::TyKind::*;
 
+use crate::ty::util::TyUtil;
 use crate::ty::{
     self, AliasTy, Const, ConstKind, FallibleTypeFolder, InferConst, InferTy, Instance, Opaque,
     PolyTraitPredicate, Projection, Ty, TyCtxt, TypeFoldable, TypeSuperFoldable,