From de83057ac4b050702042c01177dd6e4e9aa7b2af Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Mon, 30 Oct 2023 17:09:17 +0000
Subject: [PATCH 1/3] Use derivative for Clone
---
Cargo.lock | 12 +++++++
compiler/rustc_type_ir/Cargo.toml | 1 +
compiler/rustc_type_ir/src/canonical.rs | 12 ++-----
compiler/rustc_type_ir/src/const_kind.rs | 18 ++--------
compiler/rustc_type_ir/src/predicate_kind.rs | 37 +++-----------------
compiler/rustc_type_ir/src/region_kind.rs | 18 ++--------
compiler/rustc_type_ir/src/ty_kind.rs | 37 ++------------------
src/tools/tidy/src/deps.rs | 1 +
8 files changed, 27 insertions(+), 109 deletions(-)
diff --git a/Cargo.lock b/Cargo.lock
index 2b1e918e2f5ea..a9090201710a4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1011,6 +1011,17 @@ dependencies = [
"syn 2.0.29",
]
+[[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"
@@ -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 484757e2fc1a9..b39ba305913e3 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 c0b6aed98ef2e..1333a29a141cd 100644
--- a/compiler/rustc_type_ir/src/canonical.rs
+++ b/compiler/rustc_type_ir/src/canonical.rs
@@ -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"))]
pub struct Canonical<I: Interner, V> {
pub value: V,
pub max_universe: UniverseIndex,
@@ -108,16 +110,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 a40c41583af5c..3e0162328eefb 100644
--- a/compiler/rustc_type_ir/src/const_kind.rs
+++ b/compiler/rustc_type_ir/src/const_kind.rs
@@ -13,7 +13,8 @@ use crate::{
use self::ConstKind::*;
/// Represents a constant in Rust.
-// #[derive(derive_more::From)]
+#[derive(derivative::Derivative)]
+#[derivative(Clone(bound = ""))]
pub enum ConstKind<I: Interner> {
/// A const generic parameter.
Param(I::ParamConst),
@@ -211,21 +212,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 f6fabe691c6a7..124d9d0eb9598 100644
--- a/compiler/rustc_type_ir/src/predicate_kind.rs
+++ b/compiler/rustc_type_ir/src/predicate_kind.rs
@@ -12,6 +12,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 = ""))]
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 +41,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,
@@ -249,6 +237,8 @@ where
}
}
+#[derive(derivative::Derivative)]
+#[derivative(Clone(bound = ""))]
pub enum PredicateKind<I: Interner> {
/// Prove a clause
Clause(ClauseKind<I>),
@@ -305,25 +295,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) {
diff --git a/compiler/rustc_type_ir/src/region_kind.rs b/compiler/rustc_type_ir/src/region_kind.rs
index 19576ea58f1f0..66115adefeaf1 100644
--- a/compiler/rustc_type_ir/src/region_kind.rs
+++ b/compiler/rustc_type_ir/src/region_kind.rs
@@ -118,6 +118,8 @@ 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 = ""))]
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 +180,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]
diff --git a/compiler/rustc_type_ir/src/ty_kind.rs b/compiler/rustc_type_ir/src/ty_kind.rs
index b542547589ac4..39116d33c3634 100644
--- a/compiler/rustc_type_ir/src/ty_kind.rs
+++ b/compiler/rustc_type_ir/src/ty_kind.rs
@@ -114,6 +114,8 @@ 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 = ""))]
pub enum TyKind<I: Interner> {
/// The primitive boolean type. Written as `bool`.
Bool,
@@ -324,40 +326,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]
@@ -614,6 +582,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 f89faacc2d17b..4b12e9172af7f 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",
From 8eb932dcf07753f532c12ae880359f8f392728b0 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Mon, 30 Oct 2023 17:22:55 +0000
Subject: [PATCH 2/3] Use derivative for PartialOrd/ord
---
compiler/rustc_type_ir/src/const_kind.rs | 36 +++---------
compiler/rustc_type_ir/src/region_kind.rs | 41 +++-----------
compiler/rustc_type_ir/src/ty_kind.rs | 67 +++--------------------
3 files changed, 21 insertions(+), 123 deletions(-)
diff --git a/compiler/rustc_type_ir/src/const_kind.rs b/compiler/rustc_type_ir/src/const_kind.rs
index 3e0162328eefb..3c986f64d38d7 100644
--- a/compiler/rustc_type_ir/src/const_kind.rs
+++ b/compiler/rustc_type_ir/src/const_kind.rs
@@ -1,7 +1,6 @@
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;
@@ -14,7 +13,13 @@ use self::ConstKind::*;
/// Represents a constant in Rust.
#[derive(derivative::Derivative)]
-#[derivative(Clone(bound = ""))]
+#[derivative(
+ Clone(bound = ""),
+ PartialOrd(bound = ""),
+ PartialOrd = "feature_allow_slow_enum",
+ Ord(bound = ""),
+ Ord = "feature_allow_slow_enum"
+)]
pub enum ConstKind<I: Interner> {
/// A const generic parameter.
Param(I::ParamConst),
@@ -167,33 +172,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) {
diff --git a/compiler/rustc_type_ir/src/region_kind.rs b/compiler/rustc_type_ir/src/region_kind.rs
index 66115adefeaf1..8dc1cc0800584 100644
--- a/compiler/rustc_type_ir/src/region_kind.rs
+++ b/compiler/rustc_type_ir/src/region_kind.rs
@@ -1,7 +1,6 @@
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;
@@ -119,7 +118,13 @@ use self::RegionKind::*;
/// [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 = ""))]
+#[derivative(
+ Clone(bound = ""),
+ PartialOrd(bound = ""),
+ PartialOrd = "feature_allow_slow_enum",
+ Ord(bound = ""),
+ Ord = "feature_allow_slow_enum"
+)]
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
@@ -208,38 +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) -> () {
diff --git a/compiler/rustc_type_ir/src/ty_kind.rs b/compiler/rustc_type_ir/src/ty_kind.rs
index 39116d33c3634..f180ceb7b0710 100644
--- a/compiler/rustc_type_ir/src/ty_kind.rs
+++ b/compiler/rustc_type_ir/src/ty_kind.rs
@@ -3,7 +3,6 @@
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::mem::discriminant;
use std::{fmt, hash};
@@ -115,7 +114,13 @@ pub enum AliasKind {
/// converted to this representation using `AstConv::ast_ty_to_ty`.
#[rustc_diagnostic_item = "IrTyKind"]
#[derive(derivative::Derivative)]
-#[derivative(Clone(bound = ""))]
+#[derivative(
+ Clone(bound = ""),
+ PartialOrd(bound = ""),
+ PartialOrd = "feature_allow_slow_enum",
+ Ord(bound = ""),
+ Ord = "feature_allow_slow_enum"
+)]
pub enum TyKind<I: Interner> {
/// The primitive boolean type. Written as `bool`.
Bool,
@@ -378,64 +383,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) -> () {
From 8b4fa0f8b507c7c98a31d18c0969e73284383542 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Mon, 30 Oct 2023 17:26:29 +0000
Subject: [PATCH 3/3] Use derivative for Hash
---
compiler/rustc_type_ir/src/canonical.rs | 12 +---
compiler/rustc_type_ir/src/const_kind.rs | 23 +------
compiler/rustc_type_ir/src/predicate_kind.rs | 50 +-------------
compiler/rustc_type_ir/src/region_kind.rs | 24 +------
compiler/rustc_type_ir/src/ty_kind.rs | 70 +-------------------
5 files changed, 11 insertions(+), 168 deletions(-)
diff --git a/compiler/rustc_type_ir/src/canonical.rs b/compiler/rustc_type_ir/src/canonical.rs
index 1333a29a141cd..c8e730b585ad9 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};
@@ -14,7 +14,7 @@ use crate::{HashStableContext, Interner, TyEncoder, UniverseIndex};
/// 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"))]
+#[derivative(Clone(bound = "V: Clone"), Hash(bound = "V: Hash"))]
pub struct Canonical<I: Interner, V> {
pub value: V,
pub max_universe: UniverseIndex,
@@ -61,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>,
diff --git a/compiler/rustc_type_ir/src/const_kind.rs b/compiler/rustc_type_ir/src/const_kind.rs
index 3c986f64d38d7..cf67ba0b21a1a 100644
--- a/compiler/rustc_type_ir/src/const_kind.rs
+++ b/compiler/rustc_type_ir/src/const_kind.rs
@@ -2,7 +2,6 @@ use rustc_data_structures::stable_hasher::HashStable;
use rustc_data_structures::stable_hasher::StableHasher;
use rustc_serialize::{Decodable, Decoder, Encodable};
use std::fmt;
-use std::hash;
use crate::{
DebruijnIndex, DebugWithInfcx, HashStableContext, InferCtxtLike, Interner, TyDecoder,
@@ -18,7 +17,8 @@ use self::ConstKind::*;
PartialOrd(bound = ""),
PartialOrd = "feature_allow_slow_enum",
Ord(bound = ""),
- Ord = "feature_allow_slow_enum"
+ Ord = "feature_allow_slow_enum",
+ Hash(bound = "")
)]
pub enum ConstKind<I: Interner> {
/// A const generic parameter.
@@ -63,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>,
diff --git a/compiler/rustc_type_ir/src/predicate_kind.rs b/compiler/rustc_type_ir/src/predicate_kind.rs
index 124d9d0eb9598..23117fdd53109 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};
@@ -13,7 +12,7 @@ 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 = ""))]
+#[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`
@@ -82,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>,
@@ -238,7 +219,7 @@ where
}
#[derive(derivative::Derivative)]
-#[derivative(Clone(bound = ""))]
+#[derivative(Clone(bound = ""), Hash(bound = ""))]
pub enum PredicateKind<I: Interner> {
/// Prove a clause
Clause(ClauseKind<I>),
@@ -329,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 8dc1cc0800584..72f86fc069299 100644
--- a/compiler/rustc_type_ir/src/region_kind.rs
+++ b/compiler/rustc_type_ir/src/region_kind.rs
@@ -2,7 +2,6 @@ use rustc_data_structures::stable_hasher::HashStable;
use rustc_data_structures::stable_hasher::StableHasher;
use rustc_serialize::{Decodable, Decoder, Encodable};
use std::fmt;
-use std::hash;
use crate::{
DebruijnIndex, DebugWithInfcx, HashStableContext, InferCtxtLike, Interner, TyDecoder,
@@ -123,7 +122,8 @@ use self::RegionKind::*;
PartialOrd(bound = ""),
PartialOrd = "feature_allow_slow_enum",
Ord(bound = ""),
- Ord = "feature_allow_slow_enum"
+ Ord = "feature_allow_slow_enum",
+ Hash(bound = "")
)]
pub enum RegionKind<I: Interner> {
/// Region bound in a type or fn declaration which will be
@@ -213,26 +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: 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 f180ceb7b0710..dceb5ba0560b1 100644
--- a/compiler/rustc_type_ir/src/ty_kind.rs
+++ b/compiler/rustc_type_ir/src/ty_kind.rs
@@ -3,8 +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::fmt;
use std::mem::discriminant;
-use std::{fmt, hash};
use crate::HashStableContext;
use crate::Interner;
@@ -119,7 +119,8 @@ pub enum AliasKind {
PartialOrd(bound = ""),
PartialOrd = "feature_allow_slow_enum",
Ord(bound = ""),
- Ord = "feature_allow_slow_enum"
+ Ord = "feature_allow_slow_enum",
+ Hash(bound = "")
)]
pub enum TyKind<I: Interner> {
/// The primitive boolean type. Written as `bool`.
@@ -383,71 +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: 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>,