Skip to content

Commit 02dde5d

Browse files
borsbors
committed
Auto merge of rust-lang#120432 - matthiaskrgr:rollup-ho8zrrk, r=matthiaskrgr
Rollup of 8 pull requests Successful merges: - rust-lang#116677 (References refer to allocated objects) - rust-lang#120232 (Add support for custom JSON targets when using build-std.) - rust-lang#120266 (Improve documentation for [A]Rc::into_inner) - rust-lang#120358 (Bump Fuchsia, build tests, and use 8 core bots) - rust-lang#120373 (Adjust Behaviour of `read_dir` and `ReadDir` in Windows Implementation: Check Whether Path to Search In Exists) - rust-lang#120402 (Make the coroutine def id of an async closure the child of the closure def id) - rust-lang#120420 (Stop using derivative in rustc_pattern_analysis) - rust-lang#120425 (Remove unnecessary unit returns in query declarations) r? `@ghost` `@rustbot` modify labels: rollup
2 parents 6351247 + e1fa42e commit 02dde5d

File tree

22 files changed

+374
-97
lines changed

22 files changed

+374
-97
lines changed

Diff for: ‎.github/workflows/ci.yml

+1-1
Original file line numberDiff line numberDiff line change
@@ -291,7 +291,7 @@ jobs:
291291
- name: x86_64-gnu-integration
292292
env:
293293
CI_ONLY_WHEN_CHANNEL: nightly
294-
os: ubuntu-20.04-16core-64gb
294+
os: ubuntu-20.04-8core-32gb
295295
- name: x86_64-gnu-debug
296296
os: ubuntu-20.04-8core-32gb
297297
env: {}

Diff for: ‎Cargo.lock

-1
Original file line numberDiff line numberDiff line change
@@ -4342,7 +4342,6 @@ dependencies = [
43424342
name = "rustc_pattern_analysis"
43434343
version = "0.0.0"
43444344
dependencies = [
4345-
"derivative",
43464345
"rustc-hash",
43474346
"rustc_apfloat",
43484347
"rustc_arena",

Diff for: ‎compiler/rustc_middle/src/query/mod.rs

+14-14
Original file line numberDiff line numberDiff line change
@@ -109,7 +109,7 @@ pub use plumbing::{IntoQueryParam, TyCtxtAt, TyCtxtEnsure, TyCtxtEnsureWithValue
109109
// as they will raise an fatal error on query cycles instead.
110110
rustc_queries! {
111111
/// This exists purely for testing the interactions between span_delayed_bug and incremental.
112-
query trigger_span_delayed_bug(key: DefId) -> () {
112+
query trigger_span_delayed_bug(key: DefId) {
113113
desc { "triggering a span delayed bug for testing incremental" }
114114
}
115115

@@ -119,7 +119,7 @@ rustc_queries! {
119119
desc { "compute registered tools for crate" }
120120
}
121121

122-
query early_lint_checks(_: ()) -> () {
122+
query early_lint_checks(_: ()) {
123123
desc { "perform lints prior to macro expansion" }
124124
}
125125

@@ -299,7 +299,7 @@ rustc_queries! {
299299
/// name. This is useful for cases were not all linting code from rustc
300300
/// was called. With the default `None` all registered lints will also
301301
/// be checked for expectation fulfillment.
302-
query check_expectations(key: Option<Symbol>) -> () {
302+
query check_expectations(key: Option<Symbol>) {
303303
eval_always
304304
desc { "checking lint expectations (RFC 2383)" }
305305
}
@@ -906,39 +906,39 @@ rustc_queries! {
906906
}
907907

908908
/// Performs lint checking for the module.
909-
query lint_mod(key: LocalModDefId) -> () {
909+
query lint_mod(key: LocalModDefId) {
910910
desc { |tcx| "linting {}", describe_as_module(key, tcx) }
911911
}
912912

913-
query check_unused_traits(_: ()) -> () {
913+
query check_unused_traits(_: ()) {
914914
desc { "checking unused trait imports in crate" }
915915
}
916916

917917
/// Checks the attributes in the module.
918-
query check_mod_attrs(key: LocalModDefId) -> () {
918+
query check_mod_attrs(key: LocalModDefId) {
919919
desc { |tcx| "checking attributes in {}", describe_as_module(key, tcx) }
920920
}
921921

922922
/// Checks for uses of unstable APIs in the module.
923-
query check_mod_unstable_api_usage(key: LocalModDefId) -> () {
923+
query check_mod_unstable_api_usage(key: LocalModDefId) {
924924
desc { |tcx| "checking for unstable API usage in {}", describe_as_module(key, tcx) }
925925
}
926926

927927
/// Checks the const bodies in the module for illegal operations (e.g. `if` or `loop`).
928-
query check_mod_const_bodies(key: LocalModDefId) -> () {
928+
query check_mod_const_bodies(key: LocalModDefId) {
929929
desc { |tcx| "checking consts in {}", describe_as_module(key, tcx) }
930930
}
931931

932932
/// Checks the loops in the module.
933-
query check_mod_loops(key: LocalModDefId) -> () {
933+
query check_mod_loops(key: LocalModDefId) {
934934
desc { |tcx| "checking loops in {}", describe_as_module(key, tcx) }
935935
}
936936

937-
query check_mod_naked_functions(key: LocalModDefId) -> () {
937+
query check_mod_naked_functions(key: LocalModDefId) {
938938
desc { |tcx| "checking naked functions in {}", describe_as_module(key, tcx) }
939939
}
940940

941-
query check_mod_privacy(key: LocalModDefId) -> () {
941+
query check_mod_privacy(key: LocalModDefId) {
942942
desc { |tcx| "checking privacy in {}", describe_as_module(key.to_local_def_id(), tcx) }
943943
}
944944

@@ -958,7 +958,7 @@ rustc_queries! {
958958
desc { "finding live symbols in crate" }
959959
}
960960

961-
query check_mod_deathness(key: LocalModDefId) -> () {
961+
query check_mod_deathness(key: LocalModDefId) {
962962
desc { |tcx| "checking deathness of variables in {}", describe_as_module(key, tcx) }
963963
}
964964

@@ -972,7 +972,7 @@ rustc_queries! {
972972
ensure_forwards_result_if_red
973973
}
974974

975-
query collect_mod_item_types(key: LocalModDefId) -> () {
975+
query collect_mod_item_types(key: LocalModDefId) {
976976
desc { |tcx| "collecting item types in {}", describe_as_module(key, tcx) }
977977
}
978978

@@ -1121,7 +1121,7 @@ rustc_queries! {
11211121
eval_always
11221122
desc { "checking effective visibilities" }
11231123
}
1124-
query check_private_in_public(_: ()) -> () {
1124+
query check_private_in_public(_: ()) {
11251125
eval_always
11261126
desc { "checking for private elements in public interfaces" }
11271127
}

Diff for: ‎compiler/rustc_pattern_analysis/Cargo.toml

-1
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,6 @@ edition = "2021"
55

66
[dependencies]
77
# tidy-alphabetical-start
8-
derivative = "2.2.0"
98
rustc-hash = "1.1.0"
109
rustc_apfloat = "0.2.0"
1110
rustc_arena = { path = "../rustc_arena", optional = true }

Diff for: ‎compiler/rustc_pattern_analysis/src/constructor.rs

+96-2
Original file line numberDiff line numberDiff line change
@@ -151,6 +151,7 @@
151151
use std::cmp::{self, max, min, Ordering};
152152
use std::fmt;
153153
use std::iter::once;
154+
use std::mem;
154155

155156
use smallvec::SmallVec;
156157

@@ -648,8 +649,6 @@ impl OpaqueId {
648649
/// `specialize_constructor` returns the list of fields corresponding to a pattern, given a
649650
/// constructor. `Constructor::apply` reconstructs the pattern from a pair of `Constructor` and
650651
/// `Fields`.
651-
#[derive(derivative::Derivative)]
652-
#[derivative(Debug(bound = ""), Clone(bound = ""), PartialEq(bound = ""))]
653652
pub enum Constructor<Cx: TypeCx> {
654653
/// Tuples and structs.
655654
Struct,
@@ -692,6 +691,101 @@ pub enum Constructor<Cx: TypeCx> {
692691
Missing,
693692
}
694693

694+
impl<Cx: TypeCx> Clone for Constructor<Cx> {
695+
fn clone(&self) -> Self {
696+
match self {
697+
Constructor::Struct => Constructor::Struct,
698+
Constructor::Variant(idx) => Constructor::Variant(idx.clone()),
699+
Constructor::Ref => Constructor::Ref,
700+
Constructor::Slice(slice) => Constructor::Slice(slice.clone()),
701+
Constructor::UnionField => Constructor::UnionField,
702+
Constructor::Bool(b) => Constructor::Bool(b.clone()),
703+
Constructor::IntRange(range) => Constructor::IntRange(range.clone()),
704+
Constructor::F32Range(lo, hi, end) => {
705+
Constructor::F32Range(lo.clone(), hi.clone(), end.clone())
706+
}
707+
Constructor::F64Range(lo, hi, end) => {
708+
Constructor::F64Range(lo.clone(), hi.clone(), end.clone())
709+
}
710+
Constructor::Str(value) => Constructor::Str(value.clone()),
711+
Constructor::Opaque(inner) => Constructor::Opaque(inner.clone()),
712+
Constructor::Or => Constructor::Or,
713+
Constructor::Wildcard => Constructor::Wildcard,
714+
Constructor::NonExhaustive => Constructor::NonExhaustive,
715+
Constructor::Hidden => Constructor::Hidden,
716+
Constructor::Missing => Constructor::Missing,
717+
}
718+
}
719+
}
720+
721+
impl<Cx: TypeCx> fmt::Debug for Constructor<Cx> {
722+
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
723+
match self {
724+
Constructor::Struct => f.debug_tuple("Struct").finish(),
725+
Constructor::Variant(idx) => f.debug_tuple("Variant").field(idx).finish(),
726+
Constructor::Ref => f.debug_tuple("Ref").finish(),
727+
Constructor::Slice(slice) => f.debug_tuple("Slice").field(slice).finish(),
728+
Constructor::UnionField => f.debug_tuple("UnionField").finish(),
729+
Constructor::Bool(b) => f.debug_tuple("Bool").field(b).finish(),
730+
Constructor::IntRange(range) => f.debug_tuple("IntRange").field(range).finish(),
731+
Constructor::F32Range(lo, hi, end) => {
732+
f.debug_tuple("F32Range").field(lo).field(hi).field(end).finish()
733+
}
734+
Constructor::F64Range(lo, hi, end) => {
735+
f.debug_tuple("F64Range").field(lo).field(hi).field(end).finish()
736+
}
737+
Constructor::Str(value) => f.debug_tuple("Str").field(value).finish(),
738+
Constructor::Opaque(inner) => f.debug_tuple("Opaque").field(inner).finish(),
739+
Constructor::Or => f.debug_tuple("Or").finish(),
740+
Constructor::Wildcard => f.debug_tuple("Wildcard").finish(),
741+
Constructor::NonExhaustive => f.debug_tuple("NonExhaustive").finish(),
742+
Constructor::Hidden => f.debug_tuple("Hidden").finish(),
743+
Constructor::Missing => f.debug_tuple("Missing").finish(),
744+
}
745+
}
746+
}
747+
748+
impl<Cx: TypeCx> PartialEq for Constructor<Cx> {
749+
fn eq(&self, other: &Self) -> bool {
750+
(mem::discriminant(self) == mem::discriminant(other))
751+
&& match (self, other) {
752+
(Constructor::Struct, Constructor::Struct) => true,
753+
(Constructor::Variant(self_variant), Constructor::Variant(other_variant)) => {
754+
self_variant == other_variant
755+
}
756+
(Constructor::Ref, Constructor::Ref) => true,
757+
(Constructor::Slice(self_slice), Constructor::Slice(other_slice)) => {
758+
self_slice == other_slice
759+
}
760+
(Constructor::UnionField, Constructor::UnionField) => true,
761+
(Constructor::Bool(self_b), Constructor::Bool(other_b)) => self_b == other_b,
762+
(Constructor::IntRange(self_range), Constructor::IntRange(other_range)) => {
763+
self_range == other_range
764+
}
765+
(
766+
Constructor::F32Range(self_lo, self_hi, self_end),
767+
Constructor::F32Range(other_lo, other_hi, other_end),
768+
) => self_lo == other_lo && self_hi == other_hi && self_end == other_end,
769+
(
770+
Constructor::F64Range(self_lo, self_hi, self_end),
771+
Constructor::F64Range(other_lo, other_hi, other_end),
772+
) => self_lo == other_lo && self_hi == other_hi && self_end == other_end,
773+
(Constructor::Str(self_value), Constructor::Str(other_value)) => {
774+
self_value == other_value
775+
}
776+
(Constructor::Opaque(self_inner), Constructor::Opaque(other_inner)) => {
777+
self_inner == other_inner
778+
}
779+
(Constructor::Or, Constructor::Or) => true,
780+
(Constructor::Wildcard, Constructor::Wildcard) => true,
781+
(Constructor::NonExhaustive, Constructor::NonExhaustive) => true,
782+
(Constructor::Hidden, Constructor::Hidden) => true,
783+
(Constructor::Missing, Constructor::Missing) => true,
784+
_ => unreachable!(),
785+
}
786+
}
787+
}
788+
695789
impl<Cx: TypeCx> Constructor<Cx> {
696790
pub(crate) fn is_non_exhaustive(&self) -> bool {
697791
matches!(self, NonExhaustive)

Diff for: ‎compiler/rustc_pattern_analysis/src/lib.rs

+16-4
Original file line numberDiff line numberDiff line change
@@ -136,23 +136,35 @@ pub trait TypeCx: Sized + fmt::Debug {
136136
}
137137

138138
/// Context that provides information global to a match.
139-
#[derive(derivative::Derivative)]
140-
#[derivative(Clone(bound = ""), Copy(bound = ""))]
141139
pub struct MatchCtxt<'a, Cx: TypeCx> {
142140
/// The context for type information.
143141
pub tycx: &'a Cx,
144142
}
145143

144+
impl<'a, Cx: TypeCx> Clone for MatchCtxt<'a, Cx> {
145+
fn clone(&self) -> Self {
146+
Self { tycx: self.tycx }
147+
}
148+
}
149+
150+
impl<'a, Cx: TypeCx> Copy for MatchCtxt<'a, Cx> {}
151+
146152
/// The arm of a match expression.
147153
#[derive(Debug)]
148-
#[derive(derivative::Derivative)]
149-
#[derivative(Clone(bound = ""), Copy(bound = ""))]
150154
pub struct MatchArm<'p, Cx: TypeCx> {
151155
pub pat: &'p DeconstructedPat<'p, Cx>,
152156
pub has_guard: bool,
153157
pub arm_data: Cx::ArmData,
154158
}
155159

160+
impl<'p, Cx: TypeCx> Clone for MatchArm<'p, Cx> {
161+
fn clone(&self) -> Self {
162+
Self { pat: self.pat, has_guard: self.has_guard, arm_data: self.arm_data }
163+
}
164+
}
165+
166+
impl<'p, Cx: TypeCx> Copy for MatchArm<'p, Cx> {}
167+
156168
/// The entrypoint for this crate. Computes whether a match is exhaustive and which of its arms are
157169
/// useful, and runs some lints.
158170
#[cfg(feature = "rustc")]

Diff for: ‎compiler/rustc_pattern_analysis/src/pat.rs

+27-4
Original file line numberDiff line numberDiff line change
@@ -218,15 +218,24 @@ impl<'p, Cx: TypeCx> fmt::Debug for DeconstructedPat<'p, Cx> {
218218
/// algorithm. Do not use `Wild` to represent a wildcard pattern comping from user input.
219219
///
220220
/// This is morally `Option<&'p DeconstructedPat>` where `None` is interpreted as a wildcard.
221-
#[derive(derivative::Derivative)]
222-
#[derivative(Clone(bound = ""), Copy(bound = ""))]
223221
pub(crate) enum PatOrWild<'p, Cx: TypeCx> {
224222
/// A non-user-provided wildcard, created during specialization.
225223
Wild,
226224
/// A user-provided pattern.
227225
Pat(&'p DeconstructedPat<'p, Cx>),
228226
}
229227

228+
impl<'p, Cx: TypeCx> Clone for PatOrWild<'p, Cx> {
229+
fn clone(&self) -> Self {
230+
match self {
231+
PatOrWild::Wild => PatOrWild::Wild,
232+
PatOrWild::Pat(pat) => PatOrWild::Pat(pat),
233+
}
234+
}
235+
}
236+
237+
impl<'p, Cx: TypeCx> Copy for PatOrWild<'p, Cx> {}
238+
230239
impl<'p, Cx: TypeCx> PatOrWild<'p, Cx> {
231240
pub(crate) fn as_pat(&self) -> Option<&'p DeconstructedPat<'p, Cx>> {
232241
match self {
@@ -289,14 +298,28 @@ impl<'p, Cx: TypeCx> fmt::Debug for PatOrWild<'p, Cx> {
289298

290299
/// Same idea as `DeconstructedPat`, except this is a fictitious pattern built up for diagnostics
291300
/// purposes. As such they don't use interning and can be cloned.
292-
#[derive(derivative::Derivative)]
293-
#[derivative(Debug(bound = ""), Clone(bound = ""))]
294301
pub struct WitnessPat<Cx: TypeCx> {
295302
ctor: Constructor<Cx>,
296303
pub(crate) fields: Vec<WitnessPat<Cx>>,
297304
ty: Cx::Ty,
298305
}
299306

307+
impl<Cx: TypeCx> Clone for WitnessPat<Cx> {
308+
fn clone(&self) -> Self {
309+
Self { ctor: self.ctor.clone(), fields: self.fields.clone(), ty: self.ty.clone() }
310+
}
311+
}
312+
313+
impl<Cx: TypeCx> fmt::Debug for WitnessPat<Cx> {
314+
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
315+
fmt.debug_struct("WitnessPat")
316+
.field("ctor", &self.ctor)
317+
.field("fields", &self.fields)
318+
.field("ty", &self.ty)
319+
.finish()
320+
}
321+
}
322+
300323
impl<Cx: TypeCx> WitnessPat<Cx> {
301324
pub(crate) fn new(ctor: Constructor<Cx>, fields: Vec<Self>, ty: Cx::Ty) -> Self {
302325
Self { ctor, fields, ty }

Diff for: ‎compiler/rustc_pattern_analysis/src/rustc.rs

+6-2
Original file line numberDiff line numberDiff line change
@@ -46,11 +46,15 @@ pub type WitnessPat<'p, 'tcx> = crate::pat::WitnessPat<RustcMatchCheckCtxt<'p, '
4646
///
4747
/// Use `.inner()` or deref to get to the `Ty<'tcx>`.
4848
#[repr(transparent)]
49-
#[derive(derivative::Derivative)]
5049
#[derive(Clone, Copy)]
51-
#[derivative(Debug = "transparent")]
5250
pub struct RevealedTy<'tcx>(Ty<'tcx>);
5351

52+
impl<'tcx> fmt::Debug for RevealedTy<'tcx> {
53+
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
54+
self.0.fmt(fmt)
55+
}
56+
}
57+
5458
impl<'tcx> std::ops::Deref for RevealedTy<'tcx> {
5559
type Target = Ty<'tcx>;
5660
fn deref(&self) -> &Self::Target {

0 commit comments

Comments
 (0)