diff options
| -rw-r--r-- | Cargo.lock | 12 | ||||
| -rw-r--r-- | compiler/rustc_type_ir/Cargo.toml | 1 | ||||
| -rw-r--r-- | compiler/rustc_type_ir/src/canonical.rs | 22 | ||||
| -rw-r--r-- | compiler/rustc_type_ir/src/const_kind.rs | 73 | ||||
| -rw-r--r-- | compiler/rustc_type_ir/src/predicate_kind.rs | 83 | ||||
| -rw-r--r-- | compiler/rustc_type_ir/src/region_kind.rs | 79 | ||||
| -rw-r--r-- | compiler/rustc_type_ir/src/ty_kind.rs | 170 | ||||
| -rw-r--r-- | src/tools/tidy/src/deps.rs | 1 |
8 files changed, 50 insertions, 391 deletions
diff --git a/Cargo.lock b/Cargo.lock index 2b1e918e2f5..a9090201710 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1012,6 +1012,17 @@ dependencies = [ ] [[package]] +name = "derivative" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] name = "derive_builder" version = "0.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" @@ -4667,6 +4678,7 @@ name = "rustc_type_ir" version = "0.0.0" dependencies = [ "bitflags 1.3.2", + "derivative", "rustc_data_structures", "rustc_index", "rustc_macros", diff --git a/compiler/rustc_type_ir/Cargo.toml b/compiler/rustc_type_ir/Cargo.toml index 484757e2fc1..b39ba305913 100644 --- a/compiler/rustc_type_ir/Cargo.toml +++ b/compiler/rustc_type_ir/Cargo.toml @@ -6,6 +6,7 @@ edition = "2021" [dependencies] # tidy-alphabetical-start bitflags = "1.2.1" +derivative = "2.2.0" rustc_data_structures = { path = "../rustc_data_structures" } rustc_index = { path = "../rustc_index" } rustc_macros = { path = "../rustc_macros" } diff --git a/compiler/rustc_type_ir/src/canonical.rs b/compiler/rustc_type_ir/src/canonical.rs index c0b6aed98ef..c8e730b585a 100644 --- a/compiler/rustc_type_ir/src/canonical.rs +++ b/compiler/rustc_type_ir/src/canonical.rs @@ -1,5 +1,5 @@ use std::fmt; -use std::hash; +use std::hash::Hash; use std::ops::ControlFlow; use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; @@ -13,6 +13,8 @@ use crate::{HashStableContext, Interner, TyEncoder, UniverseIndex}; /// A "canonicalized" type `V` is one where all free inference /// variables have been rewritten to "canonical vars". These are /// numbered starting from 0 in order of first appearance. +#[derive(derivative::Derivative)] +#[derivative(Clone(bound = "V: Clone"), Hash(bound = "V: Hash"))] pub struct Canonical<I: Interner, V> { pub value: V, pub max_universe: UniverseIndex, @@ -59,14 +61,6 @@ impl<I: Interner, V> Canonical<I, V> { } } -impl<I: Interner, V: hash::Hash> hash::Hash for Canonical<I, V> { - fn hash<H: hash::Hasher>(&self, state: &mut H) { - self.value.hash(state); - self.max_universe.hash(state); - self.variables.hash(state); - } -} - impl<CTX: HashStableContext, I: Interner, V: HashStable<CTX>> HashStable<CTX> for Canonical<I, V> where I::CanonicalVars: HashStable<CTX>, @@ -108,16 +102,6 @@ impl<I: Interner, V: fmt::Debug> fmt::Debug for Canonical<I, V> { } } -impl<I: Interner, V: Clone> Clone for Canonical<I, V> { - fn clone(&self) -> Self { - Canonical { - value: self.value.clone(), - max_universe: self.max_universe.clone(), - variables: self.variables.clone(), - } - } -} - impl<I: Interner, V: Copy> Copy for Canonical<I, V> where I::CanonicalVars: Copy {} impl<I: Interner, V: TypeFoldable<I>> TypeFoldable<I> for Canonical<I, V> diff --git a/compiler/rustc_type_ir/src/const_kind.rs b/compiler/rustc_type_ir/src/const_kind.rs index a40c41583af..cf67ba0b21a 100644 --- a/compiler/rustc_type_ir/src/const_kind.rs +++ b/compiler/rustc_type_ir/src/const_kind.rs @@ -1,9 +1,7 @@ use rustc_data_structures::stable_hasher::HashStable; use rustc_data_structures::stable_hasher::StableHasher; use rustc_serialize::{Decodable, Decoder, Encodable}; -use std::cmp::Ordering; use std::fmt; -use std::hash; use crate::{ DebruijnIndex, DebugWithInfcx, HashStableContext, InferCtxtLike, Interner, TyDecoder, @@ -13,7 +11,15 @@ use crate::{ use self::ConstKind::*; /// Represents a constant in Rust. -// #[derive(derive_more::From)] +#[derive(derivative::Derivative)] +#[derivative( + Clone(bound = ""), + PartialOrd(bound = ""), + PartialOrd = "feature_allow_slow_enum", + Ord(bound = ""), + Ord = "feature_allow_slow_enum", + Hash(bound = "") +)] pub enum ConstKind<I: Interner> { /// A const generic parameter. Param(I::ParamConst), @@ -57,25 +63,6 @@ const fn const_kind_discriminant<I: Interner>(value: &ConstKind<I>) -> usize { } } -impl<I: Interner> hash::Hash for ConstKind<I> { - fn hash<H: hash::Hasher>(&self, state: &mut H) { - const_kind_discriminant(self).hash(state); - match self { - Param(p) => p.hash(state), - Infer(i) => i.hash(state), - Bound(d, b) => { - d.hash(state); - b.hash(state); - } - Placeholder(p) => p.hash(state), - Unevaluated(u) => u.hash(state), - Value(v) => v.hash(state), - Error(e) => e.hash(state), - Expr(e) => e.hash(state), - } - } -} - impl<CTX: HashStableContext, I: Interner> HashStable<CTX> for ConstKind<I> where I::ParamConst: HashStable<CTX>, @@ -166,33 +153,6 @@ where } } -impl<I: Interner> PartialOrd for ConstKind<I> { - fn partial_cmp(&self, other: &Self) -> Option<Ordering> { - Some(self.cmp(other)) - } -} - -impl<I: Interner> Ord for ConstKind<I> { - fn cmp(&self, other: &Self) -> Ordering { - const_kind_discriminant(self) - .cmp(&const_kind_discriminant(other)) - .then_with(|| match (self, other) { - (Param(p1), Param(p2)) => p1.cmp(p2), - (Infer(i1), Infer(i2)) => i1.cmp(i2), - (Bound(d1, b1), Bound(d2, b2)) => d1.cmp(d2).then_with(|| b1.cmp(b2)), - (Placeholder(p1), Placeholder(p2)) => p1.cmp(p2), - (Unevaluated(u1), Unevaluated(u2)) => u1.cmp(u2), - (Value(v1), Value(v2)) => v1.cmp(v2), - (Error(e1), Error(e2)) => e1.cmp(e2), - (Expr(e1), Expr(e2)) => e1.cmp(e2), - _ => { - debug_assert!(false, "This branch must be unreachable, maybe the match is missing an arm? self = {self:?}, other = {other:?}"); - Ordering::Equal - } - }) - } -} - impl<I: Interner> PartialEq for ConstKind<I> { fn eq(&self, other: &Self) -> bool { match (self, other) { @@ -211,21 +171,6 @@ impl<I: Interner> PartialEq for ConstKind<I> { impl<I: Interner> Eq for ConstKind<I> {} -impl<I: Interner> Clone for ConstKind<I> { - fn clone(&self) -> Self { - match self { - Param(arg0) => Param(arg0.clone()), - Infer(arg0) => Infer(arg0.clone()), - Bound(arg0, arg1) => Bound(arg0.clone(), arg1.clone()), - Placeholder(arg0) => Placeholder(arg0.clone()), - Unevaluated(arg0) => Unevaluated(arg0.clone()), - Value(arg0) => Value(arg0.clone()), - Error(arg0) => Error(arg0.clone()), - Expr(arg0) => Expr(arg0.clone()), - } - } -} - impl<I: Interner> fmt::Debug for ConstKind<I> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { WithInfcx::with_no_infcx(self).fmt(f) diff --git a/compiler/rustc_type_ir/src/predicate_kind.rs b/compiler/rustc_type_ir/src/predicate_kind.rs index f6fabe691c6..23117fdd531 100644 --- a/compiler/rustc_type_ir/src/predicate_kind.rs +++ b/compiler/rustc_type_ir/src/predicate_kind.rs @@ -2,7 +2,6 @@ use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; use rustc_serialize::Decoder; use rustc_serialize::{Decodable, Encodable}; use std::fmt; -use std::hash; use std::ops::ControlFlow; use crate::fold::{FallibleTypeFolder, TypeFoldable}; @@ -12,6 +11,8 @@ use crate::{TyDecoder, TyEncoder}; /// A clause is something that can appear in where bounds or be inferred /// by implied bounds. +#[derive(derivative::Derivative)] +#[derivative(Clone(bound = ""), Hash(bound = ""))] pub enum ClauseKind<I: Interner> { /// Corresponds to `where Foo: Bar<A, B, C>`. `Foo` here would be /// the `Self` type of the trait reference and `A`, `B`, and `C` @@ -39,20 +40,6 @@ pub enum ClauseKind<I: Interner> { ConstEvaluatable(I::Const), } -impl<I: Interner> Clone for ClauseKind<I> { - fn clone(&self) -> Self { - match self { - Self::Trait(arg0) => Self::Trait(arg0.clone()), - Self::RegionOutlives(arg0) => Self::RegionOutlives(arg0.clone()), - Self::TypeOutlives(arg0) => Self::TypeOutlives(arg0.clone()), - Self::Projection(arg0) => Self::Projection(arg0.clone()), - Self::ConstArgHasType(arg0, arg1) => Self::ConstArgHasType(arg0.clone(), arg1.clone()), - Self::WellFormed(arg0) => Self::WellFormed(arg0.clone()), - Self::ConstEvaluatable(arg0) => Self::ConstEvaluatable(arg0.clone()), - } - } -} - impl<I: Interner> Copy for ClauseKind<I> where I::Ty: Copy, @@ -94,24 +81,6 @@ fn clause_kind_discriminant<I: Interner>(value: &ClauseKind<I>) -> usize { } } -impl<I: Interner> hash::Hash for ClauseKind<I> { - fn hash<H: hash::Hasher>(&self, state: &mut H) { - clause_kind_discriminant(self).hash(state); - match self { - ClauseKind::Trait(p) => p.hash(state), - ClauseKind::RegionOutlives(p) => p.hash(state), - ClauseKind::TypeOutlives(p) => p.hash(state), - ClauseKind::Projection(p) => p.hash(state), - ClauseKind::ConstArgHasType(c, t) => { - c.hash(state); - t.hash(state); - } - ClauseKind::WellFormed(t) => t.hash(state), - ClauseKind::ConstEvaluatable(c) => c.hash(state), - } - } -} - impl<CTX: HashStableContext, I: Interner> HashStable<CTX> for ClauseKind<I> where I::Ty: HashStable<CTX>, @@ -249,6 +218,8 @@ where } } +#[derive(derivative::Derivative)] +#[derivative(Clone(bound = ""), Hash(bound = ""))] pub enum PredicateKind<I: Interner> { /// Prove a clause Clause(ClauseKind<I>), @@ -305,25 +276,6 @@ where { } -impl<I: Interner> Clone for PredicateKind<I> { - fn clone(&self) -> Self { - match self { - Self::Clause(arg0) => Self::Clause(arg0.clone()), - Self::ObjectSafe(arg0) => Self::ObjectSafe(arg0.clone()), - Self::ClosureKind(arg0, arg1, arg2) => { - Self::ClosureKind(arg0.clone(), arg1.clone(), arg2.clone()) - } - Self::Subtype(arg0) => Self::Subtype(arg0.clone()), - Self::Coerce(arg0) => Self::Coerce(arg0.clone()), - Self::ConstEquate(arg0, arg1) => Self::ConstEquate(arg0.clone(), arg1.clone()), - Self::Ambiguous => Self::Ambiguous, - Self::AliasRelate(arg0, arg1, arg2) => { - Self::AliasRelate(arg0.clone(), arg1.clone(), arg2.clone()) - } - } - } -} - impl<I: Interner> PartialEq for PredicateKind<I> { fn eq(&self, other: &Self) -> bool { match (self, other) { @@ -358,33 +310,6 @@ fn predicate_kind_discriminant<I: Interner>(value: &PredicateKind<I>) -> usize { } } -impl<I: Interner> hash::Hash for PredicateKind<I> { - fn hash<H: hash::Hasher>(&self, state: &mut H) { - predicate_kind_discriminant(self).hash(state); - match self { - PredicateKind::Clause(p) => p.hash(state), - PredicateKind::ObjectSafe(d) => d.hash(state), - PredicateKind::ClosureKind(d, g, k) => { - d.hash(state); - g.hash(state); - k.hash(state); - } - PredicateKind::Subtype(p) => p.hash(state), - PredicateKind::Coerce(p) => p.hash(state), - PredicateKind::ConstEquate(c1, c2) => { - c1.hash(state); - c2.hash(state); - } - PredicateKind::Ambiguous => {} - PredicateKind::AliasRelate(t1, t2, r) => { - t1.hash(state); - t2.hash(state); - r.hash(state); - } - } - } -} - impl<CTX: HashStableContext, I: Interner> HashStable<CTX> for PredicateKind<I> where I::DefId: HashStable<CTX>, diff --git a/compiler/rustc_type_ir/src/region_kind.rs b/compiler/rustc_type_ir/src/region_kind.rs index 19576ea58f1..72f86fc0692 100644 --- a/compiler/rustc_type_ir/src/region_kind.rs +++ b/compiler/rustc_type_ir/src/region_kind.rs @@ -1,9 +1,7 @@ use rustc_data_structures::stable_hasher::HashStable; use rustc_data_structures::stable_hasher::StableHasher; use rustc_serialize::{Decodable, Decoder, Encodable}; -use std::cmp::Ordering; use std::fmt; -use std::hash; use crate::{ DebruijnIndex, DebugWithInfcx, HashStableContext, InferCtxtLike, Interner, TyDecoder, @@ -118,6 +116,15 @@ use self::RegionKind::*; /// [1]: https://smallcultfollowing.com/babysteps/blog/2013/10/29/intermingled-parameter-lists/ /// [2]: https://smallcultfollowing.com/babysteps/blog/2013/11/04/intermingled-parameter-lists/ /// [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/traits/hrtb.html +#[derive(derivative::Derivative)] +#[derivative( + Clone(bound = ""), + PartialOrd(bound = ""), + PartialOrd = "feature_allow_slow_enum", + Ord(bound = ""), + Ord = "feature_allow_slow_enum", + Hash(bound = "") +)] pub enum RegionKind<I: Interner> { /// Region bound in a type or fn declaration which will be /// substituted 'early' -- that is, at the same time when type @@ -178,22 +185,6 @@ where { } -// This is manually implemented because a derive would require `I: Clone` -impl<I: Interner> Clone for RegionKind<I> { - fn clone(&self) -> Self { - match self { - ReEarlyBound(r) => ReEarlyBound(r.clone()), - ReLateBound(d, r) => ReLateBound(*d, r.clone()), - ReFree(r) => ReFree(r.clone()), - ReStatic => ReStatic, - ReVar(r) => ReVar(r.clone()), - RePlaceholder(r) => RePlaceholder(r.clone()), - ReErased => ReErased, - ReError(r) => ReError(r.clone()), - } - } -} - // This is manually implemented because a derive would require `I: PartialEq` impl<I: Interner> PartialEq for RegionKind<I> { #[inline] @@ -222,58 +213,6 @@ impl<I: Interner> PartialEq for RegionKind<I> { // This is manually implemented because a derive would require `I: Eq` impl<I: Interner> Eq for RegionKind<I> {} -// This is manually implemented because a derive would require `I: PartialOrd` -impl<I: Interner> PartialOrd for RegionKind<I> { - #[inline] - fn partial_cmp(&self, other: &RegionKind<I>) -> Option<Ordering> { - Some(self.cmp(other)) - } -} - -// This is manually implemented because a derive would require `I: Ord` -impl<I: Interner> Ord for RegionKind<I> { - #[inline] - fn cmp(&self, other: &RegionKind<I>) -> Ordering { - regionkind_discriminant(self).cmp(®ionkind_discriminant(other)).then_with(|| { - match (self, other) { - (ReEarlyBound(a_r), ReEarlyBound(b_r)) => a_r.cmp(b_r), - (ReLateBound(a_d, a_r), ReLateBound(b_d, b_r)) => { - a_d.cmp(b_d).then_with(|| a_r.cmp(b_r)) - } - (ReFree(a_r), ReFree(b_r)) => a_r.cmp(b_r), - (ReStatic, ReStatic) => Ordering::Equal, - (ReVar(a_r), ReVar(b_r)) => a_r.cmp(b_r), - (RePlaceholder(a_r), RePlaceholder(b_r)) => a_r.cmp(b_r), - (ReErased, ReErased) => Ordering::Equal, - _ => { - debug_assert!(false, "This branch must be unreachable, maybe the match is missing an arm? self = self = {self:?}, other = {other:?}"); - Ordering::Equal - } - } - }) - } -} - -// This is manually implemented because a derive would require `I: Hash` -impl<I: Interner> hash::Hash for RegionKind<I> { - fn hash<H: hash::Hasher>(&self, state: &mut H) -> () { - regionkind_discriminant(self).hash(state); - match self { - ReEarlyBound(r) => r.hash(state), - ReLateBound(d, r) => { - d.hash(state); - r.hash(state) - } - ReFree(r) => r.hash(state), - ReStatic => (), - ReVar(r) => r.hash(state), - RePlaceholder(r) => r.hash(state), - ReErased => (), - ReError(_) => (), - } - } -} - impl<I: Interner> DebugWithInfcx<I> for RegionKind<I> { fn fmt<Infcx: InferCtxtLike<Interner = I>>( this: WithInfcx<'_, Infcx, &Self>, diff --git a/compiler/rustc_type_ir/src/ty_kind.rs b/compiler/rustc_type_ir/src/ty_kind.rs index b542547589a..dceb5ba0560 100644 --- a/compiler/rustc_type_ir/src/ty_kind.rs +++ b/compiler/rustc_type_ir/src/ty_kind.rs @@ -3,9 +3,8 @@ use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; use rustc_data_structures::unify::{EqUnifyValue, UnifyKey}; use rustc_serialize::{Decodable, Decoder, Encodable}; -use std::cmp::Ordering; +use std::fmt; use std::mem::discriminant; -use std::{fmt, hash}; use crate::HashStableContext; use crate::Interner; @@ -114,6 +113,15 @@ pub enum AliasKind { /// Types written by the user start out as `hir::TyKind` and get /// converted to this representation using `AstConv::ast_ty_to_ty`. #[rustc_diagnostic_item = "IrTyKind"] +#[derive(derivative::Derivative)] +#[derivative( + Clone(bound = ""), + PartialOrd(bound = ""), + PartialOrd = "feature_allow_slow_enum", + Ord(bound = ""), + Ord = "feature_allow_slow_enum", + Hash(bound = "") +)] pub enum TyKind<I: Interner> { /// The primitive boolean type. Written as `bool`. Bool, @@ -324,40 +332,6 @@ const fn tykind_discriminant<I: Interner>(value: &TyKind<I>) -> usize { } } -// This is manually implemented because a derive would require `I: Clone` -impl<I: Interner> Clone for TyKind<I> { - fn clone(&self) -> Self { - match self { - Bool => Bool, - Char => Char, - Int(i) => Int(*i), - Uint(u) => Uint(*u), - Float(f) => Float(*f), - Adt(d, s) => Adt(d.clone(), s.clone()), - Foreign(d) => Foreign(d.clone()), - Str => Str, - Array(t, c) => Array(t.clone(), c.clone()), - Slice(t) => Slice(t.clone()), - RawPtr(p) => RawPtr(p.clone()), - Ref(r, t, m) => Ref(r.clone(), t.clone(), m.clone()), - FnDef(d, s) => FnDef(d.clone(), s.clone()), - FnPtr(s) => FnPtr(s.clone()), - Dynamic(p, r, repr) => Dynamic(p.clone(), r.clone(), *repr), - Closure(d, s) => Closure(d.clone(), s.clone()), - Coroutine(d, s, m) => Coroutine(d.clone(), s.clone(), m.clone()), - CoroutineWitness(d, s) => CoroutineWitness(d.clone(), s.clone()), - Never => Never, - Tuple(t) => Tuple(t.clone()), - Alias(k, p) => Alias(*k, p.clone()), - Param(p) => Param(p.clone()), - Bound(d, b) => Bound(*d, b.clone()), - Placeholder(p) => Placeholder(p.clone()), - Infer(t) => Infer(t.clone()), - Error(e) => Error(e.clone()), - } - } -} - // This is manually implemented because a derive would require `I: PartialEq` impl<I: Interner> PartialEq for TyKind<I> { #[inline] @@ -410,129 +384,6 @@ impl<I: Interner> PartialEq for TyKind<I> { // This is manually implemented because a derive would require `I: Eq` impl<I: Interner> Eq for TyKind<I> {} -// This is manually implemented because a derive would require `I: PartialOrd` -impl<I: Interner> PartialOrd for TyKind<I> { - #[inline] - fn partial_cmp(&self, other: &TyKind<I>) -> Option<Ordering> { - Some(self.cmp(other)) - } -} - -// This is manually implemented because a derive would require `I: Ord` -impl<I: Interner> Ord for TyKind<I> { - #[inline] - fn cmp(&self, other: &TyKind<I>) -> Ordering { - tykind_discriminant(self).cmp(&tykind_discriminant(other)).then_with(|| { - match (self, other) { - (Int(a_i), Int(b_i)) => a_i.cmp(b_i), - (Uint(a_u), Uint(b_u)) => a_u.cmp(b_u), - (Float(a_f), Float(b_f)) => a_f.cmp(b_f), - (Adt(a_d, a_s), Adt(b_d, b_s)) => a_d.cmp(b_d).then_with(|| a_s.cmp(b_s)), - (Foreign(a_d), Foreign(b_d)) => a_d.cmp(b_d), - (Array(a_t, a_c), Array(b_t, b_c)) => a_t.cmp(b_t).then_with(|| a_c.cmp(b_c)), - (Slice(a_t), Slice(b_t)) => a_t.cmp(b_t), - (RawPtr(a_t), RawPtr(b_t)) => a_t.cmp(b_t), - (Ref(a_r, a_t, a_m), Ref(b_r, b_t, b_m)) => { - a_r.cmp(b_r).then_with(|| a_t.cmp(b_t).then_with(|| a_m.cmp(b_m))) - } - (FnDef(a_d, a_s), FnDef(b_d, b_s)) => a_d.cmp(b_d).then_with(|| a_s.cmp(b_s)), - (FnPtr(a_s), FnPtr(b_s)) => a_s.cmp(b_s), - (Dynamic(a_p, a_r, a_repr), Dynamic(b_p, b_r, b_repr)) => { - a_p.cmp(b_p).then_with(|| a_r.cmp(b_r).then_with(|| a_repr.cmp(b_repr))) - } - (Closure(a_p, a_s), Closure(b_p, b_s)) => a_p.cmp(b_p).then_with(|| a_s.cmp(b_s)), - (Coroutine(a_d, a_s, a_m), Coroutine(b_d, b_s, b_m)) => { - a_d.cmp(b_d).then_with(|| a_s.cmp(b_s).then_with(|| a_m.cmp(b_m))) - } - ( - CoroutineWitness(a_d, a_s), - CoroutineWitness(b_d, b_s), - ) => match Ord::cmp(a_d, b_d) { - Ordering::Equal => Ord::cmp(a_s, b_s), - cmp => cmp, - }, - (Tuple(a_t), Tuple(b_t)) => a_t.cmp(b_t), - (Alias(a_i, a_p), Alias(b_i, b_p)) => a_i.cmp(b_i).then_with(|| a_p.cmp(b_p)), - (Param(a_p), Param(b_p)) => a_p.cmp(b_p), - (Bound(a_d, a_b), Bound(b_d, b_b)) => a_d.cmp(b_d).then_with(|| a_b.cmp(b_b)), - (Placeholder(a_p), Placeholder(b_p)) => a_p.cmp(b_p), - (Infer(a_t), Infer(b_t)) => a_t.cmp(b_t), - (Error(a_e), Error(b_e)) => a_e.cmp(b_e), - (Bool, Bool) | (Char, Char) | (Str, Str) | (Never, Never) => Ordering::Equal, - _ => { - debug_assert!(false, "This branch must be unreachable, maybe the match is missing an arm? self = {self:?}, other = {other:?}"); - Ordering::Equal - } - } - }) - } -} - -// This is manually implemented because a derive would require `I: Hash` -impl<I: Interner> hash::Hash for TyKind<I> { - fn hash<__H: hash::Hasher>(&self, state: &mut __H) -> () { - tykind_discriminant(self).hash(state); - match self { - Int(i) => i.hash(state), - Uint(u) => u.hash(state), - Float(f) => f.hash(state), - Adt(d, s) => { - d.hash(state); - s.hash(state) - } - Foreign(d) => d.hash(state), - Array(t, c) => { - t.hash(state); - c.hash(state) - } - Slice(t) => t.hash(state), - RawPtr(t) => t.hash(state), - Ref(r, t, m) => { - r.hash(state); - t.hash(state); - m.hash(state) - } - FnDef(d, s) => { - d.hash(state); - s.hash(state) - } - FnPtr(s) => s.hash(state), - Dynamic(p, r, repr) => { - p.hash(state); - r.hash(state); - repr.hash(state) - } - Closure(d, s) => { - d.hash(state); - s.hash(state) - } - Coroutine(d, s, m) => { - d.hash(state); - s.hash(state); - m.hash(state) - } - CoroutineWitness(d, s) => { - d.hash(state); - s.hash(state); - } - Tuple(t) => t.hash(state), - Alias(i, p) => { - i.hash(state); - p.hash(state); - } - Param(p) => p.hash(state), - Bound(d, b) => { - d.hash(state); - b.hash(state) - } - Placeholder(p) => p.hash(state), - Infer(t) => t.hash(state), - Error(e) => e.hash(state), - Bool | Char | Str | Never => (), - } - } -} - impl<I: Interner> DebugWithInfcx<I> for TyKind<I> { fn fmt<Infcx: InferCtxtLike<Interner = I>>( this: WithInfcx<'_, Infcx, &Self>, @@ -614,6 +465,7 @@ impl<I: Interner> DebugWithInfcx<I> for TyKind<I> { } } } + // This is manually implemented because a derive would require `I: Debug` impl<I: Interner> fmt::Debug for TyKind<I> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs index f89faacc2d1..4b12e9172af 100644 --- a/src/tools/tidy/src/deps.rs +++ b/src/tools/tidy/src/deps.rs @@ -142,6 +142,7 @@ const PERMITTED_RUSTC_DEPENDENCIES: &[&str] = &[ "darling_core", "darling_macro", "datafrog", + "derivative", "derive_more", "derive_setters", "digest", |