Skip to content

Commit 30134cf

Browse files
jackh726jackh726
committed
Remove TypeName
1 parent 30f4a12 commit 30134cf

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

43 files changed

+1421
-1247
lines changed

‎book/src/clauses/type_equality.md

Lines changed: 2 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -95,12 +95,10 @@ shortly.
9595

9696
In rustc, they correspond to the `TyVariableKind::UnnormalizedProjectionTy` enum
9797
variant, declared in [`compiler/rustc_middle/src/ty/sty.rs`][sty]. In chalk, we use an
98-
`ApplicationTy` with a name living in a special namespace dedicated to
99-
placeholder associated types (see the `TypeName` enum declared in
100-
[`chalk-ir/src/lib.rs`][chalk_type_name]).
98+
`Ty` with a name living in a special namespace dedicated to
99+
placeholder associated types.
101100

102101
[sty]: https://github.com/rust-lang/rust/blob/master/compiler/rustc_middle/src/ty/sty.rs
103-
[chalk_type_name]: https://github.com/rust-lang-nursery/chalk/blob/master/chalk-ir/src/lib.rs
104102

105103
## Projection equality
106104

‎book/src/types/rust_types.md

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1,17 +1,17 @@
11
# Rust types
22

3-
Rust types are represented by the [`Ty`] and [`TyKind`] types.
3+
Rust types are represented by the [`Ty`] and [`TyData`] types.
44
You use [`Ty`] to represent "some Rust type". But to actually inspect
55
what sort of type you have, you invoke the [`data`] method, which
6-
returns a [`TyKind`]. As described earlier, the actual in-memory
6+
returns a [`TyData`]. As described earlier, the actual in-memory
77
representation of types is controlled by the [`Interner`] trait.
88

99
[`Interner`]: http://rust-lang.github.io/chalk/chalk_ir/interner/trait.Interner.html
1010
[`Ty`]: http://rust-lang.github.io/chalk/chalk_ir/struct.Ty.html
11-
[`TyKind`]: http://rust-lang.github.io/chalk/chalk_ir/enum.TyKind.html
11+
[`TyData`]: http://rust-lang.github.io/chalk/chalk_ir/enum.TyData.html
1212
[`data`]: http://rust-lang.github.io/chalk/chalk_ir/struct.Ty.html#method.data
1313

14-
## The `TyKind` variants and how they map to Rust syntax
14+
## The `TyData` variants and how they map to Rust syntax
1515

1616
This section covers the variants we use to categorize types. We have
1717
endeavored to create a breakdown that simplifies the Rust "surface
@@ -31,7 +31,7 @@ differences in how they are handled.
3131

3232
## Justification for each variant
3333

34-
Each variant of `TyKind` generally wraps a single struct, which
34+
Each variant of `TyData` generally wraps a single struct, which
3535
represents a type known to be of that particular variant. This section
3636
goes through the variants in a bit more detail, and in particular
3737
describes why each variant exists.

‎chalk-engine/src/normalize_deep.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -107,7 +107,7 @@ where
107107
mod test {
108108
use super::*;
109109
use chalk_integration::interner::ChalkIr;
110-
use chalk_integration::{arg, ty, ty_name};
110+
use chalk_integration::{arg, ty};
111111

112112
const U0: UniverseIndex = UniverseIndex { counter: 0 };
113113

‎chalk-engine/src/slg.rs

Lines changed: 50 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -405,10 +405,6 @@ impl<I: Interner> MayInvalidate<'_, I> {
405405
);
406406
}
407407

408-
(TyKind::Apply(apply1), TyKind::Apply(apply2)) => {
409-
self.aggregate_application_tys(apply1, apply2)
410-
}
411-
412408
(TyKind::Placeholder(p1), TyKind::Placeholder(p2)) => {
413409
self.aggregate_placeholders(p1, p2)
414410
}
@@ -423,12 +419,56 @@ impl<I: Interner> MayInvalidate<'_, I> {
423419
TyKind::Alias(AliasTy::Opaque(opaque_ty2)),
424420
) => self.aggregate_opaque_ty_tys(opaque_ty1, opaque_ty2),
425421

426-
// For everything else, be conservative here and just say we may invalidate.
427-
(TyKind::Function(_), _)
428-
| (TyKind::Dyn(_), _)
429-
| (TyKind::Apply(_), _)
430-
| (TyKind::Placeholder(_), _)
431-
| (TyKind::Alias(_), _) => true,
422+
(TyKind::Adt(id_a, substitution_a), TyKind::Adt(id_b, substitution_b)) => {
423+
self.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
424+
}
425+
(
426+
TyKind::AssociatedType(id_a, substitution_a),
427+
TyKind::AssociatedType(id_b, substitution_b),
428+
) => self.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b),
429+
(TyKind::Scalar(scalar_a), TyKind::Scalar(scalar_b)) => scalar_a != scalar_b,
430+
(TyKind::Str, TyKind::Str) => false,
431+
(TyKind::Tuple(arity_a, substitution_a), TyKind::Tuple(arity_b, substitution_b)) => {
432+
self.aggregate_name_and_substs(arity_a, substitution_a, arity_b, substitution_b)
433+
}
434+
(
435+
TyKind::OpaqueType(id_a, substitution_a),
436+
TyKind::OpaqueType(id_b, substitution_b),
437+
) => self.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b),
438+
(TyKind::Slice(substitution_a), TyKind::Slice(substitution_b)) => substitution_a
439+
.iter(interner)
440+
.zip(substitution_b.iter(interner))
441+
.any(|(new, current)| self.aggregate_generic_args(new, current)),
442+
(TyKind::FnDef(id_a, substitution_a), TyKind::FnDef(id_b, substitution_b)) => {
443+
self.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
444+
}
445+
(TyKind::Ref(id_a, substitution_a), TyKind::Ref(id_b, substitution_b)) => {
446+
self.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
447+
}
448+
(TyKind::Raw(id_a, substitution_a), TyKind::Raw(id_b, substitution_b)) => {
449+
self.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
450+
}
451+
(TyKind::Never, TyKind::Never) => false,
452+
(TyKind::Array(substitution_a), TyKind::Array(substitution_b)) => substitution_a
453+
.iter(interner)
454+
.zip(substitution_b.iter(interner))
455+
.any(|(new, current)| self.aggregate_generic_args(new, current)),
456+
(TyKind::Closure(id_a, substitution_a), TyKind::Closure(id_b, substitution_b)) => {
457+
self.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
458+
}
459+
(TyKind::Generator(id_a, substitution_a), TyKind::Generator(id_b, substitution_b)) => {
460+
self.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
461+
}
462+
(
463+
TyKind::GeneratorWitness(id_a, substitution_a),
464+
TyKind::GeneratorWitness(id_b, substitution_b),
465+
) => self.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b),
466+
(TyKind::Foreign(id_a, substitution_a), TyKind::Foreign(id_b, substitution_b)) => {
467+
self.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
468+
}
469+
(TyKind::Error, TyKind::Error) => false,
470+
471+
(_, _) => true,
432472
}
433473
}
434474

@@ -484,28 +524,6 @@ impl<I: Interner> MayInvalidate<'_, I> {
484524
}
485525
}
486526

487-
fn aggregate_application_tys(
488-
&mut self,
489-
new: &ApplicationTy<I>,
490-
current: &ApplicationTy<I>,
491-
) -> bool {
492-
let ApplicationTy {
493-
name: new_name,
494-
substitution: new_substitution,
495-
} = new;
496-
let ApplicationTy {
497-
name: current_name,
498-
substitution: current_substitution,
499-
} = current;
500-
501-
self.aggregate_name_and_substs(
502-
new_name,
503-
new_substitution,
504-
current_name,
505-
current_substitution,
506-
)
507-
}
508-
509527
fn aggregate_placeholders(
510528
&mut self,
511529
new: &PlaceholderIndex,

‎chalk-engine/src/slg/aggregate.rs

Lines changed: 96 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -247,10 +247,6 @@ impl<I: Interner> AntiUnifier<'_, '_, I> {
247247
| (TyKind::Function(_), TyKind::Function(_))
248248
| (TyKind::Dyn(_), TyKind::Dyn(_)) => self.new_ty_variable(),
249249

250-
(TyKind::Apply(apply1), TyKind::Apply(apply2)) => {
251-
self.aggregate_application_tys(apply1, apply2)
252-
}
253-
254250
(
255251
TyKind::Alias(AliasTy::Projection(proj1)),
256252
TyKind::Alias(AliasTy::Projection(proj2)),
@@ -265,39 +261,104 @@ impl<I: Interner> AntiUnifier<'_, '_, I> {
265261
self.aggregate_placeholder_tys(placeholder1, placeholder2)
266262
}
267263

268-
// Mismatched base kinds.
269-
(TyKind::InferenceVar(_, _), _)
270-
| (TyKind::BoundVar(_), _)
271-
| (TyKind::Dyn(_), _)
272-
| (TyKind::Function(_), _)
273-
| (TyKind::Apply(_), _)
274-
| (TyKind::Alias(_), _)
275-
| (TyKind::Placeholder(_), _) => self.new_ty_variable(),
264+
(TyKind::Adt(id_a, substitution_a), TyKind::Adt(id_b, substitution_b)) => self
265+
.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
266+
.map(|(&name, substitution)| TyKind::Adt(name, substitution).intern(interner))
267+
.unwrap_or_else(|| self.new_ty_variable()),
268+
(
269+
TyKind::AssociatedType(id_a, substitution_a),
270+
TyKind::AssociatedType(id_b, substitution_b),
271+
) => self
272+
.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
273+
.map(|(&name, substitution)| {
274+
TyKind::AssociatedType(name, substitution).intern(interner)
275+
})
276+
.unwrap_or_else(|| self.new_ty_variable()),
277+
(TyKind::Scalar(scalar_a), TyKind::Scalar(scalar_b)) => {
278+
if scalar_a == scalar_b {
279+
TyKind::Scalar(*scalar_a).intern(interner)
280+
} else {
281+
self.new_ty_variable()
282+
}
283+
}
284+
(TyKind::Str, TyKind::Str) => TyKind::Str.intern(interner),
285+
(TyKind::Tuple(arity_a, substitution_a), TyKind::Tuple(arity_b, substitution_b)) => {
286+
self.aggregate_name_and_substs(arity_a, substitution_a, arity_b, substitution_b)
287+
.map(|(&name, substitution)| TyKind::Tuple(name, substitution).intern(interner))
288+
.unwrap_or_else(|| self.new_ty_variable())
289+
}
290+
(
291+
TyKind::OpaqueType(id_a, substitution_a),
292+
TyKind::OpaqueType(id_b, substitution_b),
293+
) => self
294+
.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
295+
.map(|(&name, substitution)| {
296+
TyKind::OpaqueType(name, substitution).intern(interner)
297+
})
298+
.unwrap_or_else(|| self.new_ty_variable()),
299+
(TyKind::Slice(substitution_a), TyKind::Slice(substitution_b)) => {
300+
let substitution = Substitution::from_iter(
301+
interner,
302+
substitution_a
303+
.iter(interner)
304+
.zip(substitution_b.iter(interner))
305+
.map(|(p1, p2)| self.aggregate_generic_args(p1, p2)),
306+
);
307+
TyKind::Slice(substitution).intern(interner)
308+
}
309+
(TyKind::FnDef(id_a, substitution_a), TyKind::FnDef(id_b, substitution_b)) => self
310+
.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
311+
.map(|(&name, substitution)| TyKind::FnDef(name, substitution).intern(interner))
312+
.unwrap_or_else(|| self.new_ty_variable()),
313+
(TyKind::Ref(id_a, substitution_a), TyKind::Ref(id_b, substitution_b)) => self
314+
.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
315+
.map(|(&name, substitution)| TyKind::Ref(name, substitution).intern(interner))
316+
.unwrap_or_else(|| self.new_ty_variable()),
317+
(TyKind::Raw(id_a, substitution_a), TyKind::Raw(id_b, substitution_b)) => self
318+
.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
319+
.map(|(&name, substitution)| TyKind::Raw(name, substitution).intern(interner))
320+
.unwrap_or_else(|| self.new_ty_variable()),
321+
(TyKind::Never, TyKind::Never) => TyKind::Never.intern(interner),
322+
(TyKind::Array(substitution_a), TyKind::Array(substitution_b)) => {
323+
let substitution = Substitution::from_iter(
324+
interner,
325+
substitution_a
326+
.iter(interner)
327+
.zip(substitution_b.iter(interner))
328+
.map(|(p1, p2)| self.aggregate_generic_args(p1, p2)),
329+
);
330+
TyKind::Array(substitution).intern(interner)
331+
}
332+
(TyKind::Closure(id_a, substitution_a), TyKind::Closure(id_b, substitution_b)) => self
333+
.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
334+
.map(|(&name, substitution)| TyKind::Closure(name, substitution).intern(interner))
335+
.unwrap_or_else(|| self.new_ty_variable()),
336+
(TyKind::Generator(id_a, substitution_a), TyKind::Generator(id_b, substitution_b)) => {
337+
self.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
338+
.map(|(&name, substitution)| {
339+
TyKind::Generator(name, substitution).intern(interner)
340+
})
341+
.unwrap_or_else(|| self.new_ty_variable())
342+
}
343+
(
344+
TyKind::GeneratorWitness(id_a, substitution_a),
345+
TyKind::GeneratorWitness(id_b, substitution_b),
346+
) => self
347+
.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
348+
.map(|(&name, substitution)| {
349+
TyKind::GeneratorWitness(name, substitution).intern(interner)
350+
})
351+
.unwrap_or_else(|| self.new_ty_variable()),
352+
(TyKind::Foreign(id_a, substitution_a), TyKind::Foreign(id_b, substitution_b)) => self
353+
.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
354+
.map(|(&name, substitution)| TyKind::Foreign(name, substitution).intern(interner))
355+
.unwrap_or_else(|| self.new_ty_variable()),
356+
(TyKind::Error, TyKind::Error) => TyKind::Error.intern(interner),
357+
358+
(_, _) => self.new_ty_variable(),
276359
}
277360
}
278361

279-
fn aggregate_application_tys(
280-
&mut self,
281-
apply1: &ApplicationTy<I>,
282-
apply2: &ApplicationTy<I>,
283-
) -> Ty<I> {
284-
let interner = self.interner;
285-
let ApplicationTy {
286-
name: name1,
287-
substitution: substitution1,
288-
} = apply1;
289-
let ApplicationTy {
290-
name: name2,
291-
substitution: substitution2,
292-
} = apply2;
293-
294-
self.aggregate_name_and_substs(name1, substitution1, name2, substitution2)
295-
.map(|(&name, substitution)| {
296-
TyKind::Apply(ApplicationTy { name, substitution }).intern(interner)
297-
})
298-
.unwrap_or_else(|| self.new_ty_variable())
299-
}
300-
301362
fn aggregate_placeholder_tys(
302363
&mut self,
303364
index1: &PlaceholderIndex,
@@ -501,7 +562,7 @@ impl<I: Interner> AntiUnifier<'_, '_, I> {
501562
#[cfg(test)]
502563
mod test {
503564
use crate::slg::aggregate::AntiUnifier;
504-
use chalk_integration::{arg, ty, ty_name};
565+
use chalk_integration::{arg, ty};
505566
use chalk_ir::UniverseIndex;
506567
use chalk_solve::infer::InferenceTable;
507568

0 commit comments

Comments
 (0)