Skip to content

Commit bee7b58

Browse files
compiler-errorscompiler-errors
committed
Derive TyEncodable/TyDecodable implementations that are parameterized over interner
1 parent adda05f commit bee7b58

File tree

7 files changed

+31
-486
lines changed

7 files changed

+31
-486
lines changed

‎compiler/rustc_macros/src/serialize.rs

+20-10
Original file line numberDiff line numberDiff line change
@@ -5,11 +5,16 @@ use syn::spanned::Spanned;
55

66
pub fn type_decodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream {
77
let decoder_ty = quote! { __D };
8-
if !s.ast().generics.lifetimes().any(|lt| lt.lifetime.ident == "tcx") {
9-
s.add_impl_generic(parse_quote! { 'tcx });
10-
}
11-
s.add_impl_generic(parse_quote! {#decoder_ty: ::rustc_type_ir::codec::TyDecoder<I = ::rustc_middle::ty::TyCtxt<'tcx>>});
12-
s.add_bounds(synstructure::AddBounds::Generics);
8+
let bound = if s.ast().generics.lifetimes().any(|lt| lt.lifetime.ident == "tcx") {
9+
quote! { <I = ::rustc_middle::ty::TyCtxt<'tcx>> }
10+
} else if s.ast().generics.type_params().any(|ty| ty.ident == "I") {
11+
quote! { <I = I> }
12+
} else {
13+
quote! {}
14+
};
15+
16+
s.add_impl_generic(parse_quote! {#decoder_ty: ::rustc_type_ir::codec::TyDecoder #bound });
17+
s.add_bounds(synstructure::AddBounds::Fields);
1318

1419
decodable_body(s, decoder_ty)
1520
}
@@ -97,12 +102,17 @@ fn decode_field(field: &syn::Field) -> proc_macro2::TokenStream {
97102
}
98103

99104
pub fn type_encodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream {
100-
if !s.ast().generics.lifetimes().any(|lt| lt.lifetime.ident == "tcx") {
101-
s.add_impl_generic(parse_quote! {'tcx});
102-
}
105+
let bound = if s.ast().generics.lifetimes().any(|lt| lt.lifetime.ident == "tcx") {
106+
quote! { <I = ::rustc_middle::ty::TyCtxt<'tcx>> }
107+
} else if s.ast().generics.type_params().any(|ty| ty.ident == "I") {
108+
quote! { <I = I> }
109+
} else {
110+
quote! {}
111+
};
112+
103113
let encoder_ty = quote! { __E };
104-
s.add_impl_generic(parse_quote! {#encoder_ty: ::rustc_type_ir::codec::TyEncoder<I = ::rustc_middle::ty::TyCtxt<'tcx>>});
105-
s.add_bounds(synstructure::AddBounds::Generics);
114+
s.add_impl_generic(parse_quote! {#encoder_ty: ::rustc_type_ir::codec::TyEncoder #bound });
115+
s.add_bounds(synstructure::AddBounds::Fields);
106116

107117
encodable_body(s, encoder_ty, false)
108118
}

‎compiler/rustc_type_ir/src/canonical.rs

+2-27
Original file line numberDiff line numberDiff line change
@@ -3,18 +3,17 @@ use std::hash::Hash;
33
use std::ops::ControlFlow;
44

55
use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
6-
use rustc_serialize::{Decodable, Encodable};
76

87
use crate::fold::{FallibleTypeFolder, TypeFoldable};
98
use crate::visit::{TypeVisitable, TypeVisitor};
10-
use crate::TyDecoder;
11-
use crate::{HashStableContext, Interner, TyEncoder, UniverseIndex};
9+
use crate::{HashStableContext, Interner, UniverseIndex};
1210

1311
/// A "canonicalized" type `V` is one where all free inference
1412
/// variables have been rewritten to "canonical vars". These are
1513
/// numbered starting from 0 in order of first appearance.
1614
#[derive(derivative::Derivative)]
1715
#[derivative(Clone(bound = "V: Clone"), Hash(bound = "V: Hash"))]
16+
#[derive(TyEncodable, TyDecodable)]
1817
pub struct Canonical<I: Interner, V> {
1918
pub value: V,
2019
pub max_universe: UniverseIndex,
@@ -127,27 +126,3 @@ where
127126
self.variables.visit_with(folder)
128127
}
129128
}
130-
131-
impl<I: Interner, E: TyEncoder<I = I>, V: Encodable<E>> Encodable<E> for Canonical<I, V>
132-
where
133-
I::CanonicalVars: Encodable<E>,
134-
{
135-
fn encode(&self, s: &mut E) {
136-
self.value.encode(s);
137-
self.max_universe.encode(s);
138-
self.variables.encode(s);
139-
}
140-
}
141-
142-
impl<I: Interner, D: TyDecoder<I = I>, V: Decodable<D>> Decodable<D> for Canonical<I, V>
143-
where
144-
I::CanonicalVars: Decodable<D>,
145-
{
146-
fn decode(d: &mut D) -> Self {
147-
Canonical {
148-
value: Decodable::decode(d),
149-
max_universe: Decodable::decode(d),
150-
variables: Decodable::decode(d),
151-
}
152-
}
153-
}

‎compiler/rustc_type_ir/src/const_kind.rs

+2-66
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,8 @@
11
use rustc_data_structures::stable_hasher::HashStable;
22
use rustc_data_structures::stable_hasher::StableHasher;
3-
use rustc_serialize::{Decodable, Decoder, Encodable};
43
use std::fmt;
54

6-
use crate::{
7-
DebruijnIndex, DebugWithInfcx, HashStableContext, InferCtxtLike, Interner, TyDecoder,
8-
TyEncoder, WithInfcx,
9-
};
5+
use crate::{DebruijnIndex, DebugWithInfcx, HashStableContext, InferCtxtLike, Interner, WithInfcx};
106

117
use self::ConstKind::*;
128

@@ -20,6 +16,7 @@ use self::ConstKind::*;
2016
Ord = "feature_allow_slow_enum",
2117
Hash(bound = "")
2218
)]
19+
#[derive(TyEncodable, TyDecodable)]
2320
pub enum ConstKind<I: Interner> {
2421
/// A const generic parameter.
2522
Param(I::ParamConst),
@@ -92,67 +89,6 @@ where
9289
}
9390
}
9491

95-
impl<I: Interner, D: TyDecoder<I = I>> Decodable<D> for ConstKind<I>
96-
where
97-
I::ParamConst: Decodable<D>,
98-
I::InferConst: Decodable<D>,
99-
I::BoundConst: Decodable<D>,
100-
I::PlaceholderConst: Decodable<D>,
101-
I::AliasConst: Decodable<D>,
102-
I::ValueConst: Decodable<D>,
103-
I::ErrorGuaranteed: Decodable<D>,
104-
I::ExprConst: Decodable<D>,
105-
{
106-
fn decode(d: &mut D) -> Self {
107-
match Decoder::read_usize(d) {
108-
0 => Param(Decodable::decode(d)),
109-
1 => Infer(Decodable::decode(d)),
110-
2 => Bound(Decodable::decode(d), Decodable::decode(d)),
111-
3 => Placeholder(Decodable::decode(d)),
112-
4 => Unevaluated(Decodable::decode(d)),
113-
5 => Value(Decodable::decode(d)),
114-
6 => Error(Decodable::decode(d)),
115-
7 => Expr(Decodable::decode(d)),
116-
_ => panic!(
117-
"{}",
118-
format!(
119-
"invalid enum variant tag while decoding `{}`, expected 0..{}",
120-
"ConstKind", 8,
121-
)
122-
),
123-
}
124-
}
125-
}
126-
127-
impl<I: Interner, E: TyEncoder<I = I>> Encodable<E> for ConstKind<I>
128-
where
129-
I::ParamConst: Encodable<E>,
130-
I::InferConst: Encodable<E>,
131-
I::BoundConst: Encodable<E>,
132-
I::PlaceholderConst: Encodable<E>,
133-
I::AliasConst: Encodable<E>,
134-
I::ValueConst: Encodable<E>,
135-
I::ErrorGuaranteed: Encodable<E>,
136-
I::ExprConst: Encodable<E>,
137-
{
138-
fn encode(&self, e: &mut E) {
139-
let disc = const_kind_discriminant(self);
140-
match self {
141-
Param(p) => e.emit_enum_variant(disc, |e| p.encode(e)),
142-
Infer(i) => e.emit_enum_variant(disc, |e| i.encode(e)),
143-
Bound(d, b) => e.emit_enum_variant(disc, |e| {
144-
d.encode(e);
145-
b.encode(e);
146-
}),
147-
Placeholder(p) => e.emit_enum_variant(disc, |e| p.encode(e)),
148-
Unevaluated(u) => e.emit_enum_variant(disc, |e| u.encode(e)),
149-
Value(v) => e.emit_enum_variant(disc, |e| v.encode(e)),
150-
Error(er) => e.emit_enum_variant(disc, |e| er.encode(e)),
151-
Expr(ex) => e.emit_enum_variant(disc, |e| ex.encode(e)),
152-
}
153-
}
154-
}
155-
15692
impl<I: Interner> PartialEq for ConstKind<I> {
15793
fn eq(&self, other: &Self) -> bool {
15894
match (self, other) {

‎compiler/rustc_type_ir/src/lib.rs

+2
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,8 @@
1010
#![deny(rustc::diagnostic_outside_of_impl)]
1111
#![allow(internal_features)]
1212

13+
extern crate self as rustc_type_ir;
14+
1315
#[macro_use]
1416
extern crate bitflags;
1517
#[macro_use]

‎compiler/rustc_type_ir/src/predicate_kind.rs

+2-137
Original file line numberDiff line numberDiff line change
@@ -1,18 +1,16 @@
11
use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
2-
use rustc_serialize::Decoder;
3-
use rustc_serialize::{Decodable, Encodable};
42
use std::fmt;
53
use std::ops::ControlFlow;
64

75
use crate::fold::{FallibleTypeFolder, TypeFoldable};
86
use crate::visit::{TypeVisitable, TypeVisitor};
97
use crate::{HashStableContext, Interner};
10-
use crate::{TyDecoder, TyEncoder};
118

129
/// A clause is something that can appear in where bounds or be inferred
1310
/// by implied bounds.
1411
#[derive(derivative::Derivative)]
1512
#[derivative(Clone(bound = ""), Hash(bound = ""))]
13+
#[derive(TyEncodable, TyDecodable)]
1614
pub enum ClauseKind<I: Interner> {
1715
/// Corresponds to `where Foo: Bar<A, B, C>`. `Foo` here would be
1816
/// the `Self` type of the trait reference and `A`, `B`, and `C`
@@ -161,65 +159,9 @@ where
161159
}
162160
}
163161

164-
impl<I: Interner, D: TyDecoder<I = I>> Decodable<D> for ClauseKind<I>
165-
where
166-
I::Ty: Decodable<D>,
167-
I::Const: Decodable<D>,
168-
I::GenericArg: Decodable<D>,
169-
I::TraitPredicate: Decodable<D>,
170-
I::ProjectionPredicate: Decodable<D>,
171-
I::TypeOutlivesPredicate: Decodable<D>,
172-
I::RegionOutlivesPredicate: Decodable<D>,
173-
{
174-
fn decode(d: &mut D) -> Self {
175-
match Decoder::read_usize(d) {
176-
0 => ClauseKind::Trait(Decodable::decode(d)),
177-
1 => ClauseKind::RegionOutlives(Decodable::decode(d)),
178-
2 => ClauseKind::TypeOutlives(Decodable::decode(d)),
179-
3 => ClauseKind::Projection(Decodable::decode(d)),
180-
4 => ClauseKind::ConstArgHasType(Decodable::decode(d), Decodable::decode(d)),
181-
5 => ClauseKind::WellFormed(Decodable::decode(d)),
182-
6 => ClauseKind::ConstEvaluatable(Decodable::decode(d)),
183-
_ => panic!(
184-
"{}",
185-
format!(
186-
"invalid enum variant tag while decoding `{}`, expected 0..{}",
187-
"ClauseKind", 7,
188-
)
189-
),
190-
}
191-
}
192-
}
193-
194-
impl<I: Interner, E: TyEncoder> Encodable<E> for ClauseKind<I>
195-
where
196-
I::Ty: Encodable<E>,
197-
I::Const: Encodable<E>,
198-
I::GenericArg: Encodable<E>,
199-
I::TraitPredicate: Encodable<E>,
200-
I::ProjectionPredicate: Encodable<E>,
201-
I::TypeOutlivesPredicate: Encodable<E>,
202-
I::RegionOutlivesPredicate: Encodable<E>,
203-
{
204-
fn encode(&self, s: &mut E) {
205-
let discriminant = clause_kind_discriminant(self);
206-
match self {
207-
ClauseKind::Trait(p) => s.emit_enum_variant(discriminant, |s| p.encode(s)),
208-
ClauseKind::RegionOutlives(p) => s.emit_enum_variant(discriminant, |s| p.encode(s)),
209-
ClauseKind::TypeOutlives(p) => s.emit_enum_variant(discriminant, |s| p.encode(s)),
210-
ClauseKind::Projection(p) => s.emit_enum_variant(discriminant, |s| p.encode(s)),
211-
ClauseKind::ConstArgHasType(c, t) => s.emit_enum_variant(discriminant, |s| {
212-
c.encode(s);
213-
t.encode(s);
214-
}),
215-
ClauseKind::WellFormed(p) => s.emit_enum_variant(discriminant, |s| p.encode(s)),
216-
ClauseKind::ConstEvaluatable(p) => s.emit_enum_variant(discriminant, |s| p.encode(s)),
217-
}
218-
}
219-
}
220-
221162
#[derive(derivative::Derivative)]
222163
#[derivative(Clone(bound = ""), Hash(bound = ""))]
164+
#[derive(TyEncodable, TyDecodable)]
223165
pub enum PredicateKind<I: Interner> {
224166
/// Prove a clause
225167
Clause(ClauseKind<I>),
@@ -418,83 +360,6 @@ where
418360
}
419361
}
420362

421-
impl<I: Interner, D: TyDecoder<I = I>> Decodable<D> for PredicateKind<I>
422-
where
423-
I::DefId: Decodable<D>,
424-
I::Const: Decodable<D>,
425-
I::GenericArgs: Decodable<D>,
426-
I::Term: Decodable<D>,
427-
I::CoercePredicate: Decodable<D>,
428-
I::SubtypePredicate: Decodable<D>,
429-
I::ClosureKind: Decodable<D>,
430-
ClauseKind<I>: Decodable<D>,
431-
{
432-
fn decode(d: &mut D) -> Self {
433-
match Decoder::read_usize(d) {
434-
0 => PredicateKind::Clause(Decodable::decode(d)),
435-
1 => PredicateKind::ObjectSafe(Decodable::decode(d)),
436-
2 => PredicateKind::ClosureKind(
437-
Decodable::decode(d),
438-
Decodable::decode(d),
439-
Decodable::decode(d),
440-
),
441-
3 => PredicateKind::Subtype(Decodable::decode(d)),
442-
4 => PredicateKind::Coerce(Decodable::decode(d)),
443-
5 => PredicateKind::ConstEquate(Decodable::decode(d), Decodable::decode(d)),
444-
6 => PredicateKind::Ambiguous,
445-
7 => PredicateKind::AliasRelate(
446-
Decodable::decode(d),
447-
Decodable::decode(d),
448-
Decodable::decode(d),
449-
),
450-
_ => panic!(
451-
"{}",
452-
format!(
453-
"invalid enum variant tag while decoding `{}`, expected 0..{}",
454-
"PredicateKind", 8,
455-
)
456-
),
457-
}
458-
}
459-
}
460-
461-
impl<I: Interner, E: TyEncoder> Encodable<E> for PredicateKind<I>
462-
where
463-
I::DefId: Encodable<E>,
464-
I::Const: Encodable<E>,
465-
I::GenericArgs: Encodable<E>,
466-
I::Term: Encodable<E>,
467-
I::CoercePredicate: Encodable<E>,
468-
I::SubtypePredicate: Encodable<E>,
469-
I::ClosureKind: Encodable<E>,
470-
ClauseKind<I>: Encodable<E>,
471-
{
472-
fn encode(&self, s: &mut E) {
473-
let discriminant = predicate_kind_discriminant(self);
474-
match self {
475-
PredicateKind::Clause(c) => s.emit_enum_variant(discriminant, |s| c.encode(s)),
476-
PredicateKind::ObjectSafe(d) => s.emit_enum_variant(discriminant, |s| d.encode(s)),
477-
PredicateKind::ClosureKind(d, g, k) => s.emit_enum_variant(discriminant, |s| {
478-
d.encode(s);
479-
g.encode(s);
480-
k.encode(s);
481-
}),
482-
PredicateKind::Subtype(c) => s.emit_enum_variant(discriminant, |s| c.encode(s)),
483-
PredicateKind::Coerce(c) => s.emit_enum_variant(discriminant, |s| c.encode(s)),
484-
PredicateKind::ConstEquate(a, b) => s.emit_enum_variant(discriminant, |s| {
485-
a.encode(s);
486-
b.encode(s);
487-
}),
488-
PredicateKind::Ambiguous => s.emit_enum_variant(discriminant, |_s| {}),
489-
PredicateKind::AliasRelate(a, b, d) => s.emit_enum_variant(discriminant, |s| {
490-
a.encode(s);
491-
b.encode(s);
492-
d.encode(s);
493-
}),
494-
}
495-
}
496-
}
497-
498363
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Copy)]
499364
#[derive(HashStable_Generic, Encodable, Decodable)]
500365
pub enum AliasRelationDirection {

0 commit comments

Comments
 (0)