Move ty::{BoundConst, CReaderCacheKey, ClosureSizeProfileData, CrateInherentImpls, CrateVariancesMap, Destructor, DestructuredConst, ImplHeader, ImplOverlapKind, ImplSubject, InferVarInfo, OpaqueTypeKey, VariantDiscr, VariantFlags} to their own little modules (cute)

Author: WaffleLapkin

compiler/rustc_middle/src/ty/bound_const.rs

@@ -0,0 +1,8 @@
+use crate::ty::{BoundVar, Ty};
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, HashStable)]
+#[derive(TyEncodable, TyDecodable, PartialOrd, Ord)]
+pub struct BoundConst<'tcx> {
+    pub var: BoundVar,
+    pub ty: Ty<'tcx>,
+}

compiler/rustc_middle/src/ty/c_reader_cache_key.rs

@@ -0,0 +1,9 @@
+use rustc_hir::def_id::CrateNum;
+
+/// Contains information needed to resolve types and (in the future) look up
+/// the types of AST nodes.
+#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+pub struct CReaderCacheKey {
+    pub cnum: Option<CrateNum>,
+    pub pos: usize,
+}

compiler/rustc_middle/src/ty/closure_size_profile_data.rs

@@ -0,0 +1,10 @@
+use crate::ty::Ty;
+
+#[derive(Clone, Debug, PartialEq, Eq, Copy, Hash, TyEncodable, TyDecodable, HashStable)]
+#[derive(TypeFoldable, TypeVisitable)]
+pub struct ClosureSizeProfileData<'tcx> {
+    /// Tuple containing the types of closure captures before the feature `capture_disjoint_fields`
+    pub before_feature_tys: Ty<'tcx>,
+    /// Tuple containing the types of closure captures after the feature `capture_disjoint_fields`
+    pub after_feature_tys: Ty<'tcx>,
+}

compiler/rustc_middle/src/ty/crate_inherent_impls.rs

@@ -0,0 +1,15 @@
+use rustc_data_structures::fx::FxHashMap;
+use rustc_hir::def_id::{DefId, LocalDefId, LocalDefIdMap};
+
+use crate::ty::SimplifiedType;
+
+/// A map for the local crate mapping each type to a vector of its
+/// inherent impls. This is not meant to be used outside of coherence;
+/// rather, you should request the vector for a specific type via
+/// `tcx.inherent_impls(def_id)` so as to minimize your dependencies
+/// (constructing this map requires touching the entire crate).
+#[derive(Clone, Debug, Default, HashStable)]
+pub struct CrateInherentImpls {
+    pub inherent_impls: LocalDefIdMap<Vec<DefId>>,
+    pub incoherent_impls: FxHashMap<SimplifiedType, Vec<LocalDefId>>,
+}

compiler/rustc_middle/src/ty/crate_variances_map.rs

@@ -0,0 +1,17 @@
+use rustc_hir::def_id::DefIdMap;
+
+use crate::ty;
+
+/// The crate variances map is computed during typeck and contains the
+/// variance of every item in the local crate. You should not use it
+/// directly, because to do so will make your pass dependent on the
+/// HIR of every item in the local crate. Instead, use
+/// `tcx.variances_of()` to get the variance for a *particular*
+/// item.
+#[derive(HashStable, Debug)]
+pub struct CrateVariancesMap<'tcx> {
+    /// For each item with generics, maps to a vector of the variance
+    /// of its generics. If an item has no generics, it will have no
+    /// entry.
+    pub variances: DefIdMap<&'tcx [ty::Variance]>,
+}

compiler/rustc_middle/src/ty/destructor.rs

@@ -0,0 +1,10 @@
+use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
+
+#[derive(Copy, Clone, Debug, HashStable, Encodable, Decodable)]
+pub struct Destructor {
+    /// The `DefId` of the destructor method
+    pub did: DefId,
+    /// The constness of the destructor method
+    pub constness: hir::Constness,
+}

compiler/rustc_middle/src/ty/destructured_const.rs

@@ -0,0 +1,8 @@
+use crate::ty::{self, VariantIdx};
+
+/// The constituent parts of a type level constant of kind ADT or array.
+#[derive(Copy, Clone, Debug, HashStable)]
+pub struct DestructuredConst<'tcx> {
+    pub variant: Option<VariantIdx>,
+    pub fields: &'tcx [ty::Const<'tcx>],
+}

compiler/rustc_middle/src/ty/impl_header.rs

@@ -0,0 +1,14 @@
+use rustc_hir::def_id::DefId;
+
+use crate::ty::{Predicate, TraitRef, Ty};
+
+/// The "header" of an impl is everything outside the body: a Self type, a trait
+/// ref (in the case of a trait impl), and a set of predicates (from the
+/// bounds / where-clauses).
+#[derive(Clone, Debug, TypeFoldable, TypeVisitable)]
+pub struct ImplHeader<'tcx> {
+    pub impl_def_id: DefId,
+    pub self_ty: Ty<'tcx>,
+    pub trait_ref: Option<TraitRef<'tcx>>,
+    pub predicates: Vec<Predicate<'tcx>>,
+}

compiler/rustc_middle/src/ty/impl_overlap_kind.rs

@@ -0,0 +1,41 @@
+#[derive(Debug, PartialEq, Eq)]
+pub enum ImplOverlapKind {
+    /// These impls are always allowed to overlap.
+    Permitted {
+        /// Whether or not the impl is permitted due to the trait being a `#[marker]` trait
+        marker: bool,
+    },
+    /// These impls are allowed to overlap, but that raises
+    /// an issue #33140 future-compatibility warning.
+    ///
+    /// Some background: in Rust 1.0, the trait-object types `Send + Sync` (today's
+    /// `dyn Send + Sync`) and `Sync + Send` (now `dyn Sync + Send`) were different.
+    ///
+    /// The widely-used version 0.1.0 of the crate `traitobject` had accidentally relied
+    /// that difference, making what reduces to the following set of impls:
+    ///
+    /// ```compile_fail,(E0119)
+    /// trait Trait {}
+    /// impl Trait for dyn Send + Sync {}
+    /// impl Trait for dyn Sync + Send {}
+    /// ```
+    ///
+    /// Obviously, once we made these types be identical, that code causes a coherence
+    /// error and a fairly big headache for us. However, luckily for us, the trait
+    /// `Trait` used in this case is basically a marker trait, and therefore having
+    /// overlapping impls for it is sound.
+    ///
+    /// To handle this, we basically regard the trait as a marker trait, with an additional
+    /// future-compatibility warning. To avoid accidentally "stabilizing" this feature,
+    /// it has the following restrictions:
+    ///
+    /// 1. The trait must indeed be a marker-like trait (i.e., no items), and must be
+    /// positive impls.
+    /// 2. The trait-ref of both impls must be equal.
+    /// 3. The trait-ref of both impls must be a trait object type consisting only of
+    /// marker traits.
+    /// 4. Neither of the impls can have any where-clauses.
+    ///
+    /// Once `traitobject` 0.1.0 is no longer an active concern, this hack can be removed.
+    Issue33140,
+}

compiler/rustc_middle/src/ty/impl_subject.rs

@@ -0,0 +1,7 @@
+use crate::ty::{TraitRef, Ty};
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug, TypeFoldable, TypeVisitable)]
+pub enum ImplSubject<'tcx> {
+    Trait(TraitRef<'tcx>),
+    Inherent(Ty<'tcx>),
+}

compiler/rustc_middle/src/ty/infer_var_info.rs

@@ -0,0 +1,12 @@
+#[derive(Debug, Default, Copy, Clone)]
+pub struct InferVarInfo {
+    /// This is true if we identified that this Ty (`?T`) is found in a `?T: Foo`
+    /// obligation, where:
+    ///
+    ///  * `Foo` is not `Sized`
+    ///  * `(): Foo` may be satisfied
+    pub self_in_trait: bool,
+    /// This is true if we identified that this Ty (`?T`) is found in a `<_ as
+    /// _>::AssocType = ?T`
+    pub output: bool,
+}