mirror
/
rustc-dev-guide
mirror of https://github.com/rust-lang/rustc-dev-guide.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

generic_arguments.md: substs -> GenericArgs 

See https://github.com/rust-lang/rust/pull/113591
This commit is contained in:
Mahdi Dibaiee 2023-07-14 21:16:48 +01:00 committed by Tshepang Mbambo
parent c514440e84
commit 6e6f620f83
1 changed files with 13 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/generic_arguments.md
View File

@ -1,28 +1,28 @@
# Generic arguments # Generic arguments
A `ty::subst::GenericArg<'tcx>` represents some entity in the type system: a type A `ty::GenericArg<'tcx>` represents some entity in the type system: a type
(`Ty<'tcx>`), lifetime (`ty::Region<'tcx>`) or constant (`ty::Const<'tcx>`). (`Ty<'tcx>`), lifetime (`ty::Region<'tcx>`) or constant (`ty::Const<'tcx>`).
`GenericArg` is used to perform substitutions of generic parameters for concrete `GenericArg` is used to perform instantiation of generic parameters to concrete
arguments, such as when calling a function with generic parameters explicitly arguments, such as when calling a function with generic parameters explicitly
with type arguments. Substitutions are represented using the with type arguments. Instantiations are represented using the
[`Subst` type](#subst) as described below. [`GenericArgs` type](#genericargs) as described below.
## `Subst` ## `GenericArgs`
`ty::subst::Subst<'tcx>` is intuitively simply a slice of `GenericArg<'tcx>`s, `ty::GenericArgs<'tcx>` is intuitively simply a slice of `GenericArg<'tcx>`s,
acting as an ordered list of substitutions from generic parameters to acting as an ordered list of generic parameters instantiated to
concrete arguments (such as types, lifetimes and consts). concrete arguments (such as types, lifetimes and consts).
For example, given a `HashMap<K, V>` with two type parameters, `K` and `V`, an For example, given a `HashMap<K, V>` with two type parameters, `K` and `V`, an
instantiation of the parameters, for example `HashMap<i32, u32>`, would be instantiation of the parameters, for example `HashMap<i32, u32>`, would be
represented by the substitution `&'tcx [tcx.types.i32, tcx.types.u32]`. represented by `&'tcx [tcx.types.i32, tcx.types.u32]`.
`Subst` provides various convenience methods to instantiate substitutions `GenericArgs` provides various convenience methods to instantiate generic arguments
given item definitions, which should generally be used rather than explicitly given item definitions, which should generally be used rather than explicitly
constructing such substitution slices. instantiating such slices.
## `GenericArg` ## `GenericArg`
The actual `GenericArg` struct is optimised for space, storing the type, lifetime or The actual `GenericArg` struct is optimised for space, storing the type, lifetime or
const as an interned pointer containing a tag identifying its kind (in the const as an interned pointer containing a tag identifying its kind (in the
lowest 2 bits). Unless you are working with the `Subst` implementation lowest 2 bits). Unless you are working with the `GenericArgs` implementation
specifically, you should generally not have to deal with `GenericArg` and instead specifically, you should generally not have to deal with `GenericArg` and instead
make use of the safe [`GenericArgKind`](#genericargkind) abstraction. make use of the safe [`GenericArgKind`](#genericargkind) abstraction.
@ -30,7 +30,7 @@ make use of the safe [`GenericArgKind`](#genericargkind) abstraction.
As `GenericArg` itself is not type-safe, the `GenericArgKind` enum provides a more As `GenericArg` itself is not type-safe, the `GenericArgKind` enum provides a more
convenient and safe interface for dealing with generic arguments. An convenient and safe interface for dealing with generic arguments. An
`GenericArgKind` can be converted to a raw `GenericArg` using `GenericArg::from()` `GenericArgKind` can be converted to a raw `GenericArg` using `GenericArg::from()`
(or simply `.into()` when the context is clear). As mentioned earlier, substitution (or simply `.into()` when the context is clear). As mentioned earlier, instantiation
lists store raw `GenericArg`s, so before dealing with them, it is preferable to lists store raw `GenericArg`s, so before dealing with them, it is preferable to
convert them to `GenericArgKind`s first. This is done by calling the `.unpack()` convert them to `GenericArgKind`s first. This is done by calling the `.unpack()`
method. method.
@ -44,7 +44,7 @@ fn deal_with_generic_arg<'tcx>(generic_arg: GenericArg<'tcx>) -> GenericArg<'tcx
GenericArgKind::Lifetime(lt) => { /* ... */ } GenericArgKind::Lifetime(lt) => { /* ... */ }
GenericArgKind::Const(ct) => { /* ... */ } GenericArgKind::Const(ct) => { /* ... */ }
}; };
// Pack the `GenericArgKind` to store it in a substitution list. // Pack the `GenericArgKind` to store it in a generic args list.
new_generic_arg.into() new_generic_arg.into()
} }
``` ```