Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit bee7b58

Browse files
compiler-errorscompiler-errors
committedNov 4, 2023
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

Lines changed: 20 additions & 10 deletions
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

Lines changed: 2 additions & 27 deletions
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

Lines changed: 2 additions & 66 deletions
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

Lines changed: 2 additions & 0 deletions
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

Lines changed: 2 additions & 137 deletions
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 {

‎compiler/rustc_type_ir/src/region_kind.rs

Lines changed: 2 additions & 71 deletions
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::RegionKind::*;
128

@@ -125,6 +121,7 @@ use self::RegionKind::*;
125121
Ord = "feature_allow_slow_enum",
126122
Hash(bound = "")
127123
)]
124+
#[derive(TyEncodable, TyDecodable)]
128125
pub enum RegionKind<I: Interner> {
129126
/// Region bound in a type or fn declaration which will be
130127
/// substituted 'early' -- that is, at the same time when type
@@ -245,72 +242,6 @@ impl<I: Interner> fmt::Debug for RegionKind<I> {
245242
}
246243
}
247244

248-
// This is manually implemented because a derive would require `I: Encodable`
249-
impl<I: Interner, E: TyEncoder<I = I>> Encodable<E> for RegionKind<I>
250-
where
251-
I::EarlyBoundRegion: Encodable<E>,
252-
I::BoundRegion: Encodable<E>,
253-
I::FreeRegion: Encodable<E>,
254-
I::InferRegion: Encodable<E>,
255-
I::PlaceholderRegion: Encodable<E>,
256-
{
257-
fn encode(&self, e: &mut E) {
258-
let disc = regionkind_discriminant(self);
259-
match self {
260-
ReEarlyBound(a) => e.emit_enum_variant(disc, |e| {
261-
a.encode(e);
262-
}),
263-
ReLateBound(a, b) => e.emit_enum_variant(disc, |e| {
264-
a.encode(e);
265-
b.encode(e);
266-
}),
267-
ReFree(a) => e.emit_enum_variant(disc, |e| {
268-
a.encode(e);
269-
}),
270-
ReStatic => e.emit_enum_variant(disc, |_| {}),
271-
ReVar(a) => e.emit_enum_variant(disc, |e| {
272-
a.encode(e);
273-
}),
274-
RePlaceholder(a) => e.emit_enum_variant(disc, |e| {
275-
a.encode(e);
276-
}),
277-
ReErased => e.emit_enum_variant(disc, |_| {}),
278-
ReError(_) => e.emit_enum_variant(disc, |_| {}),
279-
}
280-
}
281-
}
282-
283-
// This is manually implemented because a derive would require `I: Decodable`
284-
impl<I: Interner, D: TyDecoder<I = I>> Decodable<D> for RegionKind<I>
285-
where
286-
I::EarlyBoundRegion: Decodable<D>,
287-
I::BoundRegion: Decodable<D>,
288-
I::FreeRegion: Decodable<D>,
289-
I::InferRegion: Decodable<D>,
290-
I::PlaceholderRegion: Decodable<D>,
291-
I::ErrorGuaranteed: Decodable<D>,
292-
{
293-
fn decode(d: &mut D) -> Self {
294-
match Decoder::read_usize(d) {
295-
0 => ReEarlyBound(Decodable::decode(d)),
296-
1 => ReLateBound(Decodable::decode(d), Decodable::decode(d)),
297-
2 => ReFree(Decodable::decode(d)),
298-
3 => ReStatic,
299-
4 => ReVar(Decodable::decode(d)),
300-
5 => RePlaceholder(Decodable::decode(d)),
301-
6 => ReErased,
302-
7 => ReError(Decodable::decode(d)),
303-
_ => panic!(
304-
"{}",
305-
format!(
306-
"invalid enum variant tag while decoding `{}`, expected 0..{}",
307-
"RegionKind", 8,
308-
)
309-
),
310-
}
311-
}
312-
}
313-
314245
// This is not a derived impl because a derive would require `I: HashStable`
315246
impl<CTX: HashStableContext, I: Interner> HashStable<CTX> for RegionKind<I>
316247
where

‎compiler/rustc_type_ir/src/ty_kind.rs

Lines changed: 1 addition & 175 deletions
Original file line numberDiff line numberDiff line change
@@ -2,14 +2,11 @@
22

33
use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
44
use rustc_data_structures::unify::{EqUnifyValue, UnifyKey};
5-
use rustc_serialize::{Decodable, Decoder, Encodable};
65
use std::fmt;
76
use std::mem::discriminant;
87

98
use crate::HashStableContext;
109
use crate::Interner;
11-
use crate::TyDecoder;
12-
use crate::TyEncoder;
1310
use crate::{DebruijnIndex, DebugWithInfcx, InferCtxtLike, WithInfcx};
1411

1512
use self::TyKind::*;
@@ -122,6 +119,7 @@ pub enum AliasKind {
122119
Ord = "feature_allow_slow_enum",
123120
Hash(bound = "")
124121
)]
122+
#[derive(TyEncodable, TyDecodable)]
125123
pub enum TyKind<I: Interner> {
126124
/// The primitive boolean type. Written as `bool`.
127125
Bool,
@@ -472,178 +470,6 @@ impl<I: Interner> fmt::Debug for TyKind<I> {
472470
}
473471
}
474472

475-
// This is manually implemented because a derive would require `I: Encodable`
476-
impl<I: Interner, E: TyEncoder<I = I>> Encodable<E> for TyKind<I>
477-
where
478-
I::ErrorGuaranteed: Encodable<E>,
479-
I::AdtDef: Encodable<E>,
480-
I::GenericArgs: Encodable<E>,
481-
I::DefId: Encodable<E>,
482-
I::Ty: Encodable<E>,
483-
I::Const: Encodable<E>,
484-
I::Region: Encodable<E>,
485-
I::TypeAndMut: Encodable<E>,
486-
I::PolyFnSig: Encodable<E>,
487-
I::BoundExistentialPredicates: Encodable<E>,
488-
I::Tys: Encodable<E>,
489-
I::AliasTy: Encodable<E>,
490-
I::ParamTy: Encodable<E>,
491-
I::BoundTy: Encodable<E>,
492-
I::PlaceholderTy: Encodable<E>,
493-
I::InferTy: Encodable<E>,
494-
I::AllocId: Encodable<E>,
495-
{
496-
fn encode(&self, e: &mut E) {
497-
let disc = tykind_discriminant(self);
498-
match self {
499-
Bool => e.emit_enum_variant(disc, |_| {}),
500-
Char => e.emit_enum_variant(disc, |_| {}),
501-
Int(i) => e.emit_enum_variant(disc, |e| {
502-
i.encode(e);
503-
}),
504-
Uint(u) => e.emit_enum_variant(disc, |e| {
505-
u.encode(e);
506-
}),
507-
Float(f) => e.emit_enum_variant(disc, |e| {
508-
f.encode(e);
509-
}),
510-
Adt(adt, args) => e.emit_enum_variant(disc, |e| {
511-
adt.encode(e);
512-
args.encode(e);
513-
}),
514-
Foreign(def_id) => e.emit_enum_variant(disc, |e| {
515-
def_id.encode(e);
516-
}),
517-
Str => e.emit_enum_variant(disc, |_| {}),
518-
Array(t, c) => e.emit_enum_variant(disc, |e| {
519-
t.encode(e);
520-
c.encode(e);
521-
}),
522-
Slice(t) => e.emit_enum_variant(disc, |e| {
523-
t.encode(e);
524-
}),
525-
RawPtr(tam) => e.emit_enum_variant(disc, |e| {
526-
tam.encode(e);
527-
}),
528-
Ref(r, t, m) => e.emit_enum_variant(disc, |e| {
529-
r.encode(e);
530-
t.encode(e);
531-
m.encode(e);
532-
}),
533-
FnDef(def_id, args) => e.emit_enum_variant(disc, |e| {
534-
def_id.encode(e);
535-
args.encode(e);
536-
}),
537-
FnPtr(polyfnsig) => e.emit_enum_variant(disc, |e| {
538-
polyfnsig.encode(e);
539-
}),
540-
Dynamic(l, r, repr) => e.emit_enum_variant(disc, |e| {
541-
l.encode(e);
542-
r.encode(e);
543-
repr.encode(e);
544-
}),
545-
Closure(def_id, args) => e.emit_enum_variant(disc, |e| {
546-
def_id.encode(e);
547-
args.encode(e);
548-
}),
549-
Coroutine(def_id, args, m) => e.emit_enum_variant(disc, |e| {
550-
def_id.encode(e);
551-
args.encode(e);
552-
m.encode(e);
553-
}),
554-
CoroutineWitness(def_id, args) => e.emit_enum_variant(disc, |e| {
555-
def_id.encode(e);
556-
args.encode(e);
557-
}),
558-
Never => e.emit_enum_variant(disc, |_| {}),
559-
Tuple(args) => e.emit_enum_variant(disc, |e| {
560-
args.encode(e);
561-
}),
562-
Alias(k, p) => e.emit_enum_variant(disc, |e| {
563-
k.encode(e);
564-
p.encode(e);
565-
}),
566-
Param(p) => e.emit_enum_variant(disc, |e| {
567-
p.encode(e);
568-
}),
569-
Bound(d, b) => e.emit_enum_variant(disc, |e| {
570-
d.encode(e);
571-
b.encode(e);
572-
}),
573-
Placeholder(p) => e.emit_enum_variant(disc, |e| {
574-
p.encode(e);
575-
}),
576-
Infer(i) => e.emit_enum_variant(disc, |e| {
577-
i.encode(e);
578-
}),
579-
Error(d) => e.emit_enum_variant(disc, |e| {
580-
d.encode(e);
581-
}),
582-
}
583-
}
584-
}
585-
586-
// This is manually implemented because a derive would require `I: Decodable`
587-
impl<I: Interner, D: TyDecoder<I = I>> Decodable<D> for TyKind<I>
588-
where
589-
I::ErrorGuaranteed: Decodable<D>,
590-
I::AdtDef: Decodable<D>,
591-
I::GenericArgs: Decodable<D>,
592-
I::DefId: Decodable<D>,
593-
I::Ty: Decodable<D>,
594-
I::Const: Decodable<D>,
595-
I::Region: Decodable<D>,
596-
I::TypeAndMut: Decodable<D>,
597-
I::PolyFnSig: Decodable<D>,
598-
I::BoundExistentialPredicates: Decodable<D>,
599-
I::Tys: Decodable<D>,
600-
I::AliasTy: Decodable<D>,
601-
I::ParamTy: Decodable<D>,
602-
I::AliasTy: Decodable<D>,
603-
I::BoundTy: Decodable<D>,
604-
I::PlaceholderTy: Decodable<D>,
605-
I::InferTy: Decodable<D>,
606-
I::AllocId: Decodable<D>,
607-
{
608-
fn decode(d: &mut D) -> Self {
609-
match Decoder::read_usize(d) {
610-
0 => Bool,
611-
1 => Char,
612-
2 => Int(Decodable::decode(d)),
613-
3 => Uint(Decodable::decode(d)),
614-
4 => Float(Decodable::decode(d)),
615-
5 => Adt(Decodable::decode(d), Decodable::decode(d)),
616-
6 => Foreign(Decodable::decode(d)),
617-
7 => Str,
618-
8 => Array(Decodable::decode(d), Decodable::decode(d)),
619-
9 => Slice(Decodable::decode(d)),
620-
10 => RawPtr(Decodable::decode(d)),
621-
11 => Ref(Decodable::decode(d), Decodable::decode(d), Decodable::decode(d)),
622-
12 => FnDef(Decodable::decode(d), Decodable::decode(d)),
623-
13 => FnPtr(Decodable::decode(d)),
624-
14 => Dynamic(Decodable::decode(d), Decodable::decode(d), Decodable::decode(d)),
625-
15 => Closure(Decodable::decode(d), Decodable::decode(d)),
626-
16 => Coroutine(Decodable::decode(d), Decodable::decode(d), Decodable::decode(d)),
627-
17 => CoroutineWitness(Decodable::decode(d), Decodable::decode(d)),
628-
18 => Never,
629-
19 => Tuple(Decodable::decode(d)),
630-
20 => Alias(Decodable::decode(d), Decodable::decode(d)),
631-
21 => Param(Decodable::decode(d)),
632-
22 => Bound(Decodable::decode(d), Decodable::decode(d)),
633-
23 => Placeholder(Decodable::decode(d)),
634-
24 => Infer(Decodable::decode(d)),
635-
25 => Error(Decodable::decode(d)),
636-
_ => panic!(
637-
"{}",
638-
format!(
639-
"invalid enum variant tag while decoding `{}`, expected 0..{}",
640-
"TyKind", 26,
641-
)
642-
),
643-
}
644-
}
645-
}
646-
647473
// This is not a derived impl because a derive would require `I: HashStable`
648474
#[allow(rustc::usage_of_ty_tykind)]
649475
impl<CTX: HashStableContext, I: Interner> HashStable<CTX> for TyKind<I>

0 commit comments

Comments
 (0)
Please sign in to comment.