user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rollup merge of #152206 - tshepang:misc, r=davidtwco

Browse source 
misc doc improvements

These are things I collected as I was looking at code and docs
This commit is contained in:
Stuart Cook 2026-02-17 13:02:23 +11:00 • committed by GitHub
commit 910d4f4c09
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
7 changed files with 52 additions and 29 deletions
Download patch file Download diff file Expand all files Collapse all files

4
compiler/rustc_error_codes/src/error_codes/E0570.md
View file

@ -1,7 +1,7 @@
The requested ABI is unsupported by the current target.
The rust compiler maintains for each target a list of unsupported ABIs on
that target. If an ABI is present in such a list this usually means that the
The Rust compiler maintains a list of unsupported ABIs for each target.
If an ABI is present in such a list, this usually means that the
target / ABI combination is currently unsupported by llvm.
If necessary, you can circumvent this check using custom target specifications.

5
compiler/rustc_expand/src/config.rs
View file

@ -86,8 +86,7 @@ pub fn features(sess: &Session, krate_attrs: &[Attribute], crate_name: Symbol) -
if let Some(f) = REMOVED_LANG_FEATURES.iter().find(|f| name == f.feature.name) {
let pull_note = if let Some(pull) = f.pull {
format!(
"; see <https://github.com/rust-lang/rust/pull/{}> for more information",
pull
"; see <https://github.com/rust-lang/rust/pull/{pull}> for more information",
)
} else {
"".to_owned()
@ -123,7 +122,7 @@ pub fn features(sess: &Session, krate_attrs: &[Attribute], crate_name: Symbol) -
// If the enabled feature is unstable, record it.
if UNSTABLE_LANG_FEATURES.iter().find(|f| name == f.name).is_some() {
// When the ICE comes a standard library crate, there's a chance that the person
// When the ICE comes from a standard library crate, there's a chance that the person
// hitting the ICE may be using -Zbuild-std or similar with an untested target.
// The bug is probably in the standard library and not the compiler in that case,
// but that doesn't really matter - we want a bug report.

7
compiler/rustc_feature/src/unstable.rs
View file

@ -64,8 +64,6 @@ pub struct EnabledLibFeature {
}
impl Features {
/// `since` should be set for stable features that are nevertheless enabled with a `#[feature]`
/// attribute, indicating since when they are stable.
pub fn set_enabled_lang_feature(&mut self, lang_feat: EnabledLangFeature) {
self.enabled_lang_features.push(lang_feat);
self.enabled_features.insert(lang_feat.gate_name);
@ -781,8 +779,9 @@ impl Features {
}
}
/// Some features are not allowed to be used together at the same time, if
/// the two are present, produce an error.
/// Some features are not allowed to be used together at the same time.
///
/// If the two are present, produce an error.
pub const INCOMPATIBLE_FEATURES: &[(Symbol, Symbol)] = &[
// Experimental match ergonomics rulesets are incompatible with each other, to simplify the
// boolean logic required to tell which typing rules to use.

6
compiler/rustc_lint_defs/src/builtin.rs
View file

@ -3659,10 +3659,10 @@ declare_lint! {
/// `stdcall`, `fastcall`, and `cdecl` calling conventions (or their unwind
/// variants) on targets that cannot meaningfully be supported for the requested target.
///
/// For example `stdcall` does not make much sense for a x86_64 or, more apparently, powerpc
/// For example, `stdcall` does not make much sense for a x86_64 or, more apparently, powerpc
/// code, because this calling convention was never specified for those targets.
///
/// Historically MSVC toolchains have fallen back to the regular C calling convention for
/// Historically, MSVC toolchains have fallen back to the regular C calling convention for
/// targets other than x86, but Rust doesn't really see a similar need to introduce a similar
/// hack across many more targets.
///
@ -3689,7 +3689,7 @@ declare_lint! {
///
/// ### Explanation
///
/// On most of the targets the behaviour of `stdcall` and similar calling conventions is not
/// On most of the targets, the behaviour of `stdcall` and similar calling conventions is not
/// defined at all, but was previously accepted due to a bug in the implementation of the
/// compiler.
pub UNSUPPORTED_CALLING_CONVENTIONS,

13
compiler/rustc_type_ir/src/predicate.rs
View file

@ -42,7 +42,9 @@ where
}
}
/// A complete reference to a trait. These take numerous guises in syntax,
/// A complete reference to a trait.
///
/// These take numerous guises in syntax,
/// but perhaps the most recognizable form is in a where-clause:
/// ```ignore (illustrative)
/// T: Foo<U>
@ -241,7 +243,9 @@ impl ImplPolarity {
}
}
/// Polarity for a trait predicate. May either be negative or positive.
/// Polarity for a trait predicate.
///
/// May either be negative or positive.
/// Distinguished from [`ImplPolarity`] since we never compute goals with
/// "reservation" level.
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
@ -327,6 +331,7 @@ impl<I: Interner> ty::Binder<I, ExistentialPredicate<I>> {
}
/// An existential reference to a trait, where `Self` is erased.
///
/// For example, the trait object `Trait<'a, 'b, X, Y>` is:
/// ```ignore (illustrative)
/// exists T. T: Trait<'a, 'b, X, Y>
@ -442,6 +447,7 @@ impl<I: Interner> ExistentialProjection<I> {
}
/// Extracts the underlying existential trait reference from this projection.
///
/// For example, if this is a projection of `exists T. <T as Iterator>::Item == X`,
/// then this function would return an `exists T. T: Iterator` existential trait
/// reference.
@ -493,14 +499,17 @@ impl<I: Interner> ty::Binder<I, ExistentialProjection<I>> {
#[cfg_attr(feature = "nightly", derive(Encodable, Decodable, HashStable_NoContext))]
pub enum AliasTermKind {
/// A projection `<Type as Trait>::AssocType`.
///
/// Can get normalized away if monomorphic enough.
ProjectionTy,
/// An associated type in an inherent `impl`
InherentTy,
/// An opaque type (usually from `impl Trait` in type aliases or function return types)
///
/// Can only be normalized away in PostAnalysis mode or its defining scope.
OpaqueTy,
/// A free type alias that actually checks its trait bounds.
///
/// Currently only used if the type alias references opaque types.
/// Can always be normalized away.
FreeTy,

34
compiler/rustc_type_ir/src/ty_kind.rs
View file

@ -29,14 +29,17 @@ mod closure;
)]
pub enum AliasTyKind {
/// A projection `<Type as Trait>::AssocType`.
///
/// Can get normalized away if monomorphic enough.
Projection,
/// An associated type in an inherent `impl`
Inherent,
/// An opaque type (usually from `impl Trait` in type aliases or function return types)
///
/// Can only be normalized away in PostAnalysis mode or its defining scope.
Opaque,
/// A type alias that actually checks its trait bounds.
///
/// Currently only used if the type alias references opaque types.
/// Can always be normalized away.
Free,
@ -99,7 +102,9 @@ pub enum TyKind<I: Interner> {
/// An array with the given length. Written as `[T; N]`.
Array(I::Ty, I::Const),
/// A pattern newtype. Takes any type and restricts its valid values to its pattern.
/// A pattern newtype.
///
/// Takes any type and restricts its valid values to its pattern.
/// This will also change the layout to take advantage of this restriction.
/// Only `Copy` and `Clone` will automatically get implemented for pattern types.
/// Auto-traits treat this as if it were an aggregate with a single nested type.
@ -116,8 +121,9 @@ pub enum TyKind<I: Interner> {
/// `&'a mut T` or `&'a T`.
Ref(I::Region, I::Ty, Mutability),
/// The anonymous type of a function declaration/definition. Each
/// function has a unique type.
/// The anonymous type of a function declaration/definition.
///
/// Each function has a unique type.
///
/// For the function `fn foo() -> i32 { 3 }` this type would be
/// shown to the user as `fn() -> i32 {foo}`.
@ -129,7 +135,9 @@ pub enum TyKind<I: Interner> {
/// ```
FnDef(I::FunctionId, I::GenericArgs),
/// A pointer to a function. Written as `fn() -> i32`.
/// A pointer to a function.
///
/// Written as `fn() -> i32`.
///
/// Note that both functions and closures start out as either
/// [FnDef] or [Closure] which can be then be coerced to this variant.
@ -179,6 +187,7 @@ pub enum TyKind<I: Interner> {
Coroutine(I::CoroutineId, I::GenericArgs),
/// A type representing the types stored inside a coroutine.
///
/// This should only appear as part of the `CoroutineArgs`.
///
/// Unlike upvars, the witness can reference lifetimes from
@ -210,6 +219,7 @@ pub enum TyKind<I: Interner> {
Tuple(I::Tys),
/// A projection, opaque type, free type alias, or inherent associated type.
///
/// All of these types are represented as pairs of def-id and args, and can
/// be normalized, so they are grouped conceptually.
Alias(AliasTyKind, AliasTy<I>),
@ -253,8 +263,9 @@ pub enum TyKind<I: Interner> {
/// inside of the type.
Infer(InferTy),
/// A placeholder for a type which could not be computed; this is
/// propagated to avoid useless error messages.
/// A placeholder for a type which could not be computed.
///
/// This is propagated to avoid useless error messages.
Error(I::ErrorGuaranteed),
}
@ -282,7 +293,9 @@ impl<I: Interner> TyKind<I> {
}
/// Returns `true` when the outermost type cannot be further normalized,
/// resolved, or instantiated. This includes all primitive types, but also
/// resolved, or instantiated.
///
/// This includes all primitive types, but also
/// things like ADTs and trait objects, since even if their arguments or
/// nested types may be further simplified, the outermost [`ty::TyKind`] or
/// type constructor remains the same.
@ -481,6 +494,7 @@ impl<I: Interner> AliasTy<I> {
}
/// Extracts the underlying trait reference and own args from this projection.
///
/// For example, if this is a projection of `<T as StreamingIterator>::Item<'a>`,
/// then this function would return a `T: StreamingIterator` trait reference and
/// `['a]` as the own args.
@ -490,6 +504,7 @@ impl<I: Interner> AliasTy<I> {
}
/// Extracts the underlying trait reference from this projection.
///
/// For example, if this is a projection of `<T as Iterator>::Item`,
/// then this function would return a `T: Iterator` trait reference.
///
@ -593,8 +608,9 @@ pub enum InferTy {
FloatVar(FloatVid),
/// A [`FreshTy`][Self::FreshTy] is one that is generated as a replacement
/// for an unbound type variable. This is convenient for caching etc. See
/// `TypeFreshener` for more details.
/// for an unbound type variable.
///
/// This is convenient for caching etc. See `TypeFreshener` for more details.
///
/// Compare with [`TyVar`][Self::TyVar].
FreshTy(u32),