Remove TyS

src/memory.md

@@ -16,18 +16,19 @@ types for equality: for each interned type `X`, we implemented [`PartialEq for
 X`][peqimpl], so we can just compare pointers. The [`CtxtInterners`] type
 contains a bunch of maps of interned types and the arena itself.
 
-[peqimpl]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TyS.html#implementations
+[peqimpl]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.Ty.html#implementations
 [`CtxtInterners`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.CtxtInterners.html#structfield.arena
 
-### Example: `ty::TyS`
+### Example: `ty::TyKind`
 
-Taking the example of [`ty::TyS`] which represents a type in the compiler (you
+Taking the example of [`ty::TyKind`] which represents a type in the compiler (you
 can read more [here](./ty.md)).  Each time we want to construct a type, the
 compiler doesn’t naively allocate from the buffer.  Instead, we check if that
 type was already constructed. If it was, we just get the same pointer we had
 before, otherwise we make a fresh pointer. With this schema if we want to know
 if two types are the same, all we need to do is compare the pointers which is
-efficient. `TyS` is carefully setup so you never construct them on the stack.
+efficient. `TyKind` should never be constructed on the stack, and it would be unusable
+if done so.
 You always allocate them from this arena and you always intern them so they are
 unique.
 
@@ -52,7 +53,7 @@ allocate, and which are found in this module. Here are a few examples:
 [`TraitRef`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TraitRef.html
 [`Predicate`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.Predicate.html
 
-[`ty::TyS`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TyS.html
+[`ty::TyKind`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/sty/type.TyKind.html
 
 ## The tcx and how it uses lifetimes
 

src/ty.md

@@ -119,23 +119,20 @@ or `fn(i32) -> i32` (with type aliases fully expanded).
 
 ## `ty::Ty` implementation
 
-[`rustc_middle::ty::Ty`][ty_ty] is actually a type alias to [`&TyS`][tys].
-This type, which is short for "Type Structure", is where the main functionality is located.
-You can ignore `TyS` struct in general; you will basically never access it explicitly.
-We always pass it by reference using the `Ty` alias.
-The only exception is to define inherent methods on types. In particular, `TyS` has a [`kind`][kind]
-field of type [`TyKind`][tykind], which represents the key type information. `TyKind` is a big enum
+[`rustc_middle::ty::Ty`][ty_ty] is actually a wrapper around
+[`Interned<WithCachedTypeInfo<TyKind>>`][tykind].
+You can ignore `Interned` in general; you will basically never access it explicitly.
+We always hide them within `Ty` and skip over it via `Deref` impls or methods.
+`TyKind` is a big enum
 with variants to represent many different Rust types
 (e.g. primitives, references, abstract data types, generics, lifetimes, etc).
-`TyS` also has 2 more fields, `flags` and `outer_exclusive_binder`. They
+`WithCachedTypeInfo` has a few cached values like `flags` and `outer_exclusive_binder`. They
 are convenient hacks for efficiency and summarize information about the type that we may want to
-know, but they don’t come into the picture as much here. Finally, `ty::TyS`s
-are [interned](./memory.md), so that the `ty::Ty` can be a thin pointer-like
+know, but they don’t come into the picture as much here. Finally, [`Interned`](./memory.md) allows
+the `ty::Ty` to be a thin pointer-like
 type. This allows us to do cheap comparisons for equality, along with the other
 benefits of interning.
 
-[tys]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TyS.html
-[kind]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TyS.html#structfield.kind
 [tykind]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/enum.TyKind.html
 
 ## Allocating and working with types