Split things out of representing types

Author: BoxyUwU

src/SUMMARY.md

@@ -134,14 +134,15 @@
 
 - [Prologue](./part-4-intro.md)
 - [Generic parameter definitions](./generic_parameters_summary.md)
+    - [`EarlyBinder` and instantiating parameters](./ty_module/early_binder.md)
+- [Binders and Higher ranked regions](./ty_module/binders.md)
+    - [Instantiating binders](./ty_module/instantiating_binders.md)
+- [Early vs Late bound parameters](./early_late_parameters_summary.md)
     - [Implementation nuances of early/late bound parameters](./early-late-bound-params/early-late-bound-implementation-nuances.md)
     - [Interactions with turbofishing](./early-late-bound-params/turbofishing-and-early-late-bound.md)
 - [The `ty` module: representing types](./ty.md)
     - [ADTs and Generic Arguments](./ty_module/generic_arguments.md)
     - [Parameter types/consts/regions](./ty_module/param_ty_const_regions.md)
-    - [`EarlyBinder` and instantiating parameters](./ty_module/early_binder.md)
-    - [`Binder` and Higher ranked regions](./ty_module/binders.md)
-    - [Instantiating binders](./ty_module/instantiating_binders.md)
 - [`TypeFolder` and `TypeFoldable`](./ty-fold.md)
 - [Parameter Environments](./param_env/param_env_summary.md)
     - [What is it?](./param_env/param_env_what_is_it.md)

src/early_late_parameters_summary.md

@@ -0,0 +1,39 @@
+
+# Early vs Late bound parameters
+
+
+```rust
+fn foo<'a, T>(b: &'a T) -> &'a T { b }
+//     ^^  ^early bound
+//     ^^
+//     ^^late bound
+```
+
+Generally when referring to an item with generic parameters you must specify a list of generic arguments corresponding to the item's generic parameters. In some cases it is permitted to elide these arguments but still, implicitly, a set of arguments are provided (e.g. `Vec::default()` desugars to `Vec::<_>::default()`).
+
+For functions this is not necessarily the case, for example if we take the function `foo` from the example above and write the following code:
+```rust
+fn main() {
+    let f = foo::<_>;
+
+    let b = String::new();
+    let c = String::new();
+    
+    f(&b);
+    drop(b);
+    f(&c);
+}
+```
+
+This code compiles perfectly fine even though there is no single lifetime that could possibly be specified in `foo::<_>` that would allow for both
+the `&b` and `&c` borrows to be used as arguments (note: the `drop(b)` line forces the `&b` borrow to be shorter than the `&c` borrow). This works because the `'a` lifetime is _late bound_.
+
+A generic parameter being late bound means that when we write `foo::<_>` we do not actually provide an argument for that parameter, instead we wait until _calling_ the function to provide the generic argument. In the above example this means that we are doing something like `f::<'_>(&b);` and `f::<'_>(&c);` (although in practice we do not actually support turbofishing late bound parameters in this manner)
+
+It may be helpful to think of "early bound parameter" or "late bound parameter" as meaning "early provided parameter" and "late provided parameter", i.e. we provide the argument to the parameter either early (when naming the function) or late (when calling it).
+
+Late bound parameters on functions are tracked with a [`Binder`] when accessing the signature of the function, this can be done with the [`fn_sig`] query. For more information of binders see the [chapter on `Binder`s ][ch_binders].
+
+[`Binder`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_type_ir/binder/struct.Binder.html
+[`fn_sig`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/context/struct.TyCtxt.html#method.fn_sig
+[ch_binders]: ./ty_module/binders.md

src/generic_parameters_summary.md

@@ -25,42 +25,4 @@ Interestingly, `ty::Generics` does not currently contain _every_ generic paramet
 [ch_representing_types]: ./ty.md
 [`ty::Generics`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.Generics.html
 [`GenericParamDef`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/generics/struct.GenericParamDef.html
-
-# Early vs Late bound parameters
-
-
-```rust
-fn foo<'a, T>(b: &'a T) -> &'a T { b }
-//     ^^  ^early bound
-//     ^^
-//     ^^late bound
-```
-
-Generally when referring to an item with generic parameters you must specify a list of generic arguments corresponding to the item's generic parameters. In some cases it is permitted to elide these arguments but still, implicitly, a set of arguments are provided (e.g. `Vec::default()` desugars to `Vec::<_>::default()`).
-
-For functions this is not necessarily the case, for example if we take the function `foo` from the example above and write the following code:
-```rust
-fn main() {
-    let f = foo::<_>;
-
-    let b = String::new();
-    let c = String::new();
-    
-    f(&b);
-    drop(b);
-    f(&c);
-}
-```
-
-This code compiles perfectly fine even though there is no single lifetime that could possibly be specified in `foo::<_>` that would allow for both
-the `&b` and `&c` borrows to be used as arguments (note: the `drop(b)` line forces the `&b` borrow to be shorter than the `&c` borrow). This works because the `'a` lifetime is _late bound_.
-
-A generic parameter being late bound means that when we write `foo::<_>` we do not actually provide an argument for that parameter, instead we wait until _calling_ the function to provide the generic argument. In the above example this means that we are doing something like `f::<'_>(&b);` and `f::<'_>(&c);` (although in practice we do not actually support turbofishing late bound parameters in this manner)
-
-It may be helpful to think of "early bound parameter" or "late bound parameter" as meaning "early provided parameter" and "late provided parameter", i.e. we provide the argument to the parameter either early (when naming the function) or late (when calling it).
-
-Late bound parameters on functions are tracked with a [`Binder`] when accessing the signature of the function, this can be done with the [`fn_sig`] query. For more information of binders see the [chapter on `Binder`s ][ch_binders].
-
-[`Binder`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_type_ir/binder/struct.Binder.html
-[`fn_sig`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/context/struct.TyCtxt.html#method.fn_sig
-[ch_binders]: ./ty_module/binders.md
+[ch_binders]: ./ty_module/binders.md

src/ty_module/early_binder.md

@@ -47,10 +47,10 @@ fn bar(foo: Foo<u32, f32>) {
 
 In the compiler the `instantiate` call for this is done in [`FieldDef::ty`] ([src][field_def_ty_src]), at some point during type checking `bar` we will wind up calling `FieldDef::ty(x, &[u32, f32])` in order to obtain the type of `foo.x`.
 
-**Note on indices:** It is possible for the indices in `Param` to not match with what the `EarlyBinder` binds. For
-example, the index could be out of bounds or it could be the index of a lifetime when we were expecting a type.
-These sorts of errors would be caught earlier in the compiler when translating from a `rustc_hir::Ty` to a `ty::Ty`.
-If they occur later, that is a compiler bug.
+**Note on indices:** It is a bug if the index of a `Param` does not match what the `EarlyBinder` binds. For
+example, if the index is out of bounds or the index index of a lifetime corresponds to a type parameter.
+These sorts of errors are caught earlier in the compiler during name resolution where we disallow references
+to generics parameters introduced by items that should not be nameable by the inner item. 
 
 [`FieldDef::ty`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.FieldDef.html#method.ty
 [field_def_ty_src]: https://github.com/rust-lang/rust/blob/44d679b9021f03a79133021b94e6d23e9b55b3ab/compiler/rustc_middle/src/ty/mod.rs#L1421-L1426