nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-22 14:55:26 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #127042 - GrigorenkoPV:derivative, r=compiler-errors

Browse Source 
Switch from `derivative` to `derive-where`

This is a part of the effort to get rid of `syn 1.*` in compiler's dependencies: #109302

Derivative has not been maintained in nearly 3 years[^1]. It also depends on `syn 1.*`.

This PR replaces `derivative` with `derive-where`[^2], a not dead alternative, which uses `syn 2.*`.

A couple of `Debug` formats have changed around the skipped fields[^3], but I doubt this is an issue.

[^1]: https://github.com/mcarton/rust-derivative/issues/117
[^2]: https://lib.rs/crates/derive-where
[^3]: See the changes in `tests/ui`
This commit is contained in:
bors 2024-07-25 22:50:58 +00:00
commit 2f26b2a99a
35 changed files with 192 additions and 462 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
Cargo.lock
View File

@ -986,14 +986,14 @@ dependencies = [
] ]
[[package]] [[package]]
name = "derivative" name = "derive-where"
version = "2.2.0" version = "1.2.7"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b" checksum = "62d671cc41a825ebabc75757b62d3d168c577f9149b2d49ece1dad1f72119d25"
dependencies = [ dependencies = [
"proc-macro2", "proc-macro2",
"quote", "quote",
"syn 1.0.109", "syn 2.0.67",
] ]
[[package]] [[package]]
@ -4248,7 +4248,7 @@ name = "rustc_middle"
version = "0.0.0" version = "0.0.0"
dependencies = [ dependencies = [
"bitflags 2.5.0", "bitflags 2.5.0",
"derivative", "derive-where",
"either", "either",
"field-offset", "field-offset",
"gsgdt", "gsgdt",
@ -4378,7 +4378,7 @@ name = "rustc_next_trait_solver"
version = "0.0.0" version = "0.0.0"
dependencies = [ dependencies = [
"bitflags 2.5.0", "bitflags 2.5.0",
"derivative", "derive-where",
"rustc_ast_ir", "rustc_ast_ir",
"rustc_data_structures", "rustc_data_structures",
"rustc_index", "rustc_index",
@ -4628,7 +4628,7 @@ dependencies = [
name = "rustc_span" name = "rustc_span"
version = "0.0.0" version = "0.0.0"
dependencies = [ dependencies = [
"derivative", "derive-where",
"indexmap", "indexmap",
"itoa", "itoa",
"md-5", "md-5",
@ -4768,7 +4768,7 @@ name = "rustc_type_ir"
version = "0.0.0" version = "0.0.0"
dependencies = [ dependencies = [
"bitflags 2.5.0", "bitflags 2.5.0",
"derivative", "derive-where",
"indexmap", "indexmap",
"rustc_ast_ir", "rustc_ast_ir",
"rustc_data_structures", "rustc_data_structures",

2
compiler/rustc_middle/Cargo.toml
View File

@ -6,7 +6,7 @@ edition = "2021"
[dependencies] [dependencies]
# tidy-alphabetical-start # tidy-alphabetical-start
bitflags = "2.4.1" bitflags = "2.4.1"
derivative = "2.2.0" derive-where = "1.2.7"
either = "1.5.0" either = "1.5.0"
field-offset = "0.3.5" field-offset = "0.3.5"
gsgdt = "0.1.2" gsgdt = "0.1.2"

13
compiler/rustc_middle/src/mir/query.rs
View File

@ -2,6 +2,7 @@
use crate::mir; use crate::mir;
use crate::ty::{self, CoroutineArgsExt, OpaqueHiddenType, Ty, TyCtxt}; use crate::ty::{self, CoroutineArgsExt, OpaqueHiddenType, Ty, TyCtxt};
use derive_where::derive_where;
use rustc_data_structures::fx::FxIndexMap; use rustc_data_structures::fx::FxIndexMap;
use rustc_errors::ErrorGuaranteed; use rustc_errors::ErrorGuaranteed;
use rustc_hir::def_id::LocalDefId; use rustc_hir::def_id::LocalDefId;
@ -224,13 +225,7 @@ rustc_data_structures::static_assert_size!(ConstraintCategory<'_>, 16);
/// See also `rustc_const_eval::borrow_check::constraints`. /// See also `rustc_const_eval::borrow_check::constraints`.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)] #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
#[derive(TyEncodable, TyDecodable, HashStable, TypeVisitable, TypeFoldable)] #[derive(TyEncodable, TyDecodable, HashStable, TypeVisitable, TypeFoldable)]
#[derive(derivative::Derivative)] #[derive_where(PartialOrd, Ord)]
#[derivative(
PartialOrd,
Ord,
PartialOrd = "feature_allow_slow_enum",
Ord = "feature_allow_slow_enum"
)]
pub enum ConstraintCategory<'tcx> { pub enum ConstraintCategory<'tcx> {
Return(ReturnConstraint), Return(ReturnConstraint),
Yield, Yield,
@ -240,7 +235,7 @@ pub enum ConstraintCategory<'tcx> {
Cast { Cast {
/// Whether this is an unsizing cast and if yes, this contains the target type. /// Whether this is an unsizing cast and if yes, this contains the target type.
/// Region variables are erased to ReErased. /// Region variables are erased to ReErased.
#[derivative(PartialOrd = "ignore", Ord = "ignore")] #[derive_where(skip)]
unsize_to: Option<Ty<'tcx>>, unsize_to: Option<Ty<'tcx>>,
}, },
@ -250,7 +245,7 @@ pub enum ConstraintCategory<'tcx> {
ClosureBounds, ClosureBounds,
/// Contains the function type if available. /// Contains the function type if available.
CallArgument(#[derivative(PartialOrd = "ignore", Ord = "ignore")] Option<Ty<'tcx>>), CallArgument(#[derive_where(skip)] Option<Ty<'tcx>>),
CopyBound, CopyBound,
SizedBound, SizedBound,
Assignment, Assignment,

2
compiler/rustc_next_trait_solver/Cargo.toml
View File

@ -6,7 +6,7 @@ edition = "2021"
[dependencies] [dependencies]
# tidy-alphabetical-start # tidy-alphabetical-start
bitflags = "2.4.1" bitflags = "2.4.1"
derivative = "2.2.0" derive-where = "1.2.7"
rustc_ast_ir = { path = "../rustc_ast_ir", default-features = false } rustc_ast_ir = { path = "../rustc_ast_ir", default-features = false }
rustc_data_structures = { path = "../rustc_data_structures", optional = true } rustc_data_structures = { path = "../rustc_data_structures", optional = true }
rustc_index = { path = "../rustc_index", default-features = false } rustc_index = { path = "../rustc_index", default-features = false }

7
compiler/rustc_next_trait_solver/src/coherence.rs
View File

@ -1,6 +1,7 @@
use std::fmt::Debug; use std::fmt::Debug;
use std::ops::ControlFlow; use std::ops::ControlFlow;
use derive_where::derive_where;
use rustc_type_ir::inherent::*; use rustc_type_ir::inherent::*;
use rustc_type_ir::visit::{TypeVisitable, TypeVisitableExt, TypeVisitor}; use rustc_type_ir::visit::{TypeVisitable, TypeVisitableExt, TypeVisitor};
use rustc_type_ir::{self as ty, InferCtxtLike, Interner}; use rustc_type_ir::{self as ty, InferCtxtLike, Interner};
@ -108,15 +109,13 @@ impl From<bool> for IsFirstInputType {
} }
} }
#[derive(derivative::Derivative)] #[derive_where(Debug; I: Interner, T: Debug)]
#[derivative(Debug(bound = "T: Debug"))]
pub enum OrphanCheckErr<I: Interner, T> { pub enum OrphanCheckErr<I: Interner, T> {
NonLocalInputType(Vec<(I::Ty, IsFirstInputType)>), NonLocalInputType(Vec<(I::Ty, IsFirstInputType)>),
UncoveredTyParams(UncoveredTyParams<I, T>), UncoveredTyParams(UncoveredTyParams<I, T>),
} }
#[derive(derivative::Derivative)] #[derive_where(Debug; I: Interner, T: Debug)]
#[derivative(Debug(bound = "T: Debug"))]
pub struct UncoveredTyParams<I: Interner, T> { pub struct UncoveredTyParams<I: Interner, T> {
pub uncovered: T, pub uncovered: T,
pub local_ty: Option<I::Ty>, pub local_ty: Option<I::Ty>,

4
compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
View File

@ -2,6 +2,7 @@
pub(super) mod structural_traits; pub(super) mod structural_traits;
use derive_where::derive_where;
use rustc_type_ir::elaborate; use rustc_type_ir::elaborate;
use rustc_type_ir::fold::TypeFoldable; use rustc_type_ir::fold::TypeFoldable;
use rustc_type_ir::inherent::*; use rustc_type_ir::inherent::*;
@ -21,8 +22,7 @@ use crate::solve::{
/// ///
/// It consists of both the `source`, which describes how that goal would be proven, /// It consists of both the `source`, which describes how that goal would be proven,
/// and the `result` when using the given `source`. /// and the `result` when using the given `source`.
#[derive(derivative::Derivative)] #[derive_where(Clone, Debug; I: Interner)]
#[derivative(Debug(bound = ""), Clone(bound = ""))]
pub(super) struct Candidate<I: Interner> { pub(super) struct Candidate<I: Interner> {
pub(super) source: CandidateSource<I>, pub(super) source: CandidateSource<I>,
pub(super) result: CanonicalResponse<I>, pub(super) result: CanonicalResponse<I>,

4
compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
View File

@ -1,6 +1,7 @@
//! Code which is used by built-in goals that match "structurally", such a auto //! Code which is used by built-in goals that match "structurally", such a auto
//! traits, `Copy`/`Clone`. //! traits, `Copy`/`Clone`.
use derive_where::derive_where;
use rustc_ast_ir::{Movability, Mutability}; use rustc_ast_ir::{Movability, Mutability};
use rustc_type_ir::data_structures::HashMap; use rustc_type_ir::data_structures::HashMap;
use rustc_type_ir::fold::{TypeFoldable, TypeFolder, TypeSuperFoldable}; use rustc_type_ir::fold::{TypeFoldable, TypeFolder, TypeSuperFoldable};
@ -384,8 +385,7 @@ pub(in crate::solve) fn extract_tupled_inputs_and_output_from_callable<I: Intern
/// Relevant types for an async callable, including its inputs, output, /// Relevant types for an async callable, including its inputs, output,
/// and the return type you get from awaiting the output. /// and the return type you get from awaiting the output.
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, Debug; I: Interner)]
#[derivative(Clone(bound = ""), Copy(bound = ""), Debug(bound = ""))]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic)]
pub(in crate::solve) struct AsyncCallableRelevantTypes<I: Interner> { pub(in crate::solve) struct AsyncCallableRelevantTypes<I: Interner> {
pub tupled_inputs_ty: I::Ty, pub tupled_inputs_ty: I::Ty,

4
compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
View File

@ -1,5 +1,6 @@
use std::ops::ControlFlow; use std::ops::ControlFlow;
use derive_where::derive_where;
#[cfg(feature = "nightly")] #[cfg(feature = "nightly")]
use rustc_macros::{HashStable_NoContext, TyDecodable, TyEncodable}; use rustc_macros::{HashStable_NoContext, TyDecodable, TyEncodable};
use rustc_type_ir::data_structures::ensure_sufficient_stack; use rustc_type_ir::data_structures::ensure_sufficient_stack;
@ -87,8 +88,7 @@ where
pub(super) inspect: ProofTreeBuilder<D>, pub(super) inspect: ProofTreeBuilder<D>,
} }
#[derive(derivative::Derivative)] #[derive_where(Clone, Debug, Default; I: Interner)]
#[derivative(Clone(bound = ""), Debug(bound = ""), Default(bound = ""))]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)]
#[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))]
// FIXME: This can be made crate-private once `EvalCtxt` also lives in this crate. // FIXME: This can be made crate-private once `EvalCtxt` also lives in this crate.

22
compiler/rustc_next_trait_solver/src/solve/inspect/build.rs
View File

@ -7,6 +7,7 @@
use std::marker::PhantomData; use std::marker::PhantomData;
use std::mem; use std::mem;
use derive_where::derive_where;
use rustc_type_ir::inherent::*; use rustc_type_ir::inherent::*;
use rustc_type_ir::{self as ty, search_graph, Interner}; use rustc_type_ir::{self as ty, search_graph, Interner};
@ -51,8 +52,7 @@ where
/// in the code, only one or two variants are actually possible. /// in the code, only one or two variants are actually possible.
/// ///
/// We simply ICE in case that assumption is broken. /// We simply ICE in case that assumption is broken.
#[derive(derivative::Derivative)] #[derive_where(Debug; I: Interner)]
#[derivative(Debug(bound = ""))]
enum DebugSolver<I: Interner> { enum DebugSolver<I: Interner> {
Root, Root,
GoalEvaluation(WipGoalEvaluation<I>), GoalEvaluation(WipGoalEvaluation<I>),
@ -78,8 +78,7 @@ impl<I: Interner> From<WipCanonicalGoalEvaluationStep<I>> for DebugSolver<I> {
} }
} }
#[derive(derivative::Derivative)] #[derive_where(PartialEq, Eq, Debug; I: Interner)]
#[derivative(PartialEq(bound = ""), Eq(bound = ""), Debug(bound = ""))]
struct WipGoalEvaluation<I: Interner> { struct WipGoalEvaluation<I: Interner> {
pub uncanonicalized_goal: Goal<I, I::Predicate>, pub uncanonicalized_goal: Goal<I, I::Predicate>,
pub orig_values: Vec<I::GenericArg>, pub orig_values: Vec<I::GenericArg>,
@ -96,8 +95,7 @@ impl<I: Interner> WipGoalEvaluation<I> {
} }
} }
#[derive(derivative::Derivative)] #[derive_where(PartialEq, Eq; I: Interner)]
#[derivative(PartialEq(bound = ""), Eq(bound = ""))]
pub(in crate::solve) enum WipCanonicalGoalEvaluationKind<I: Interner> { pub(in crate::solve) enum WipCanonicalGoalEvaluationKind<I: Interner> {
Overflow, Overflow,
CycleInStack, CycleInStack,
@ -118,8 +116,7 @@ impl<I: Interner> std::fmt::Debug for WipCanonicalGoalEvaluationKind<I> {
} }
} }
#[derive(derivative::Derivative)] #[derive_where(PartialEq, Eq, Debug; I: Interner)]
#[derivative(PartialEq(bound = ""), Eq(bound = ""), Debug(bound = ""))]
struct WipCanonicalGoalEvaluation<I: Interner> { struct WipCanonicalGoalEvaluation<I: Interner> {
goal: CanonicalInput<I>, goal: CanonicalInput<I>,
kind: Option<WipCanonicalGoalEvaluationKind<I>>, kind: Option<WipCanonicalGoalEvaluationKind<I>>,
@ -153,8 +150,7 @@ impl<I: Interner> WipCanonicalGoalEvaluation<I> {
} }
} }
#[derive(derivative::Derivative)] #[derive_where(PartialEq, Eq, Debug; I: Interner)]
#[derivative(PartialEq(bound = ""), Eq(bound = ""), Debug(bound = ""))]
struct WipCanonicalGoalEvaluationStep<I: Interner> { struct WipCanonicalGoalEvaluationStep<I: Interner> {
/// Unlike `EvalCtxt::var_values`, we append a new /// Unlike `EvalCtxt::var_values`, we append a new
/// generic arg here whenever we create a new inference /// generic arg here whenever we create a new inference
@ -193,8 +189,7 @@ impl<I: Interner> WipCanonicalGoalEvaluationStep<I> {
} }
} }
#[derive(derivative::Derivative)] #[derive_where(PartialEq, Eq, Debug; I: Interner)]
#[derivative(PartialEq(bound = ""), Eq(bound = ""), Debug(bound = ""))]
struct WipProbe<I: Interner> { struct WipProbe<I: Interner> {
initial_num_var_values: usize, initial_num_var_values: usize,
steps: Vec<WipProbeStep<I>>, steps: Vec<WipProbeStep<I>>,
@ -212,8 +207,7 @@ impl<I: Interner> WipProbe<I> {
} }
} }
#[derive(derivative::Derivative)] #[derive_where(PartialEq, Eq, Debug; I: Interner)]
#[derivative(PartialEq(bound = ""), Eq(bound = ""), Debug(bound = ""))]
enum WipProbeStep<I: Interner> { enum WipProbeStep<I: Interner> {
AddGoal(GoalSource, inspect::CanonicalState<I, Goal<I, I::Predicate>>), AddGoal(GoalSource, inspect::CanonicalState<I, Goal<I, I::Predicate>>),
NestedProbe(WipProbe<I>), NestedProbe(WipProbe<I>),

2
compiler/rustc_span/Cargo.toml
View File

@ -5,7 +5,7 @@ edition = "2021"
[dependencies] [dependencies]
# tidy-alphabetical-start # tidy-alphabetical-start
derivative = "2.2.0" derive-where = "1.2.7"
indexmap = { version = "2.0.0" } indexmap = { version = "2.0.0" }
itoa = "1.0" itoa = "1.0"
md5 = { package = "md-5", version = "0.10.0" } md5 = { package = "md-5", version = "0.10.0" }

9
compiler/rustc_span/src/lib.rs
View File

@ -38,6 +38,7 @@
// this crate without this line making `rustc_span` available. // this crate without this line making `rustc_span` available.
extern crate self as rustc_span; extern crate self as rustc_span;
use derive_where::derive_where;
use rustc_data_structures::{outline, AtomicRef}; use rustc_data_structures::{outline, AtomicRef};
use rustc_macros::{Decodable, Encodable, HashStable_Generic}; use rustc_macros::{Decodable, Encodable, HashStable_Generic};
use rustc_serialize::opaque::{FileEncoder, MemDecoder}; use rustc_serialize::opaque::{FileEncoder, MemDecoder};
@ -467,18 +468,18 @@ impl FileName {
/// `SpanData` is public because `Span` uses a thread-local interner and can't be /// `SpanData` is public because `Span` uses a thread-local interner and can't be
/// sent to other threads, but some pieces of performance infra run in a separate thread. /// sent to other threads, but some pieces of performance infra run in a separate thread.
/// Using `Span` is generally preferred. /// Using `Span` is generally preferred.
#[derive(Clone, Copy, Hash, PartialEq, Eq, derivative::Derivative)] #[derive(Clone, Copy, Hash, PartialEq, Eq)]
#[derivative(PartialOrd, Ord)] #[derive_where(PartialOrd, Ord)]
pub struct SpanData { pub struct SpanData {
pub lo: BytePos, pub lo: BytePos,
pub hi: BytePos, pub hi: BytePos,
/// Information about where the macro came from, if this piece of /// Information about where the macro came from, if this piece of
/// code was created by a macro expansion. /// code was created by a macro expansion.
#[derivative(PartialOrd = "ignore", Ord = "ignore")] #[derive_where(skip)]
// `SyntaxContext` does not implement `Ord`. // `SyntaxContext` does not implement `Ord`.
// The other fields are enough to determine in-file order. // The other fields are enough to determine in-file order.
pub ctxt: SyntaxContext, pub ctxt: SyntaxContext,
#[derivative(PartialOrd = "ignore", Ord = "ignore")] #[derive_where(skip)]
// `LocalDefId` does not implement `Ord`. // `LocalDefId` does not implement `Ord`.
// The other fields are enough to determine in-file order. // The other fields are enough to determine in-file order.
pub parent: Option<LocalDefId>, pub parent: Option<LocalDefId>,

2
compiler/rustc_type_ir/Cargo.toml
View File

@ -6,7 +6,7 @@ edition = "2021"
[dependencies] [dependencies]
# tidy-alphabetical-start # tidy-alphabetical-start
bitflags = "2.4.1" bitflags = "2.4.1"
derivative = "2.2.0" derive-where = "1.2.7"
indexmap = "2.0.0" indexmap = "2.0.0"
rustc_ast_ir = { path = "../rustc_ast_ir", default-features = false } rustc_ast_ir = { path = "../rustc_ast_ir", default-features = false }
rustc_data_structures = { path = "../rustc_data_structures", optional = true } rustc_data_structures = { path = "../rustc_data_structures", optional = true }

37
compiler/rustc_type_ir/src/binder.rs
View File

@ -3,6 +3,7 @@ use std::hash::Hash;
use std::marker::PhantomData; use std::marker::PhantomData;
use std::ops::{ControlFlow, Deref}; use std::ops::{ControlFlow, Deref};
use derive_where::derive_where;
#[cfg(feature = "nightly")] #[cfg(feature = "nightly")]
use rustc_macros::{HashStable_NoContext, TyDecodable, TyEncodable}; use rustc_macros::{HashStable_NoContext, TyDecodable, TyEncodable};
#[cfg(feature = "nightly")] #[cfg(feature = "nightly")]
@ -25,15 +26,12 @@ use crate::{self as ty, Interner};
/// e.g., `liberate_late_bound_regions`). /// e.g., `liberate_late_bound_regions`).
/// ///
/// `Decodable` and `Encodable` are implemented for `Binder<T>` using the `impl_binder_encode_decode!` macro. /// `Decodable` and `Encodable` are implemented for `Binder<T>` using the `impl_binder_encode_decode!` macro.
#[derive(derivative::Derivative)] #[derive_where(Clone; I: Interner, T: Clone)]
#[derivative( #[derive_where(Copy; I: Interner, T: Copy)]
Clone(bound = "T: Clone"), #[derive_where(Hash; I: Interner, T: Hash)]
Copy(bound = "T: Copy"), #[derive_where(PartialEq; I: Interner, T: PartialEq)]
Hash(bound = "T: Hash"), #[derive_where(Eq; I: Interner, T: Eq)]
PartialEq(bound = "T: PartialEq"), #[derive_where(Debug; I: Interner, T: Debug)]
Eq(bound = "T: Eq"),
Debug(bound = "T: Debug")
)]
#[cfg_attr(feature = "nightly", derive(HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(HashStable_NoContext))]
pub struct Binder<I: Interner, T> { pub struct Binder<I: Interner, T> {
value: T, value: T,
@ -351,21 +349,18 @@ impl<I: Interner> TypeVisitor<I> for ValidateBoundVars<I> {
/// ///
/// If you don't have anything to `instantiate`, you may be looking for /// If you don't have anything to `instantiate`, you may be looking for
/// [`instantiate_identity`](EarlyBinder::instantiate_identity) or [`skip_binder`](EarlyBinder::skip_binder). /// [`instantiate_identity`](EarlyBinder::instantiate_identity) or [`skip_binder`](EarlyBinder::skip_binder).
#[derive(derivative::Derivative)] #[derive_where(Clone; I: Interner, T: Clone)]
#[derivative( #[derive_where(Copy; I: Interner, T: Copy)]
Clone(bound = "T: Clone"), #[derive_where(PartialEq; I: Interner, T: PartialEq)]
Copy(bound = "T: Copy"), #[derive_where(Eq; I: Interner, T: Eq)]
PartialEq(bound = "T: PartialEq"), #[derive_where(Ord; I: Interner, T: Ord)]
Eq(bound = "T: Eq"), #[derive_where(PartialOrd; I: Interner, T: Ord)]
Ord(bound = "T: Ord"), #[derive_where(Hash; I: Interner, T: Hash)]
PartialOrd(bound = "T: Ord"), #[derive_where(Debug; I: Interner, T: Debug)]
Hash(bound = "T: Hash"),
Debug(bound = "T: Debug")
)]
#[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))]
pub struct EarlyBinder<I: Interner, T> { pub struct EarlyBinder<I: Interner, T> {
value: T, value: T,
#[derivative(Debug = "ignore")] #[derive_where(skip(Debug))]
_tcx: PhantomData<I>, _tcx: PhantomData<I>,
} }

42
compiler/rustc_type_ir/src/canonical.rs
View File

@ -1,3 +1,6 @@
#![allow(clippy::derived_hash_with_manual_eq)]
use derive_where::derive_where;
#[cfg(feature = "nightly")] #[cfg(feature = "nightly")]
use rustc_macros::{HashStable_NoContext, TyDecodable, TyEncodable}; use rustc_macros::{HashStable_NoContext, TyDecodable, TyEncodable};
use rustc_type_ir_macros::{Lift_Generic, TypeFoldable_Generic, TypeVisitable_Generic}; use rustc_type_ir_macros::{Lift_Generic, TypeFoldable_Generic, TypeVisitable_Generic};
@ -11,15 +14,12 @@ use crate::{self as ty, Interner, UniverseIndex};
/// A "canonicalized" type `V` is one where all free inference /// A "canonicalized" type `V` is one where all free inference
/// variables have been rewritten to "canonical vars". These are /// variables have been rewritten to "canonical vars". These are
/// numbered starting from 0 in order of first appearance. /// numbered starting from 0 in order of first appearance.
#[derive(derivative::Derivative)] #[derive_where(Clone; I: Interner, V: Clone)]
#[derivative( #[derive_where(Hash; I: Interner, V: Hash)]
Clone(bound = "V: Clone"), #[derive_where(PartialEq; I: Interner, V: PartialEq)]
Hash(bound = "V: Hash"), #[derive_where(Eq; I: Interner, V: Eq)]
PartialEq(bound = "V: PartialEq"), #[derive_where(Debug; I: Interner, V: fmt::Debug)]
Eq(bound = "V: Eq"), #[derive_where(Copy; I: Interner, V: Copy)]
Debug(bound = "V: fmt::Debug"),
Copy(bound = "V: Copy")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic)]
#[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))]
pub struct Canonical<I: Interner, V> { pub struct Canonical<I: Interner, V> {
@ -84,15 +84,7 @@ impl<I: Interner, V: fmt::Display> fmt::Display for Canonical<I, V> {
/// canonical value. This is sufficient information for code to create /// canonical value. This is sufficient information for code to create
/// a copy of the canonical value in some other inference context, /// a copy of the canonical value in some other inference context,
/// with fresh inference variables replacing the canonical values. /// with fresh inference variables replacing the canonical values.
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, Hash, PartialEq, Eq, Debug; I: Interner)]
#[derivative(
Clone(bound = ""),
Copy(bound = ""),
Hash(bound = ""),
Debug(bound = ""),
Eq(bound = ""),
PartialEq(bound = "")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic)]
#[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))]
pub struct CanonicalVarInfo<I: Interner> { pub struct CanonicalVarInfo<I: Interner> {
@ -149,8 +141,7 @@ impl<I: Interner> CanonicalVarInfo<I> {
/// Describes the "kind" of the canonical variable. This is a "kind" /// Describes the "kind" of the canonical variable. This is a "kind"
/// in the type-theory sense of the term -- i.e., a "meta" type system /// in the type-theory sense of the term -- i.e., a "meta" type system
/// that analyzes type-like values. /// that analyzes type-like values.
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, Hash, Eq, Debug; I: Interner)]
#[derivative(Clone(bound = ""), Copy(bound = ""), Hash(bound = ""), Debug(bound = ""))]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic)]
#[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))]
pub enum CanonicalVarKind<I: Interner> { pub enum CanonicalVarKind<I: Interner> {
@ -178,6 +169,7 @@ pub enum CanonicalVarKind<I: Interner> {
PlaceholderConst(I::PlaceholderConst), PlaceholderConst(I::PlaceholderConst),
} }
// FIXME(GrigorenkoPV): consider not implementing PartialEq manually
impl<I: Interner> PartialEq for CanonicalVarKind<I> { impl<I: Interner> PartialEq for CanonicalVarKind<I> {
fn eq(&self, other: &Self) -> bool { fn eq(&self, other: &Self) -> bool {
match (self, other) { match (self, other) {
@ -266,15 +258,7 @@ pub enum CanonicalTyVarKind {
/// vectors with the original values that were replaced by canonical /// vectors with the original values that were replaced by canonical
/// variables. You will need to supply it later to instantiate the /// variables. You will need to supply it later to instantiate the
/// canonicalized query response. /// canonicalized query response.
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, Hash, PartialEq, Eq, Debug; I: Interner)]
#[derivative(
Clone(bound = ""),
Copy(bound = ""),
PartialEq(bound = ""),
Eq(bound = ""),
Hash(bound = ""),
Debug(bound = "")
)]
#[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)]
pub struct CanonicalVarValues<I: Interner> { pub struct CanonicalVarValues<I: Interner> {

16
compiler/rustc_type_ir/src/const_kind.rs
View File

@ -1,3 +1,6 @@
#![allow(clippy::derived_hash_with_manual_eq)]
use derive_where::derive_where;
#[cfg(feature = "nightly")] #[cfg(feature = "nightly")]
use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
#[cfg(feature = "nightly")] #[cfg(feature = "nightly")]
@ -10,8 +13,7 @@ use crate::{self as ty, DebruijnIndex, Interner};
use self::ConstKind::*; use self::ConstKind::*;
/// Represents a constant in Rust. /// Represents a constant in Rust.
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, Hash, Eq; I: Interner)]
#[derivative(Clone(bound = ""), Copy(bound = ""), Hash(bound = ""), Eq(bound = ""))]
#[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))]
pub enum ConstKind<I: Interner> { pub enum ConstKind<I: Interner> {
/// A const generic parameter. /// A const generic parameter.
@ -43,6 +45,7 @@ pub enum ConstKind<I: Interner> {
Expr(I::ExprConst), Expr(I::ExprConst),
} }
// FIXME(GrigorenkoPV): consider not implementing PartialEq manually
impl<I: Interner> PartialEq for ConstKind<I> { impl<I: Interner> PartialEq for ConstKind<I> {
fn eq(&self, other: &Self) -> bool { fn eq(&self, other: &Self) -> bool {
match (self, other) { match (self, other) {
@ -77,14 +80,7 @@ impl<I: Interner> fmt::Debug for ConstKind<I> {
} }
/// An unevaluated (potentially generic) constant used in the type-system. /// An unevaluated (potentially generic) constant used in the type-system.
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, Hash, PartialEq, Eq; I: Interner)]
#[derivative(
Clone(bound = ""),
Copy(bound = ""),
Hash(bound = ""),
PartialEq(bound = ""),
Eq(bound = "")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)]
#[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))]
pub struct UnevaluatedConst<I: Interner> { pub struct UnevaluatedConst<I: Interner> {

10
compiler/rustc_type_ir/src/error.rs
View File

@ -1,3 +1,4 @@
use derive_where::derive_where;
use rustc_type_ir_macros::{TypeFoldable_Generic, TypeVisitable_Generic}; use rustc_type_ir_macros::{TypeFoldable_Generic, TypeVisitable_Generic};
use crate::solve::NoSolution; use crate::solve::NoSolution;
@ -21,14 +22,7 @@ impl<T> ExpectedFound<T> {
} }
// Data structures used in type unification // Data structures used in type unification
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, PartialEq, Eq, Debug; I: Interner)]
#[derivative(
Clone(bound = ""),
Copy(bound = ""),
PartialEq(bound = ""),
Eq(bound = ""),
Debug(bound = "")
)]
#[derive(TypeVisitable_Generic)] #[derive(TypeVisitable_Generic)]
#[cfg_attr(feature = "nightly", rustc_pass_by_value)] #[cfg_attr(feature = "nightly", rustc_pass_by_value)]
pub enum TypeError<I: Interner> { pub enum TypeError<I: Interner> {

19
compiler/rustc_type_ir/src/generic_arg.rs
View File

@ -1,16 +1,10 @@
use derive_where::derive_where;
#[cfg(feature = "nightly")] #[cfg(feature = "nightly")]
use rustc_macros::{HashStable_NoContext, TyDecodable, TyEncodable}; use rustc_macros::{HashStable_NoContext, TyDecodable, TyEncodable};
use crate::Interner; use crate::Interner;
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, PartialEq, Eq, Debug; I: Interner)]
#[derivative(
Clone(bound = ""),
Copy(bound = ""),
Debug(bound = ""),
Eq(bound = ""),
PartialEq(bound = "")
)]
#[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))]
pub enum GenericArgKind<I: Interner> { pub enum GenericArgKind<I: Interner> {
Lifetime(I::Region), Lifetime(I::Region),
@ -18,14 +12,7 @@ pub enum GenericArgKind<I: Interner> {
Const(I::Const), Const(I::Const),
} }
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, PartialEq, Eq, Debug; I: Interner)]
#[derivative(
Clone(bound = ""),
Copy(bound = ""),
Debug(bound = ""),
Eq(bound = ""),
PartialEq(bound = "")
)]
#[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))]
pub enum TermKind<I: Interner> { pub enum TermKind<I: Interner> {
Ty(I::Ty), Ty(I::Ty),

11
compiler/rustc_type_ir/src/opaque_ty.rs
View File

@ -1,3 +1,4 @@
use derive_where::derive_where;
#[cfg(feature = "nightly")] #[cfg(feature = "nightly")]
use rustc_macros::{HashStable_NoContext, TyDecodable, TyEncodable}; use rustc_macros::{HashStable_NoContext, TyDecodable, TyEncodable};
use rustc_type_ir_macros::{TypeFoldable_Generic, TypeVisitable_Generic}; use rustc_type_ir_macros::{TypeFoldable_Generic, TypeVisitable_Generic};
@ -5,15 +6,7 @@ use rustc_type_ir_macros::{TypeFoldable_Generic, TypeVisitable_Generic};
use crate::inherent::*; use crate::inherent::*;
use crate::{self as ty, Interner}; use crate::{self as ty, Interner};
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, Hash, PartialEq, Eq, Debug; I: Interner)]
#[derivative(
Clone(bound = ""),
Hash(bound = ""),
PartialEq(bound = ""),
Eq(bound = ""),
Debug(bound = ""),
Copy(bound = "")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic)]
#[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))]
pub struct OpaqueTypeKey<I: Interner> { pub struct OpaqueTypeKey<I: Interner> {

4
compiler/rustc_type_ir/src/outlives.rs
View File

@ -2,6 +2,7 @@
//! refers to rules defined in RFC 1214 (`OutlivesFooBar`), so see that //! refers to rules defined in RFC 1214 (`OutlivesFooBar`), so see that
//! RFC for reference. //! RFC for reference.
use derive_where::derive_where;
use smallvec::{smallvec, SmallVec}; use smallvec::{smallvec, SmallVec};
use crate::data_structures::SsoHashSet; use crate::data_structures::SsoHashSet;
@ -9,8 +10,7 @@ use crate::inherent::*;
use crate::visit::{TypeSuperVisitable, TypeVisitable, TypeVisitableExt as _, TypeVisitor}; use crate::visit::{TypeSuperVisitable, TypeVisitable, TypeVisitableExt as _, TypeVisitor};
use crate::{self as ty, Interner}; use crate::{self as ty, Interner};
#[derive(derivative::Derivative)] #[derive_where(Debug; I: Interner)]
#[derivative(Debug(bound = ""))]
pub enum Component<I: Interner> { pub enum Component<I: Interner> {
Region(I::Region), Region(I::Region),
Param(I::ParamTy), Param(I::ParamTy),

112
compiler/rustc_type_ir/src/predicate.rs
View File

@ -1,6 +1,7 @@
use std::fmt; use std::fmt;
use std::hash::Hash; use std::hash::Hash;
use derive_where::derive_where;
#[cfg(feature = "nightly")] #[cfg(feature = "nightly")]
use rustc_macros::{Decodable, Encodable, HashStable_NoContext, TyDecodable, TyEncodable}; use rustc_macros::{Decodable, Encodable, HashStable_NoContext, TyDecodable, TyEncodable};
use rustc_type_ir_macros::{Lift_Generic, TypeFoldable_Generic, TypeVisitable_Generic}; use rustc_type_ir_macros::{Lift_Generic, TypeFoldable_Generic, TypeVisitable_Generic};
@ -12,15 +13,12 @@ use crate::visit::TypeVisitableExt as _;
use crate::{self as ty, Interner}; use crate::{self as ty, Interner};
/// `A: 'region` /// `A: 'region`
#[derive(derivative::Derivative)] #[derive_where(Clone; I: Interner, A: Clone)]
#[derivative( #[derive_where(Copy; I: Interner, A: Copy)]
Clone(bound = "A: Clone"), #[derive_where(Hash; I: Interner, A: Hash)]
Copy(bound = "A: Copy"), #[derive_where(PartialEq; I: Interner, A: PartialEq)]
Hash(bound = "A: Hash"), #[derive_where(Eq; I: Interner, A: Eq)]
PartialEq(bound = "A: PartialEq"), #[derive_where(Debug; I: Interner, A: fmt::Debug)]
Eq(bound = "A: Eq"),
Debug(bound = "A: fmt::Debug")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic)]
#[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))]
pub struct OutlivesPredicate<I: Interner, A>(pub A, pub I::Region); pub struct OutlivesPredicate<I: Interner, A>(pub A, pub I::Region);
@ -50,14 +48,7 @@ where
/// ///
/// Trait references also appear in object types like `Foo<U>`, but in /// Trait references also appear in object types like `Foo<U>`, but in
/// that case the `Self` parameter is absent from the generic parameters. /// that case the `Self` parameter is absent from the generic parameters.
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, Hash, PartialEq, Eq; I: Interner)]
#[derivative(
Clone(bound = ""),
Copy(bound = ""),
Hash(bound = ""),
PartialEq(bound = ""),
Eq(bound = "")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)]
#[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))]
pub struct TraitRef<I: Interner> { pub struct TraitRef<I: Interner> {
@ -122,14 +113,7 @@ impl<I: Interner> ty::Binder<I, TraitRef<I>> {
} }
} }
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, Hash, PartialEq, Eq; I: Interner)]
#[derivative(
Clone(bound = ""),
Copy(bound = ""),
Hash(bound = ""),
PartialEq(bound = ""),
Eq(bound = "")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)]
#[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))]
pub struct TraitPredicate<I: Interner> { pub struct TraitPredicate<I: Interner> {
@ -243,15 +227,7 @@ impl fmt::Display for PredicatePolarity {
} }
} }
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, Hash, PartialEq, Eq, Debug; I: Interner)]
#[derivative(
Clone(bound = ""),
Copy(bound = ""),
Hash(bound = ""),
PartialEq(bound = ""),
Eq(bound = ""),
Debug(bound = "")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)]
#[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))]
pub enum ExistentialPredicate<I: Interner> { pub enum ExistentialPredicate<I: Interner> {
@ -296,14 +272,7 @@ impl<I: Interner> ty::Binder<I, ExistentialPredicate<I>> {
/// ``` /// ```
/// The generic parameters don't include the erased `Self`, only trait /// The generic parameters don't include the erased `Self`, only trait
/// type and lifetime parameters (`[X, Y]` and `['a, 'b]` above). /// type and lifetime parameters (`[X, Y]` and `['a, 'b]` above).
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, Hash, PartialEq, Eq; I: Interner)]
#[derivative(
Clone(bound = ""),
Copy(bound = ""),
Hash(bound = ""),
PartialEq(bound = ""),
Eq(bound = "")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)]
#[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))]
pub struct ExistentialTraitRef<I: Interner> { pub struct ExistentialTraitRef<I: Interner> {
@ -349,14 +318,7 @@ impl<I: Interner> ty::Binder<I, ExistentialTraitRef<I>> {
} }
/// A `ProjectionPredicate` for an `ExistentialTraitRef`. /// A `ProjectionPredicate` for an `ExistentialTraitRef`.
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, Hash, PartialEq, Eq; I: Interner)]
#[derivative(
Clone(bound = ""),
Copy(bound = ""),
Hash(bound = ""),
PartialEq(bound = ""),
Eq(bound = "")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)]
#[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))]
pub struct ExistentialProjection<I: Interner> { pub struct ExistentialProjection<I: Interner> {
@ -452,15 +414,7 @@ impl AliasTermKind {
/// * For a projection, this would be `<Ty as Trait<...>>::N<...>`. /// * For a projection, this would be `<Ty as Trait<...>>::N<...>`.
/// * For an inherent projection, this would be `Ty::N<...>`. /// * For an inherent projection, this would be `Ty::N<...>`.
/// * For an opaque type, there is no explicit syntax. /// * For an opaque type, there is no explicit syntax.
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, Hash, PartialEq, Eq, Debug; I: Interner)]
#[derivative(
Clone(bound = ""),
Copy(bound = ""),
Hash(bound = ""),
PartialEq(bound = ""),
Eq(bound = ""),
Debug(bound = "")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)]
#[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))]
pub struct AliasTerm<I: Interner> { pub struct AliasTerm<I: Interner> {
@ -489,7 +443,7 @@ pub struct AliasTerm<I: Interner> {
pub def_id: I::DefId, pub def_id: I::DefId,
/// This field exists to prevent the creation of `AliasTerm` without using [`AliasTerm::new_from_args`]. /// This field exists to prevent the creation of `AliasTerm` without using [`AliasTerm::new_from_args`].
#[derivative(Debug = "ignore")] #[derive_where(skip(Debug))]
_use_alias_term_new_instead: (), _use_alias_term_new_instead: (),
} }
@ -631,14 +585,7 @@ impl<I: Interner> From<ty::UnevaluatedConst<I>> for AliasTerm<I> {
/// equality between arbitrary types. Processing an instance of /// equality between arbitrary types. Processing an instance of
/// Form #2 eventually yields one of these `ProjectionPredicate` /// Form #2 eventually yields one of these `ProjectionPredicate`
/// instances to normalize the LHS. /// instances to normalize the LHS.
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, Hash, PartialEq, Eq; I: Interner)]
#[derivative(
Clone(bound = ""),
Copy(bound = ""),
Hash(bound = ""),
PartialEq(bound = ""),
Eq(bound = "")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)]
#[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))]
pub struct ProjectionPredicate<I: Interner> { pub struct ProjectionPredicate<I: Interner> {
@ -706,14 +653,7 @@ impl<I: Interner> fmt::Debug for ProjectionPredicate<I> {
/// Used by the new solver. Unlike a `ProjectionPredicate` this can only be /// Used by the new solver. Unlike a `ProjectionPredicate` this can only be
/// proven by actually normalizing `alias`. /// proven by actually normalizing `alias`.
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, Hash, PartialEq, Eq; I: Interner)]
#[derivative(
Clone(bound = ""),
Copy(bound = ""),
Hash(bound = ""),
PartialEq(bound = ""),
Eq(bound = "")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)]
#[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))]
pub struct NormalizesTo<I: Interner> { pub struct NormalizesTo<I: Interner> {
@ -748,15 +688,7 @@ impl<I: Interner> fmt::Debug for NormalizesTo<I> {
/// Encodes that `a` must be a subtype of `b`. The `a_is_expected` flag indicates /// Encodes that `a` must be a subtype of `b`. The `a_is_expected` flag indicates
/// whether the `a` type is the type that we should label as "expected" when /// whether the `a` type is the type that we should label as "expected" when
/// presenting user diagnostics. /// presenting user diagnostics.
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, Hash, PartialEq, Eq, Debug; I: Interner)]
#[derivative(
Clone(bound = ""),
Copy(bound = ""),
Hash(bound = ""),
PartialEq(bound = ""),
Eq(bound = ""),
Debug(bound = "")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)]
#[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))]
pub struct SubtypePredicate<I: Interner> { pub struct SubtypePredicate<I: Interner> {
@ -766,15 +698,7 @@ pub struct SubtypePredicate<I: Interner> {
} }
/// Encodes that we have to coerce *from* the `a` type to the `b` type. /// Encodes that we have to coerce *from* the `a` type to the `b` type.
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, Hash, PartialEq, Eq, Debug; I: Interner)]
#[derivative(
Clone(bound = ""),
Copy(bound = ""),
Hash(bound = ""),
PartialEq(bound = ""),
Eq(bound = ""),
Debug(bound = "")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)]
#[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))]
pub struct CoercePredicate<I: Interner> { pub struct CoercePredicate<I: Interner> {

16
compiler/rustc_type_ir/src/predicate_kind.rs
View File

@ -1,3 +1,6 @@
#![allow(clippy::derived_hash_with_manual_eq)]
use derive_where::derive_where;
#[cfg(feature = "nightly")] #[cfg(feature = "nightly")]
use rustc_macros::{Decodable, Encodable, HashStable_NoContext, TyDecodable, TyEncodable}; use rustc_macros::{Decodable, Encodable, HashStable_NoContext, TyDecodable, TyEncodable};
use rustc_type_ir_macros::{TypeFoldable_Generic, TypeVisitable_Generic}; use rustc_type_ir_macros::{TypeFoldable_Generic, TypeVisitable_Generic};
@ -7,8 +10,7 @@ use crate::{self as ty, Interner};
/// A clause is something that can appear in where bounds or be inferred /// A clause is something that can appear in where bounds or be inferred
/// by implied bounds. /// by implied bounds.
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, Hash, Eq; I: Interner)]
#[derivative(Clone(bound = ""), Copy(bound = ""), Hash(bound = ""), Eq(bound = ""))]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic)]
#[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))]
pub enum ClauseKind<I: Interner> { pub enum ClauseKind<I: Interner> {
@ -38,6 +40,7 @@ pub enum ClauseKind<I: Interner> {
ConstEvaluatable(I::Const), ConstEvaluatable(I::Const),
} }
// FIXME(GrigorenkoPV): consider not implementing PartialEq manually
impl<I: Interner> PartialEq for ClauseKind<I> { impl<I: Interner> PartialEq for ClauseKind<I> {
fn eq(&self, other: &Self) -> bool { fn eq(&self, other: &Self) -> bool {
match (self, other) { match (self, other) {
@ -53,14 +56,7 @@ impl<I: Interner> PartialEq for ClauseKind<I> {
} }
} }
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, Hash, PartialEq, Eq; I: Interner)]
#[derivative(
Clone(bound = ""),
Copy(bound = ""),
Hash(bound = ""),
PartialEq(bound = ""),
Eq(bound = "")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic)]
#[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))]
pub enum PredicateKind<I: Interner> { pub enum PredicateKind<I: Interner> {

7
compiler/rustc_type_ir/src/region_kind.rs
View File

@ -1,3 +1,6 @@
#![allow(clippy::derived_hash_with_manual_eq)]
use derive_where::derive_where;
#[cfg(feature = "nightly")] #[cfg(feature = "nightly")]
use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
#[cfg(feature = "nightly")] #[cfg(feature = "nightly")]
@ -124,8 +127,7 @@ rustc_index::newtype_index! {
/// [1]: https://smallcultfollowing.com/babysteps/blog/2013/10/29/intermingled-parameter-lists/ /// [1]: https://smallcultfollowing.com/babysteps/blog/2013/10/29/intermingled-parameter-lists/
/// [2]: https://smallcultfollowing.com/babysteps/blog/2013/11/04/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 /// [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/traits/hrtb.html
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, Hash, Eq; I: Interner)]
#[derivative(Clone(bound = ""), Copy(bound = ""), Hash(bound = ""), Eq(bound = ""))]
#[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable))] #[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable))]
pub enum RegionKind<I: Interner> { pub enum RegionKind<I: Interner> {
/// A region parameter; for example `'a` in `impl<'a> Trait for &'a ()`. /// A region parameter; for example `'a` in `impl<'a> Trait for &'a ()`.
@ -193,6 +195,7 @@ const fn regionkind_discriminant<I: Interner>(value: &RegionKind<I>) -> usize {
} }
} }
// FIXME(GrigorenkoPV): consider not implementing PartialEq manually
// This is manually implemented because a derive would require `I: PartialEq` // This is manually implemented because a derive would require `I: PartialEq`
impl<I: Interner> PartialEq for RegionKind<I> { impl<I: Interner> PartialEq for RegionKind<I> {
#[inline] #[inline]

13
compiler/rustc_type_ir/src/relate.rs
View File

@ -1,5 +1,6 @@
use std::iter; use std::iter;
use derive_where::derive_where;
use rustc_ast_ir::Mutability; use rustc_ast_ir::Mutability;
use tracing::{instrument, trace}; use tracing::{instrument, trace};
@ -17,19 +18,11 @@ pub type RelateResult<I, T> = Result<T, TypeError<I>>;
/// a miscompilation or unsoundness. /// a miscompilation or unsoundness.
/// ///
/// When in doubt, use `VarianceDiagInfo::default()` /// When in doubt, use `VarianceDiagInfo::default()`
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, PartialEq, Eq, Debug, Default; I: Interner)]
#[derivative(
Copy(bound = ""),
Clone(bound = ""),
Debug(bound = ""),
Default(bound = ""),
PartialEq(bound = ""),
Eq(bound = "")
)]
pub enum VarianceDiagInfo<I: Interner> { pub enum VarianceDiagInfo<I: Interner> {
/// No additional information - this is the default. /// No additional information - this is the default.
/// We will not add any additional information to error messages. /// We will not add any additional information to error messages.
#[derivative(Default)] #[derive_where(default)]
None, None,
/// We switched our variance because a generic argument occurs inside /// We switched our variance because a generic argument occurs inside
/// the invariant generic argument of another type. /// the invariant generic argument of another type.

15
compiler/rustc_type_ir/src/search_graph/global_cache.rs
View File

@ -1,10 +1,10 @@
use derive_where::derive_where;
use rustc_index::IndexVec; use rustc_index::IndexVec;
use super::{AvailableDepth, Cx, StackDepth, StackEntry}; use super::{AvailableDepth, Cx, StackDepth, StackEntry};
use crate::data_structures::{HashMap, HashSet}; use crate::data_structures::{HashMap, HashSet};
#[derive(derivative::Derivative)] #[derive_where(Debug, Clone, Copy; X: Cx)]
#[derivative(Debug(bound = ""), Clone(bound = ""), Copy(bound = ""))]
struct QueryData<X: Cx> { struct QueryData<X: Cx> {
result: X::Result, result: X::Result,
proof_tree: X::ProofTree, proof_tree: X::ProofTree,
@ -20,8 +20,7 @@ struct Success<X: Cx> {
/// This contains results whose computation never hit the /// This contains results whose computation never hit the
/// recursion limit in `success`, and all results which hit /// recursion limit in `success`, and all results which hit
/// the recursion limit in `with_overflow`. /// the recursion limit in `with_overflow`.
#[derive(derivative::Derivative)] #[derive_where(Default; X: Cx)]
#[derivative(Default(bound = ""))]
struct CacheEntry<X: Cx> { struct CacheEntry<X: Cx> {
success: Option<Success<X>>, success: Option<Success<X>>,
/// We have to be careful when caching roots of cycles. /// We have to be careful when caching roots of cycles.
@ -32,8 +31,7 @@ struct CacheEntry<X: Cx> {
with_overflow: HashMap<usize, X::Tracked<QueryData<X>>>, with_overflow: HashMap<usize, X::Tracked<QueryData<X>>>,
} }
#[derive(derivative::Derivative)] #[derive_where(Debug; X: Cx)]
#[derivative(Debug(bound = ""))]
pub(super) struct CacheData<'a, X: Cx> { pub(super) struct CacheData<'a, X: Cx> {
pub(super) result: X::Result, pub(super) result: X::Result,
pub(super) proof_tree: X::ProofTree, pub(super) proof_tree: X::ProofTree,
@ -41,11 +39,10 @@ pub(super) struct CacheData<'a, X: Cx> {
pub(super) encountered_overflow: bool, pub(super) encountered_overflow: bool,
// FIXME: This is currently unused, but impacts the design // FIXME: This is currently unused, but impacts the design
// by requiring a closure for `Cx::with_global_cache`. // by requiring a closure for `Cx::with_global_cache`.
#[allow(dead_code)]
pub(super) nested_goals: &'a HashSet<X::Input>, pub(super) nested_goals: &'a HashSet<X::Input>,
} }
#[derive_where(Default; X: Cx)]
#[derive(derivative::Derivative)]
#[derivative(Default(bound = ""))]
pub struct GlobalCache<X: Cx> { pub struct GlobalCache<X: Cx> {
map: HashMap<X::Input, CacheEntry<X>>, map: HashMap<X::Input, CacheEntry<X>>,
} }

7
compiler/rustc_type_ir/src/search_graph/mod.rs
View File

@ -3,6 +3,7 @@ use std::hash::Hash;
use std::marker::PhantomData; use std::marker::PhantomData;
use std::mem; use std::mem;
use derive_where::derive_where;
use rustc_index::{Idx, IndexVec}; use rustc_index::{Idx, IndexVec};
use tracing::debug; use tracing::debug;
@ -153,8 +154,7 @@ rustc_index::newtype_index! {
pub struct StackDepth {} pub struct StackDepth {}
} }
#[derive(derivative::Derivative)] #[derive_where(Debug; X: Cx)]
#[derivative(Debug(bound = ""))]
struct StackEntry<X: Cx> { struct StackEntry<X: Cx> {
input: X::Input, input: X::Input,
@ -226,8 +226,7 @@ struct DetachedEntry<X: Cx> {
/// ///
/// The provisional cache can theoretically result in changes to the observable behavior, /// The provisional cache can theoretically result in changes to the observable behavior,
/// see tests/ui/traits/next-solver/cycles/provisional-cache-impacts-behavior.rs. /// see tests/ui/traits/next-solver/cycles/provisional-cache-impacts-behavior.rs.
#[derive(derivative::Derivative)] #[derive_where(Default; X: Cx)]
#[derivative(Default(bound = ""))]
struct ProvisionalCacheEntry<X: Cx> { struct ProvisionalCacheEntry<X: Cx> {
stack_depth: Option<StackDepth>, stack_depth: Option<StackDepth>,
with_inductive_stack: Option<DetachedEntry<X>>, with_inductive_stack: Option<DetachedEntry<X>>,

44
compiler/rustc_type_ir/src/solve/inspect.rs
View File

@ -21,6 +21,7 @@ use crate::solve::{
CandidateSource, CanonicalInput, Certainty, Goal, GoalSource, QueryInput, QueryResult, CandidateSource, CanonicalInput, Certainty, Goal, GoalSource, QueryInput, QueryResult,
}; };
use crate::{Canonical, CanonicalVarValues, Interner}; use crate::{Canonical, CanonicalVarValues, Interner};
use derive_where::derive_where;
use rustc_type_ir_macros::{TypeFoldable_Generic, TypeVisitable_Generic}; use rustc_type_ir_macros::{TypeFoldable_Generic, TypeVisitable_Generic};
use std::fmt::Debug; use std::fmt::Debug;
use std::hash::Hash; use std::hash::Hash;
@ -31,15 +32,12 @@ use std::hash::Hash;
/// This is only ever used as [CanonicalState]. Any type information in proof /// This is only ever used as [CanonicalState]. Any type information in proof
/// trees used mechanically has to be canonicalized as we otherwise leak /// trees used mechanically has to be canonicalized as we otherwise leak
/// inference variables from a nested `InferCtxt`. /// inference variables from a nested `InferCtxt`.
#[derive(derivative::Derivative)] #[derive_where(Clone; I: Interner, T: Clone)]
#[derivative( #[derive_where(Copy; I: Interner, T: Copy)]
Clone(bound = "T: Clone"), #[derive_where(PartialEq; I: Interner, T: PartialEq)]
Copy(bound = "T: Copy"), #[derive_where(Eq; I: Interner, T: Eq)]
PartialEq(bound = "T: PartialEq"), #[derive_where(Hash; I: Interner, T: Hash)]
Eq(bound = "T: Eq"), #[derive_where(Debug; I: Interner, T: Debug)]
Hash(bound = "T: Hash"),
Debug(bound = "T: Debug")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic)]
pub struct State<I: Interner, T> { pub struct State<I: Interner, T> {
pub var_values: CanonicalVarValues<I>, pub var_values: CanonicalVarValues<I>,
@ -52,24 +50,21 @@ pub type CanonicalState<I, T> = Canonical<I, State<I, T>>;
/// for the `CanonicalVarValues` of the canonicalized goal. /// for the `CanonicalVarValues` of the canonicalized goal.
/// We use this to map any [CanonicalState] from the local `InferCtxt` /// We use this to map any [CanonicalState] from the local `InferCtxt`
/// of the solver query to the `InferCtxt` of the caller. /// of the solver query to the `InferCtxt` of the caller.
#[derive(derivative::Derivative)] #[derive_where(PartialEq, Eq, Hash; I: Interner)]
#[derivative(PartialEq(bound = ""), Eq(bound = ""), Hash(bound = ""))]
pub struct GoalEvaluation<I: Interner> { pub struct GoalEvaluation<I: Interner> {
pub uncanonicalized_goal: Goal<I, I::Predicate>, pub uncanonicalized_goal: Goal<I, I::Predicate>,
pub orig_values: Vec<I::GenericArg>, pub orig_values: Vec<I::GenericArg>,
pub evaluation: CanonicalGoalEvaluation<I>, pub evaluation: CanonicalGoalEvaluation<I>,
} }
#[derive(derivative::Derivative)] #[derive_where(PartialEq, Eq, Hash, Debug; I: Interner)]
#[derivative(PartialEq(bound = ""), Eq(bound = ""), Hash(bound = ""), Debug(bound = ""))]
pub struct CanonicalGoalEvaluation<I: Interner> { pub struct CanonicalGoalEvaluation<I: Interner> {
pub goal: CanonicalInput<I>, pub goal: CanonicalInput<I>,
pub kind: CanonicalGoalEvaluationKind<I>, pub kind: CanonicalGoalEvaluationKind<I>,
pub result: QueryResult<I>, pub result: QueryResult<I>,
} }
#[derive(derivative::Derivative)] #[derive_where(PartialEq, Eq, Hash, Debug; I: Interner)]
#[derivative(PartialEq(bound = ""), Eq(bound = ""), Hash(bound = ""), Debug(bound = ""))]
pub enum CanonicalGoalEvaluationKind<I: Interner> { pub enum CanonicalGoalEvaluationKind<I: Interner> {
Overflow, Overflow,
CycleInStack, CycleInStack,
@ -77,8 +72,7 @@ pub enum CanonicalGoalEvaluationKind<I: Interner> {
Evaluation { final_revision: I::CanonicalGoalEvaluationStepRef }, Evaluation { final_revision: I::CanonicalGoalEvaluationStepRef },
} }
#[derive(derivative::Derivative)] #[derive_where(PartialEq, Eq, Hash, Debug; I: Interner)]
#[derivative(PartialEq(bound = ""), Eq(bound = ""), Hash(bound = ""), Debug(bound = ""))]
pub struct CanonicalGoalEvaluationStep<I: Interner> { pub struct CanonicalGoalEvaluationStep<I: Interner> {
pub instantiated_goal: QueryInput<I, I::Predicate>, pub instantiated_goal: QueryInput<I, I::Predicate>,
@ -89,8 +83,7 @@ pub struct CanonicalGoalEvaluationStep<I: Interner> {
/// A self-contained computation during trait solving. This either /// A self-contained computation during trait solving. This either
/// corresponds to a `EvalCtxt::probe(_X)` call or the root evaluation /// corresponds to a `EvalCtxt::probe(_X)` call or the root evaluation
/// of a goal. /// of a goal.
#[derive(derivative::Derivative)] #[derive_where(PartialEq, Eq, Hash, Debug; I: Interner)]
#[derivative(Debug(bound = ""), PartialEq(bound = ""), Eq(bound = ""), Hash(bound = ""))]
pub struct Probe<I: Interner> { pub struct Probe<I: Interner> {
/// What happened inside of this probe in chronological order. /// What happened inside of this probe in chronological order.
pub steps: Vec<ProbeStep<I>>, pub steps: Vec<ProbeStep<I>>,
@ -98,8 +91,7 @@ pub struct Probe<I: Interner> {
pub final_state: CanonicalState<I, ()>, pub final_state: CanonicalState<I, ()>,
} }
#[derive(derivative::Derivative)] #[derive_where(PartialEq, Eq, Hash, Debug; I: Interner)]
#[derivative(PartialEq(bound = ""), Eq(bound = ""), Hash(bound = ""), Debug(bound = ""))]
pub enum ProbeStep<I: Interner> { pub enum ProbeStep<I: Interner> {
/// We added a goal to the `EvalCtxt` which will get proven /// We added a goal to the `EvalCtxt` which will get proven
/// the next time `EvalCtxt::try_evaluate_added_goals` is called. /// the next time `EvalCtxt::try_evaluate_added_goals` is called.
@ -121,15 +113,7 @@ pub enum ProbeStep<I: Interner> {
/// What kind of probe we're in. In case the probe represents a candidate, or /// What kind of probe we're in. In case the probe represents a candidate, or
/// the final result of the current goal - via [ProbeKind::Root] - we also /// the final result of the current goal - via [ProbeKind::Root] - we also
/// store the [QueryResult]. /// store the [QueryResult].
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, PartialEq, Eq, Hash, Debug; I: Interner)]
#[derivative(
Clone(bound = ""),
Copy(bound = ""),
PartialEq(bound = ""),
Eq(bound = ""),
Hash(bound = ""),
Debug(bound = "")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic)]
pub enum ProbeKind<I: Interner> { pub enum ProbeKind<I: Interner> {
/// The root inference context while proving a goal. /// The root inference context while proving a goal.

84
compiler/rustc_type_ir/src/solve/mod.rs
View File

@ -3,6 +3,7 @@ pub mod inspect;
use std::fmt; use std::fmt;
use std::hash::Hash; use std::hash::Hash;
use derive_where::derive_where;
#[cfg(feature = "nightly")] #[cfg(feature = "nightly")]
use rustc_macros::{HashStable_NoContext, TyDecodable, TyEncodable}; use rustc_macros::{HashStable_NoContext, TyDecodable, TyEncodable};
use rustc_type_ir_macros::{Lift_Generic, TypeFoldable_Generic, TypeVisitable_Generic}; use rustc_type_ir_macros::{Lift_Generic, TypeFoldable_Generic, TypeVisitable_Generic};
@ -89,15 +90,12 @@ pub struct NoSolution;
/// ///
/// Most of the time the `param_env` contains the `where`-bounds of the function /// Most of the time the `param_env` contains the `where`-bounds of the function
/// we're currently typechecking while the `predicate` is some trait bound. /// we're currently typechecking while the `predicate` is some trait bound.
#[derive(derivative::Derivative)] #[derive_where(Clone; I: Interner, P: Clone)]
#[derivative( #[derive_where(Copy; I: Interner, P: Copy)]
Clone(bound = "P: Clone"), #[derive_where(Hash; I: Interner, P: Hash)]
Copy(bound = "P: Copy"), #[derive_where(PartialEq; I: Interner, P: PartialEq)]
Hash(bound = "P: Hash"), #[derive_where(Eq; I: Interner, P: Eq)]
PartialEq(bound = "P: PartialEq"), #[derive_where(Debug; I: Interner, P: fmt::Debug)]
Eq(bound = "P: Eq"),
Debug(bound = "P: fmt::Debug")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)]
#[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))]
pub struct Goal<I: Interner, P> { pub struct Goal<I: Interner, P> {
@ -140,15 +138,12 @@ pub enum GoalSource {
InstantiateHigherRanked, InstantiateHigherRanked,
} }
#[derive(derivative::Derivative)] #[derive_where(Clone; I: Interner, Goal<I, P>: Clone)]
#[derivative( #[derive_where(Copy; I: Interner, Goal<I, P>: Copy)]
Clone(bound = "Goal<I, P>: Clone"), #[derive_where(Hash; I: Interner, Goal<I, P>: Hash)]
Copy(bound = "Goal<I, P>: Copy"), #[derive_where(PartialEq; I: Interner, Goal<I, P>: PartialEq)]
Hash(bound = "Goal<I, P>: Hash"), #[derive_where(Eq; I: Interner, Goal<I, P>: Eq)]
PartialEq(bound = "Goal<I, P>: PartialEq"), #[derive_where(Debug; I: Interner, Goal<I, P>: fmt::Debug)]
Eq(bound = "Goal<I, P>: Eq"),
Debug(bound = "Goal<I, P>: fmt::Debug")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic)]
#[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))]
pub struct QueryInput<I: Interner, P> { pub struct QueryInput<I: Interner, P> {
@ -157,15 +152,7 @@ pub struct QueryInput<I: Interner, P> {
} }
/// Opaques that are defined in the inference context before a query is called. /// Opaques that are defined in the inference context before a query is called.
#[derive(derivative::Derivative)] #[derive_where(Clone, Hash, PartialEq, Eq, Debug, Default; I: Interner)]
#[derivative(
Clone(bound = ""),
Hash(bound = ""),
PartialEq(bound = ""),
Eq(bound = ""),
Debug(bound = ""),
Default(bound = "")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic)]
#[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))]
pub struct PredefinedOpaquesData<I: Interner> { pub struct PredefinedOpaquesData<I: Interner> {
@ -173,15 +160,7 @@ pub struct PredefinedOpaquesData<I: Interner> {
} }
/// Possible ways the given goal can be proven. /// Possible ways the given goal can be proven.
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, Hash, PartialEq, Eq, Debug; I: Interner)]
#[derivative(
Clone(bound = ""),
Copy(bound = ""),
Hash(bound = ""),
PartialEq(bound = ""),
Eq(bound = ""),
Debug(bound = "")
)]
pub enum CandidateSource<I: Interner> { pub enum CandidateSource<I: Interner> {
/// A user written impl. /// A user written impl.
/// ///
@ -265,15 +244,7 @@ pub enum BuiltinImplSource {
TupleUnsizing, TupleUnsizing,
} }
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, Hash, PartialEq, Eq, Debug; I: Interner)]
#[derivative(
Clone(bound = ""),
Copy(bound = ""),
Hash(bound = ""),
PartialEq(bound = ""),
Eq(bound = ""),
Debug(bound = "")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic)]
#[cfg_attr(feature = "nightly", derive(HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(HashStable_NoContext))]
pub struct Response<I: Interner> { pub struct Response<I: Interner> {
@ -284,15 +255,7 @@ pub struct Response<I: Interner> {
} }
/// Additional constraints returned on success. /// Additional constraints returned on success.
#[derive(derivative::Derivative)] #[derive_where(Clone, Hash, PartialEq, Eq, Debug, Default; I: Interner)]
#[derivative(
Clone(bound = ""),
Hash(bound = ""),
PartialEq(bound = ""),
Eq(bound = ""),
Debug(bound = ""),
Default(bound = "")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic)]
#[cfg_attr(feature = "nightly", derive(HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(HashStable_NoContext))]
pub struct ExternalConstraintsData<I: Interner> { pub struct ExternalConstraintsData<I: Interner> {
@ -301,15 +264,7 @@ pub struct ExternalConstraintsData<I: Interner> {
pub normalization_nested_goals: NestedNormalizationGoals<I>, pub normalization_nested_goals: NestedNormalizationGoals<I>,
} }
#[derive(derivative::Derivative)] #[derive_where(Clone, Hash, PartialEq, Eq, Debug, Default; I: Interner)]
#[derivative(
Clone(bound = ""),
Hash(bound = ""),
PartialEq(bound = ""),
Eq(bound = ""),
Debug(bound = ""),
Default(bound = "")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic)]
#[cfg_attr(feature = "nightly", derive(HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(HashStable_NoContext))]
pub struct NestedNormalizationGoals<I: Interner>(pub Vec<(GoalSource, Goal<I, I::Predicate>)>); pub struct NestedNormalizationGoals<I: Interner>(pub Vec<(GoalSource, Goal<I, I::Predicate>)>);
@ -386,8 +341,7 @@ impl MaybeCause {
} }
} }
#[derive(derivative::Derivative)] #[derive_where(PartialEq, Eq, Debug; I: Interner)]
#[derivative(PartialEq(bound = ""), Eq(bound = ""), Debug(bound = ""))]
pub struct CacheData<I: Interner> { pub struct CacheData<I: Interner> {
pub result: QueryResult<I>, pub result: QueryResult<I>,
pub proof_tree: Option<I::CanonicalGoalEvaluationStepRef>, pub proof_tree: Option<I::CanonicalGoalEvaluationStepRef>,

39
compiler/rustc_type_ir/src/ty_kind.rs
View File

@ -1,3 +1,7 @@
#![allow(clippy::derived_hash_with_manual_eq)]
use derive_where::derive_where;
#[cfg(feature = "nightly")] #[cfg(feature = "nightly")]
use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
#[cfg(feature = "nightly")] #[cfg(feature = "nightly")]
@ -64,8 +68,7 @@ impl AliasTyKind {
/// Types written by the user start out as `hir::TyKind` and get /// Types written by the user start out as `hir::TyKind` and get
/// converted to this representation using `<dyn HirTyLowerer>::lower_ty`. /// converted to this representation using `<dyn HirTyLowerer>::lower_ty`.
#[cfg_attr(feature = "nightly", rustc_diagnostic_item = "IrTyKind")] #[cfg_attr(feature = "nightly", rustc_diagnostic_item = "IrTyKind")]
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, Hash, Eq; I: Interner)]
#[derivative(Clone(bound = ""), Copy(bound = ""), Hash(bound = ""), Eq(bound = ""))]
#[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))]
pub enum TyKind<I: Interner> { pub enum TyKind<I: Interner> {
/// The primitive boolean type. Written as `bool`. /// The primitive boolean type. Written as `bool`.
@ -292,6 +295,7 @@ const fn tykind_discriminant<I: Interner>(value: &TyKind<I>) -> usize {
} }
} }
// FIXME(GrigorenkoPV): consider not implementing PartialEq manually
// This is manually implemented because a derive would require `I: PartialEq` // This is manually implemented because a derive would require `I: PartialEq`
impl<I: Interner> PartialEq for TyKind<I> { impl<I: Interner> PartialEq for TyKind<I> {
#[inline] #[inline]
@ -414,15 +418,7 @@ impl<I: Interner> fmt::Debug for TyKind<I> {
/// * For a projection, this would be `<Ty as Trait<...>>::N<...>`. /// * For a projection, this would be `<Ty as Trait<...>>::N<...>`.
/// * For an inherent projection, this would be `Ty::N<...>`. /// * For an inherent projection, this would be `Ty::N<...>`.
/// * For an opaque type, there is no explicit syntax. /// * For an opaque type, there is no explicit syntax.
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, Hash, PartialEq, Eq, Debug; I: Interner)]
#[derivative(
Clone(bound = ""),
Copy(bound = ""),
Hash(bound = ""),
PartialEq(bound = ""),
Eq(bound = ""),
Debug(bound = "")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)]
#[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))]
pub struct AliasTy<I: Interner> { pub struct AliasTy<I: Interner> {
@ -451,7 +447,7 @@ pub struct AliasTy<I: Interner> {
pub def_id: I::DefId, pub def_id: I::DefId,
/// This field exists to prevent the creation of `AliasTy` without using [`AliasTy::new_from_args`]. /// This field exists to prevent the creation of `AliasTy` without using [`AliasTy::new_from_args`].
#[derivative(Debug = "ignore")] #[derive_where(skip(Debug))]
pub(crate) _use_alias_ty_new_instead: (), pub(crate) _use_alias_ty_new_instead: (),
} }
@ -942,15 +938,7 @@ impl fmt::Debug for InferTy {
} }
} }
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, PartialEq, Eq, Hash, Debug; I: Interner)]
#[derivative(
Clone(bound = ""),
Copy(bound = ""),
PartialEq(bound = ""),
Eq(bound = ""),
Hash(bound = ""),
Debug(bound = "")
)]
#[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic)]
pub struct TypeAndMut<I: Interner> { pub struct TypeAndMut<I: Interner> {
@ -958,14 +946,7 @@ pub struct TypeAndMut<I: Interner> {
pub mutbl: Mutability, pub mutbl: Mutability,
} }
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, PartialEq, Eq, Hash; I: Interner)]
#[derivative(
Clone(bound = ""),
Copy(bound = ""),
PartialEq(bound = ""),
Eq(bound = ""),
Hash(bound = "")
)]
#[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))] #[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)]
pub struct FnSig<I: Interner> { pub struct FnSig<I: Interner> {

51
compiler/rustc_type_ir/src/ty_kind/closure.rs
View File

@ -1,5 +1,6 @@
use std::ops::ControlFlow; use std::ops::ControlFlow;
use derive_where::derive_where;
use rustc_type_ir_macros::{Lift_Generic, TypeFoldable_Generic, TypeVisitable_Generic}; use rustc_type_ir_macros::{Lift_Generic, TypeFoldable_Generic, TypeVisitable_Generic};
use crate::fold::{shift_region, TypeFoldable, TypeFolder, TypeSuperFoldable}; use crate::fold::{shift_region, TypeFoldable, TypeFolder, TypeSuperFoldable};
@ -100,15 +101,7 @@ use crate::{self as ty, Interner};
/// * `GR`: The "return type", which is the type of value returned upon /// * `GR`: The "return type", which is the type of value returned upon
/// completion of the coroutine. /// completion of the coroutine.
/// * `GW`: The "coroutine witness". /// * `GW`: The "coroutine witness".
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, PartialEq, Eq, Hash, Debug; I: Interner)]
#[derivative(
Clone(bound = ""),
Copy(bound = ""),
Hash(bound = ""),
PartialEq(bound = ""),
Eq(bound = ""),
Debug(bound = "")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)]
pub struct ClosureArgs<I: Interner> { pub struct ClosureArgs<I: Interner> {
/// Lifetime and type parameters from the enclosing function, /// Lifetime and type parameters from the enclosing function,
@ -210,15 +203,7 @@ impl<I: Interner> ClosureArgs<I> {
} }
} }
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, PartialEq, Eq, Hash, Debug; I: Interner)]
#[derivative(
Clone(bound = ""),
Copy(bound = ""),
Hash(bound = ""),
PartialEq(bound = ""),
Eq(bound = ""),
Debug(bound = "")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)]
pub struct CoroutineClosureArgs<I: Interner> { pub struct CoroutineClosureArgs<I: Interner> {
pub args: I::GenericArgs, pub args: I::GenericArgs,
@ -370,15 +355,7 @@ impl<I: Interner> TypeVisitor<I> for HasRegionsBoundAt {
} }
} }
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, PartialEq, Eq, Hash, Debug; I: Interner)]
#[derivative(
Clone(bound = ""),
Copy(bound = ""),
Hash(bound = ""),
PartialEq(bound = ""),
Eq(bound = ""),
Debug(bound = "")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic)]
pub struct CoroutineClosureSignature<I: Interner> { pub struct CoroutineClosureSignature<I: Interner> {
pub interior: I::Ty, pub interior: I::Ty,
@ -552,15 +529,7 @@ impl<I: Interner> TypeFolder<I> for FoldEscapingRegions<I> {
} }
} }
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, PartialEq, Eq, Hash, Debug; I: Interner)]
#[derivative(
Clone(bound = ""),
Copy(bound = ""),
Hash(bound = ""),
PartialEq(bound = ""),
Eq(bound = ""),
Debug(bound = "")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic)]
pub struct GenSig<I: Interner> { pub struct GenSig<I: Interner> {
pub resume_ty: I::Ty, pub resume_ty: I::Ty,
@ -569,15 +538,7 @@ pub struct GenSig<I: Interner> {
} }
/// Similar to `ClosureArgs`; see the above documentation for more. /// Similar to `ClosureArgs`; see the above documentation for more.
#[derive(derivative::Derivative)] #[derive_where(Clone, Copy, PartialEq, Eq, Hash, Debug; I: Interner)]
#[derivative(
Clone(bound = ""),
Copy(bound = ""),
Hash(bound = ""),
PartialEq(bound = ""),
Eq(bound = ""),
Debug(bound = "")
)]
#[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)] #[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)]
pub struct CoroutineArgs<I: Interner> { pub struct CoroutineArgs<I: Interner> {
pub args: I::GenericArgs, pub args: I::GenericArgs,

2
src/tools/tidy/src/deps.rs
View File

@ -269,7 +269,7 @@ const PERMITTED_RUSTC_DEPENDENCIES: &[&str] = &[
"darling_macro", "darling_macro",
"datafrog", "datafrog",
"deranged", "deranged",
"derivative", "derive-where",
"derive_more", "derive_more",
"derive_setters", "derive_setters",
"digest", "digest",

2
tests/ui/attributes/dump-preds.stderr
View File

@ -31,7 +31,7 @@ error: rustc_dump_item_bounds
LL | type Assoc<P: Eq>: std::ops::Deref<Target = ()> LL | type Assoc<P: Eq>: std::ops::Deref<Target = ()>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: Binder { value: ProjectionPredicate(AliasTerm { args: [Alias(Projection, AliasTy { args: [Self/#0, T/#1, P/#2], def_id: DefId(..) })], def_id: DefId(..) }, Term::Ty(())), bound_vars: [] } = note: Binder { value: ProjectionPredicate(AliasTerm { args: [Alias(Projection, AliasTy { args: [Self/#0, T/#1, P/#2], def_id: DefId(..), .. })], def_id: DefId(..), .. }, Term::Ty(())), bound_vars: [] }
= note: Binder { value: TraitPredicate(<<Self as Trait<T>>::Assoc<P> as std::ops::Deref>, polarity:Positive), bound_vars: [] } = note: Binder { value: TraitPredicate(<<Self as Trait<T>>::Assoc<P> as std::ops::Deref>, polarity:Positive), bound_vars: [] }
= note: Binder { value: TraitPredicate(<<Self as Trait<T>>::Assoc<P> as std::marker::Sized>, polarity:Positive), bound_vars: [] } = note: Binder { value: TraitPredicate(<<Self as Trait<T>>::Assoc<P> as std::marker::Sized>, polarity:Positive), bound_vars: [] }

8
tests/ui/coherence/occurs-check/associated-type.next.stderr
View File

@ -1,7 +1,7 @@
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [*const ?1t, '^0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), "'a")], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) } WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [*const ?1t, '^0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), "'a")], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit), .. }
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [*const ?1t, '^0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), "'a")], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) } WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [*const ?1t, '^0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), "'a")], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit), .. }
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [*const ?1t, '^0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), "'a")], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) } WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [*const ?1t, '^0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), "'a")], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit), .. }
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [*const ?1t, '^0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), "'a")], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) } WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [*const ?1t, '^0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), "'a")], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit), .. }
error[E0119]: conflicting implementations of trait `Overlap<for<'a> fn(&'a (), ())>` for type `for<'a> fn(&'a (), ())` error[E0119]: conflicting implementations of trait `Overlap<for<'a> fn(&'a (), ())>` for type `for<'a> fn(&'a (), ())`
--> $DIR/associated-type.rs:31:1 --> $DIR/associated-type.rs:31:1
| |

16
tests/ui/coherence/occurs-check/associated-type.old.stderr
View File

@ -1,11 +1,11 @@
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [*const ?1t, '^0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), "'a")], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) } WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [*const ?1t, '^0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), "'a")], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit), .. }
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [*const ?1t, !2_0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), "'a")], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) } WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [*const ?1t, !2_0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), "'a")], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit), .. }
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [*const ?1t, '^0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), "'a")], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) } WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [*const ?1t, '^0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), "'a")], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit), .. }
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [*const ?1t, !2_0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), "'a")], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) } WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [*const ?1t, !2_0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), "'a")], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit), .. }
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [*const ?1t, '^0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), "'a")], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) } WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [*const ?1t, '^0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), "'a")], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit), .. }
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [*const ?1t, !2_0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), "'a")], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) } WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [*const ?1t, !2_0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), "'a")], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit), .. }
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [*const ?1t, '^0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), "'a")], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) } WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [*const ?1t, '^0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), "'a")], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit), .. }
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [*const ?1t, !2_0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), "'a")], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit) } WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [*const ?1t, !2_0.Named(DefId(0:27 ~ associated_type[f554]::{impl#3}::'a#1), "'a")], def_id: DefId(0:5 ~ associated_type[f554]::ToUnit::Unit), .. }
error[E0119]: conflicting implementations of trait `Overlap<for<'a> fn(&'a (), _)>` for type `for<'a> fn(&'a (), _)` error[E0119]: conflicting implementations of trait `Overlap<for<'a> fn(&'a (), _)>` for type `for<'a> fn(&'a (), _)`
--> $DIR/associated-type.rs:31:1 --> $DIR/associated-type.rs:31:1
| |

4
tests/ui/higher-ranked/structually-relate-aliases.stderr
View File

@ -1,5 +1,5 @@
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [?1t, '^0.Named(DefId(0:15 ~ structually_relate_aliases[de75]::{impl#1}::'a), "'a")], def_id: DefId(0:5 ~ structually_relate_aliases[de75]::ToUnit::Unit) } WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [?1t, '^0.Named(DefId(0:15 ~ structually_relate_aliases[de75]::{impl#1}::'a), "'a")], def_id: DefId(0:5 ~ structually_relate_aliases[de75]::ToUnit::Unit), .. }
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [?1t, !2_0.Named(DefId(0:15 ~ structually_relate_aliases[de75]::{impl#1}::'a), "'a")], def_id: DefId(0:5 ~ structually_relate_aliases[de75]::ToUnit::Unit) } WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: [?1t, !2_0.Named(DefId(0:15 ~ structually_relate_aliases[de75]::{impl#1}::'a), "'a")], def_id: DefId(0:5 ~ structually_relate_aliases[de75]::ToUnit::Unit), .. }
error[E0277]: the trait bound `for<'a> T: ToUnit<'a>` is not satisfied error[E0277]: the trait bound `for<'a> T: ToUnit<'a>` is not satisfied
--> $DIR/structually-relate-aliases.rs:13:36 --> $DIR/structually-relate-aliases.rs:13:36
| |

8
tests/ui/traits/next-solver/issue-118950-root-region.stderr
View File

@ -25,10 +25,10 @@ help: this trait has no implementations, consider adding one
LL | trait ToUnit<'a> { LL | trait ToUnit<'a> {
| ^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: ['^0.Named(DefId(0:15 ~ issue_118950_root_region[d54f]::{impl#1}::'a), "'a"), ?1t], def_id: DefId(0:8 ~ issue_118950_root_region[d54f]::Assoc) } WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: ['^0.Named(DefId(0:15 ~ issue_118950_root_region[d54f]::{impl#1}::'a), "'a"), ?1t], def_id: DefId(0:8 ~ issue_118950_root_region[d54f]::Assoc), .. }
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: ['^0.Named(DefId(0:15 ~ issue_118950_root_region[d54f]::{impl#1}::'a), "'a"), ?1t], def_id: DefId(0:8 ~ issue_118950_root_region[d54f]::Assoc) } WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: ['^0.Named(DefId(0:15 ~ issue_118950_root_region[d54f]::{impl#1}::'a), "'a"), ?1t], def_id: DefId(0:8 ~ issue_118950_root_region[d54f]::Assoc), .. }
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: ['^0.Named(DefId(0:15 ~ issue_118950_root_region[d54f]::{impl#1}::'a), "'a"), ?1t], def_id: DefId(0:8 ~ issue_118950_root_region[d54f]::Assoc) } WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: ['^0.Named(DefId(0:15 ~ issue_118950_root_region[d54f]::{impl#1}::'a), "'a"), ?1t], def_id: DefId(0:8 ~ issue_118950_root_region[d54f]::Assoc), .. }
WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: ['^0.Named(DefId(0:15 ~ issue_118950_root_region[d54f]::{impl#1}::'a), "'a"), ?1t], def_id: DefId(0:8 ~ issue_118950_root_region[d54f]::Assoc) } WARN rustc_infer::infer::relate::generalize may incompletely handle alias type: AliasTy { args: ['^0.Named(DefId(0:15 ~ issue_118950_root_region[d54f]::{impl#1}::'a), "'a"), ?1t], def_id: DefId(0:8 ~ issue_118950_root_region[d54f]::Assoc), .. }
error[E0119]: conflicting implementations of trait `Overlap<fn(_)>` for type `fn(_)` error[E0119]: conflicting implementations of trait `Overlap<fn(_)>` for type `fn(_)`
--> $DIR/issue-118950-root-region.rs:19:1 --> $DIR/issue-118950-root-region.rs:19:1
| |