mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fix typos “a”→“an”

Browse Source
This commit is contained in:
Frank Steffahn 2021-08-22 14:46:15 +02:00
parent 2ad56d5c90
commit bf88b113ea
99 changed files with 157 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
compiler/rustc_ast/src/token.rs
View File

@ -495,7 +495,7 @@ pub fn is_lifetime(&self) -> bool {
self.lifetime().is_some()
}
/// Returns `true` if the token is a identifier whose name is the given
/// Returns `true` if the token is an identifier whose name is the given
/// string slice.
pub fn is_ident_named(&self, name: Symbol) -> bool {
self.ident().map_or(false, |(ident, _)| ident.name == name)

4
compiler/rustc_ast_lowering/src/lib.rs
View File

@ -1265,7 +1265,7 @@ fn lower_generic_arg(
ty,
);
// Construct a AnonConst where the expr is the "ty"'s path.
// Construct an AnonConst where the expr is the "ty"'s path.
let parent_def_id = self.current_hir_id_owner.0;
let node_id = self.resolver.next_node_id();
@ -2690,7 +2690,7 @@ fn elided_ref_lifetime(&mut self, span: Span) -> hir::Lifetime {
}
/// Report an error on illegal use of `'_` or a `&T` with no explicit lifetime;
/// return a "error lifetime".
/// return an "error lifetime".
fn new_error_lifetime(&mut self, id: Option<NodeId>, span: Span) -> hir::Lifetime {
let (id, msg, label) = match id {
Some(id) => (id, "`'_` cannot be used here", "`'_` is a reserved lifetime name"),

2
compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
View File

@ -1700,7 +1700,7 @@ pub fn cs_fold<F>(
/// One or more fields: call the base case function on the first value (which depends on
/// `use_fold`), and use that as the base case. Then perform `cs_fold` on the remainder of the
/// fields.
/// When the `substructure` is a `EnumNonMatchingCollapsed`, the result of `enum_nonmatch_f`
/// When the `substructure` is an `EnumNonMatchingCollapsed`, the result of `enum_nonmatch_f`
/// is returned. Statics may not be folded over.
/// See `cs_op` in `partial_ord.rs` for a model example.
pub fn cs_fold1<F, B>(

2
compiler/rustc_codegen_llvm/src/intrinsic.rs
View File

@ -137,7 +137,7 @@ fn codegen_intrinsic_call(
match scalar.value {
Primitive::Int(..) => {
if self.cx().size_of(ret_ty).bytes() < 4 {
// `va_arg` should not be called on a integer type
// `va_arg` should not be called on an integer type
// less than 4 bytes in length. If it is, promote
// the integer to a `i32` and truncate the result
// back to the smaller type.

2
compiler/rustc_codegen_ssa/src/mir/rvalue.rs
View File

@ -901,7 +901,7 @@ fn cast_float_to_int<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
//
// Performance note: Unordered comparison can be lowered to a "flipped"
// comparison and a negation, and the negation can be merged into the
// select. Therefore, it not necessarily any more expensive than a
// select. Therefore, it not necessarily any more expensive than an
// ordered ("normal") comparison. Whether these optimizations will be
// performed is ultimately up to the backend, but at least x86 does
// perform them.

48
compiler/rustc_data_structures/src/owning_ref/mod.rs
View File

@ -321,7 +321,7 @@ pub unsafe trait IntoErasedSendSync<'a> {
/////////////////////////////////////////////////////////////////////////////
impl<O, T: ?Sized> OwningRef<O, T> {
/// Creates a new owning reference from a owner
/// Creates a new owning reference from an owner
/// initialized to the direct dereference of it.
///
/// # Example
@ -368,7 +368,7 @@ pub unsafe fn new_assert_stable_address(o: O) -> Self
/// fn main() {
/// let owning_ref = OwningRef::new(Box::new([1, 2, 3, 4]));
///
/// // create a owning reference that points at the
/// // create an owning reference that points at the
/// // third element of the array.
/// let owning_ref = owning_ref.map(|array| &array[2]);
/// assert_eq!(*owning_ref, 3);
@ -396,7 +396,7 @@ pub fn map<F, U: ?Sized>(self, f: F) -> OwningRef<O, U>
/// fn main() {
/// let owning_ref = OwningRef::new(Box::new([1, 2, 3, 4]));
///
/// // create a owning reference that points at the
/// // create an owning reference that points at the
/// // third element of the array.
/// let owning_ref = owning_ref.try_map(|array| {
/// if array[2] == 3 { Ok(&array[2]) } else { Err(()) }
@ -430,7 +430,7 @@ pub unsafe fn map_owner<F, P>(self, f: F) -> OwningRef<P, T>
/// in an additional `Box<O>`.
///
/// This can be used to safely erase the owner of any `OwningRef<O, T>`
/// to a `OwningRef<Box<Erased>, T>`.
/// to an `OwningRef<Box<Erased>, T>`.
pub fn map_owner_box(self) -> OwningRef<Box<O>, T> {
OwningRef { reference: self.reference, owner: Box::new(self.owner) }
}
@ -511,7 +511,7 @@ pub fn into_inner(self) -> O {
}
impl<O, T: ?Sized> OwningRefMut<O, T> {
/// Creates a new owning reference from a owner
/// Creates a new owning reference from an owner
/// initialized to the direct dereference of it.
///
/// # Example
@ -558,7 +558,7 @@ pub unsafe fn new_assert_stable_address(mut o: O) -> Self
/// fn main() {
/// let owning_ref_mut = OwningRefMut::new(Box::new([1, 2, 3, 4]));
///
/// // create a owning reference that points at the
/// // create an owning reference that points at the
/// // third element of the array.
/// let owning_ref = owning_ref_mut.map(|array| &array[2]);
/// assert_eq!(*owning_ref, 3);
@ -586,7 +586,7 @@ pub fn map<F, U: ?Sized>(mut self, f: F) -> OwningRef<O, U>
/// fn main() {
/// let owning_ref_mut = OwningRefMut::new(Box::new([1, 2, 3, 4]));
///
/// // create a owning reference that points at the
/// // create an owning reference that points at the
/// // third element of the array.
/// let owning_ref_mut = owning_ref_mut.map_mut(|array| &mut array[2]);
/// assert_eq!(*owning_ref_mut, 3);
@ -614,7 +614,7 @@ pub fn map_mut<F, U: ?Sized>(mut self, f: F) -> OwningRefMut<O, U>
/// fn main() {
/// let owning_ref_mut = OwningRefMut::new(Box::new([1, 2, 3, 4]));
///
/// // create a owning reference that points at the
/// // create an owning reference that points at the
/// // third element of the array.
/// let owning_ref = owning_ref_mut.try_map(|array| {
/// if array[2] == 3 { Ok(&array[2]) } else { Err(()) }
@ -644,7 +644,7 @@ pub fn try_map<F, U: ?Sized, E>(mut self, f: F) -> Result<OwningRef<O, U>, E>
/// fn main() {
/// let owning_ref_mut = OwningRefMut::new(Box::new([1, 2, 3, 4]));
///
/// // create a owning reference that points at the
/// // create an owning reference that points at the
/// // third element of the array.
/// let owning_ref_mut = owning_ref_mut.try_map_mut(|array| {
/// if array[2] == 3 { Ok(&mut array[2]) } else { Err(()) }
@ -678,7 +678,7 @@ pub unsafe fn map_owner<F, P>(self, f: F) -> OwningRefMut<P, T>
/// in an additional `Box<O>`.
///
/// This can be used to safely erase the owner of any `OwningRefMut<O, T>`
/// to a `OwningRefMut<Box<Erased>, T>`.
/// to an `OwningRefMut<Box<Erased>, T>`.
pub fn map_owner_box(self) -> OwningRefMut<Box<O>, T> {
OwningRefMut { reference: self.reference, owner: Box::new(self.owner) }
}
@ -970,7 +970,7 @@ fn from(other: OwningRefMut<O, T>) -> Self {
}
}
// ^ FIXME: Is a Into impl for calling into_inner() possible as well?
// ^ FIXME: Is an Into impl for calling into_inner() possible as well?
impl<O, T: ?Sized> Debug for OwningRef<O, T>
where
@ -1139,27 +1139,27 @@ unsafe fn to_handle_mut(x: *const Self) -> Self::HandleMut {
// about which handle creation to use (i.e., read() vs try_read()) as well as
// what to do with error results.
/// Typedef of a owning reference that uses a `Box` as the owner.
/// Typedef of an owning reference that uses a `Box` as the owner.
pub type BoxRef<T, U = T> = OwningRef<Box<T>, U>;
/// Typedef of a owning reference that uses a `Vec` as the owner.
/// Typedef of an owning reference that uses a `Vec` as the owner.
pub type VecRef<T, U = T> = OwningRef<Vec<T>, U>;
/// Typedef of a owning reference that uses a `String` as the owner.
/// Typedef of an owning reference that uses a `String` as the owner.
pub type StringRef = OwningRef<String, str>;
/// Typedef of a owning reference that uses a `Rc` as the owner.
/// Typedef of an owning reference that uses a `Rc` as the owner.
pub type RcRef<T, U = T> = OwningRef<Rc<T>, U>;
/// Typedef of a owning reference that uses a `Arc` as the owner.
/// Typedef of an owning reference that uses a `Arc` as the owner.
pub type ArcRef<T, U = T> = OwningRef<Arc<T>, U>;
/// Typedef of a owning reference that uses a `Ref` as the owner.
/// Typedef of an owning reference that uses a `Ref` as the owner.
pub type RefRef<'a, T, U = T> = OwningRef<Ref<'a, T>, U>;
/// Typedef of a owning reference that uses a `RefMut` as the owner.
/// Typedef of an owning reference that uses a `RefMut` as the owner.
pub type RefMutRef<'a, T, U = T> = OwningRef<RefMut<'a, T>, U>;
/// Typedef of a owning reference that uses a `MutexGuard` as the owner.
/// Typedef of an owning reference that uses a `MutexGuard` as the owner.
pub type MutexGuardRef<'a, T, U = T> = OwningRef<MutexGuard<'a, T>, U>;
/// Typedef of a owning reference that uses a `RwLockReadGuard` as the owner.
/// Typedef of an owning reference that uses a `RwLockReadGuard` as the owner.
pub type RwLockReadGuardRef<'a, T, U = T> = OwningRef<RwLockReadGuard<'a, T>, U>;
/// Typedef of a owning reference that uses a `RwLockWriteGuard` as the owner.
/// Typedef of an owning reference that uses a `RwLockWriteGuard` as the owner.
pub type RwLockWriteGuardRef<'a, T, U = T> = OwningRef<RwLockWriteGuard<'a, T>, U>;
/// Typedef of a mutable owning reference that uses a `Box` as the owner.
@ -1219,11 +1219,11 @@ fn into_erased_send_sync(self) -> Self::Erased {
}
}
/// Typedef of a owning reference that uses an erased `Box` as the owner.
/// Typedef of an owning reference that uses an erased `Box` as the owner.
pub type ErasedBoxRef<U> = OwningRef<Box<dyn Erased>, U>;
/// Typedef of a owning reference that uses an erased `Rc` as the owner.
/// Typedef of an owning reference that uses an erased `Rc` as the owner.
pub type ErasedRcRef<U> = OwningRef<Rc<dyn Erased>, U>;
/// Typedef of a owning reference that uses an erased `Arc` as the owner.
/// Typedef of an owning reference that uses an erased `Arc` as the owner.
pub type ErasedArcRef<U> = OwningRef<Arc<dyn Erased>, U>;
/// Typedef of a mutable owning reference that uses an erased `Box` as the owner.

2
compiler/rustc_data_structures/src/profiling.rs
View File

@ -220,7 +220,7 @@ pub fn verbose_generic_activity<'a>(
VerboseTimingGuard::start(message, self.generic_activity(event_label))
}
/// Start profiling a extra verbose generic activity. Profiling continues until the
/// Start profiling an extra verbose generic activity. Profiling continues until the
/// VerboseTimingGuard returned from this call is dropped. In addition to recording
/// a measureme event, "extra verbose" generic activities also print a timing entry to
/// stdout if the compiler is invoked with -Ztime-passes.

2
compiler/rustc_data_structures/src/sync.rs
View File

@ -14,7 +14,7 @@
//!
//! `MTRef` is an immutable reference if cfg!(parallel_compiler), and a mutable reference otherwise.
//!
//! `rustc_erase_owner!` erases a OwningRef owner into Erased or Erased + Send + Sync
//! `rustc_erase_owner!` erases an OwningRef owner into Erased or Erased + Send + Sync
//! depending on the value of cfg!(parallel_compiler).
use crate::owning_ref::{Erased, OwningRef};

2
compiler/rustc_data_structures/src/tiny_list.rs
View File

@ -5,7 +5,7 @@
//!
//! - If you have a list that rarely stores more than one element, then this
//! data-structure can store the element without allocating and only uses as
//! much space as a `Option<(T, usize)>`. If T can double as the `Option`
//! much space as an `Option<(T, usize)>`. If T can double as the `Option`
//! discriminant, it will even only be as large as `T, usize`.
//!
//! If you expect to store more than 1 element in the common case, steer clear

2
compiler/rustc_hir/src/hir.rs
View File

@ -2323,7 +2323,7 @@ pub enum TyKind<'hir> {
///
/// Type parameters may be stored in each `PathSegment`.
Path(QPath<'hir>),
/// A opaque type definition itself. This is currently only used for the
/// An opaque type definition itself. This is currently only used for the
/// `opaque type Foo: Trait` item that `impl Trait` in desugars to.
///
/// The generic argument list contains the lifetimes (and in the future

2
compiler/rustc_hir/src/intravisit.rs
View File

@ -313,7 +313,7 @@ fn visit_body(&mut self, b: &'v Body<'v>) {
}
/// When invoking `visit_all_item_likes()`, you need to supply an
/// item-like visitor. This method converts a "intra-visit"
/// item-like visitor. This method converts an "intra-visit"
/// visitor into an item-like visitor that walks the entire tree.
/// If you use this, you probably don't want to process the
/// contents of nested item-like things, since the outer loop will

2
compiler/rustc_infer/src/infer/error_reporting/mod.rs
View File

@ -1697,7 +1697,7 @@ enum Mismatch<'a> {
}
// In some (most?) cases cause.body_id points to actual body, but in some cases
// it's a actual definition. According to the comments (e.g. in
// it's an actual definition. According to the comments (e.g. in
// librustc_typeck/check/compare_method.rs:compare_predicate_entailment) the latter
// is relied upon by some other code. This might (or might not) need cleanup.
let body_owner_def_id =

2
compiler/rustc_infer/src/infer/nll_relate/mod.rs
View File

@ -389,7 +389,7 @@ fn generalize_value<T: Relate<'tcx>>(
}
}
/// When we instantiate a inference variable with a value in
/// When we instantiate an inference variable with a value in
/// `relate_ty_var`, we always have the pair of a `TyVid` and a `Ty`,
/// but the ordering may vary (depending on whether the inference
/// variable was found on the `a` or `b` sides). Therefore, this trait

2
compiler/rustc_infer/src/infer/region_constraints/mod.rs
View File

@ -186,7 +186,7 @@ pub enum GenericKind<'tcx> {
/// ('a: min) || ('b: min)
/// }
///
/// This is described with a `AnyRegion('a, 'b)` node.
/// This is described with an `AnyRegion('a, 'b)` node.
#[derive(Debug, Clone)]
pub enum VerifyBound<'tcx> {
/// Given a kind K and a bound B, expands to a function like the

2
compiler/rustc_infer/src/traits/mod.rs
View File

@ -28,7 +28,7 @@
pub use rustc_middle::traits::*;
/// An `Obligation` represents some trait reference (e.g., `i32: Eq`) for
/// which the "impl_source" must be found. The process of finding a "impl_source" is
/// which the "impl_source" must be found. The process of finding an "impl_source" is
/// called "resolving" the `Obligation`. This process consists of
/// either identifying an `impl` (e.g., `impl Eq for i32`) that
/// satisfies the obligation, or else finding a bound that is in

2
compiler/rustc_lint/src/types.rs
View File

@ -1171,7 +1171,7 @@ fn visit_ty(&mut self, ty: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
ty::Projection(..) => {
let ty = self.cx.tcx.normalize_erasing_regions(self.cx.param_env, ty);
// If `ty` is a opaque type directly then `super_visit_with` won't invoke
// If `ty` is an opaque type directly then `super_visit_with` won't invoke
// this function again.
if ty.has_opaque_types() {
self.visit_ty(ty)

2
compiler/rustc_metadata/src/creader.rs
View File

@ -308,7 +308,7 @@ fn existing_match(&self, name: Symbol, hash: Option<Svh>, kind: PathKind) -> Opt
}
// Alright, so we've gotten this far which means that `data` has the
// right name, we don't have a hash, and we don't have a --extern
// right name, we don't have a hash, and we don't have an --extern
// pointing for ourselves. We're still not quite yet done because we
// have to make sure that this crate was found in the crate lookup
// path (this is a top-level dependency) as we don't want to

2
compiler/rustc_middle/src/hir/map/blocks.rs
View File

@ -63,7 +63,7 @@ fn is_fn_like(&self) -> bool {
}
}
/// Carries either an FnLikeNode or a Expr, as these are the two
/// Carries either an FnLikeNode or an Expr, as these are the two
/// constructs that correspond to "code" (as in, something from which
/// we can construct a control-flow graph).
#[derive(Copy, Clone)]

2
compiler/rustc_middle/src/middle/region.rs
View File

@ -151,7 +151,7 @@ pub struct FirstStatementIndex {
static_assert_size!(ScopeData, 4);
impl Scope {
/// Returns a item-local ID associated with this scope.
/// Returns an item-local ID associated with this scope.
///
/// N.B., likely to be replaced as API is refined; e.g., pnkfelix
/// anticipates `fn entry_node_id` and `fn each_exit_node_id`.

2
compiler/rustc_middle/src/mir/interpret/error.rs
View File

@ -46,7 +46,7 @@ pub fn struct_error<'tcx>(tcx: TyCtxtAt<'tcx>, msg: &str) -> DiagnosticBuilder<'
/// Packages the kind of error we got from the const code interpreter
/// up with a Rust-level backtrace of where the error occurred.
/// These should always be constructed by calling `.into()` on
/// a `InterpError`. In `rustc_mir::interpret`, we have `throw_err_*`
/// an `InterpError`. In `rustc_mir::interpret`, we have `throw_err_*`
/// macros for this.
#[derive(Debug)]
pub struct InterpErrorInfo<'tcx>(Box<InterpErrorInfoInner<'tcx>>);

4
compiler/rustc_middle/src/mir/interpret/value.rs
View File

@ -17,7 +17,7 @@
/// Represents the result of const evaluation via the `eval_to_allocation` query.
#[derive(Copy, Clone, HashStable, TyEncodable, TyDecodable, Debug, Hash, Eq, PartialEq)]
pub struct ConstAlloc<'tcx> {
// the value lives here, at offset 0, and that allocation definitely is a `AllocKind::Memory`
// the value lives here, at offset 0, and that allocation definitely is an `AllocKind::Memory`
// (so you can use `AllocMap::unwrap_memory`).
pub alloc_id: AllocId,
pub ty: Ty<'tcx>,
@ -113,7 +113,7 @@ pub fn from_machine_usize(i: u64, cx: &impl HasDataLayout) -> Self {
}
/// A `Scalar` represents an immediate, primitive value existing outside of a
/// `memory::Allocation`. It is in many ways like a small chunk of a `Allocation`, up to 16 bytes in
/// `memory::Allocation`. It is in many ways like a small chunk of an `Allocation`, up to 16 bytes in
/// size. Like a range of bytes in an `Allocation`, a `Scalar` can either represent the raw bytes
/// of a simple value or a pointer into another `Allocation`
///

2
compiler/rustc_middle/src/traits/mod.rs
View File

@ -509,7 +509,7 @@ pub enum ImplSource<'tcx, N> {
TraitUpcasting(ImplSourceTraitUpcastingData<'tcx, N>),
/// ImplSource automatically generated for a closure. The `DefId` is the ID
/// of the closure expression. This is a `ImplSource::UserDefined` in spirit, but the
/// of the closure expression. This is an `ImplSource::UserDefined` in spirit, but the
/// impl is generated by the compiler and does not appear in the source.
Closure(ImplSourceClosureData<'tcx, N>),

2
compiler/rustc_middle/src/traits/select.rs
View File

@ -111,7 +111,7 @@ pub enum SelectionCandidate<'tcx> {
ProjectionCandidate(usize),
/// Implementation of a `Fn`-family trait by one of the anonymous types
/// generated for a `||` expression.
/// generated for an `||` expression.
ClosureCandidate,
/// Implementation of a `Generator` trait by one of the anonymous types

2
compiler/rustc_middle/src/ty/adt.rs
View File

@ -209,7 +209,7 @@ pub fn is_union(&self) -> bool {
self.flags.contains(AdtFlags::IS_UNION)
}
/// Returns `true` if this is a enum.
/// Returns `true` if this is an enum.
#[inline]
pub fn is_enum(&self) -> bool {
self.flags.contains(AdtFlags::IS_ENUM)

2
compiler/rustc_middle/src/ty/context.rs
View File

@ -1792,7 +1792,7 @@ pub fn with_context_opt<F, R>(f: F) -> R
if context == 0 {
f(None)
} else {
// We could get a `ImplicitCtxt` pointer from another thread.
// We could get an `ImplicitCtxt` pointer from another thread.
// Ensure that `ImplicitCtxt` is `Sync`.
sync::assert_sync::<ImplicitCtxt<'_, '_>>();

2
compiler/rustc_middle/src/ty/inhabitedness/mod.rs
View File

@ -9,7 +9,7 @@
mod def_id_forest;
// The methods in this module calculate `DefIdForest`s of modules in which a
// The methods in this module calculate `DefIdForest`s of modules in which an
// `AdtDef`/`VariantDef`/`FieldDef` is visibly uninhabited.
//
// # Example

4
compiler/rustc_middle/src/ty/layout.rs
View File

@ -2571,14 +2571,14 @@ pub trait FnAbiExt<'tcx, C>
/// Compute a `FnAbi` suitable for indirect calls, i.e. to `fn` pointers.
///
/// NB: this doesn't handle virtual calls - those should use `FnAbi::of_instance`
/// instead, where the instance is a `InstanceDef::Virtual`.
/// instead, where the instance is an `InstanceDef::Virtual`.
fn of_fn_ptr(cx: &C, sig: ty::PolyFnSig<'tcx>, extra_args: &[Ty<'tcx>]) -> Self;
/// Compute a `FnAbi` suitable for declaring/defining an `fn` instance, and for
/// direct calls to an `fn`.
///
/// NB: that includes virtual calls, which are represented by "direct calls"
/// to a `InstanceDef::Virtual` instance (of `<dyn Trait as Trait>::fn`).
/// to an `InstanceDef::Virtual` instance (of `<dyn Trait as Trait>::fn`).
fn of_instance(cx: &C, instance: ty::Instance<'tcx>, extra_args: &[Ty<'tcx>]) -> Self;
fn new_internal(

4
compiler/rustc_middle/src/ty/mod.rs
View File

@ -865,7 +865,7 @@ pub fn to_opt_type_outlives(self) -> Option<PolyTypeOutlivesPredicate<'tcx>> {
/// Represents the bounds declared on a particular set of type
/// parameters. Should eventually be generalized into a flag list of
/// where-clauses. You can obtain a `InstantiatedPredicates` list from a
/// where-clauses. You can obtain an `InstantiatedPredicates` list from a
/// `GenericPredicates` by using the `instantiate` method. Note that this method
/// reflects an important semantic invariant of `InstantiatedPredicates`: while
/// the `GenericPredicates` are expressed in terms of the bound type
@ -1371,7 +1371,7 @@ pub struct VariantFlags: u32 {
}
}
/// Definition of a variant -- a struct's fields or a enum variant.
/// Definition of a variant -- a struct's fields or an enum variant.
#[derive(Debug, HashStable)]
pub struct VariantDef {
/// `DefId` that identifies the variant itself.

4
compiler/rustc_middle/src/ty/sty.rs
View File

@ -1323,7 +1323,7 @@ pub fn for_def(def: &ty::GenericParamDef) -> ParamConst {
/// These are regions that are stored behind a binder and must be substituted
/// with some concrete region before being used. There are two kind of
/// bound regions: early-bound, which are bound in an item's `Generics`,
/// and are substituted by a `InternalSubsts`, and late-bound, which are part of
/// and are substituted by an `InternalSubsts`, and late-bound, which are part of
/// higher-ranked types (e.g., `for<'a> fn(&'a ())`), and are substituted by
/// the likes of `liberate_late_bound_regions`. The distinction exists
/// because higher-ranked lifetimes aren't supported in all places. See [1][2].
@ -1471,7 +1471,7 @@ pub struct ExistentialProjection<'tcx> {
impl<'tcx> ExistentialProjection<'tcx> {
/// 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 a `exists T. T: Iterator` existential trait
/// then this function would return an `exists T. T: Iterator` existential trait
/// reference.
pub fn trait_ref(&self, tcx: TyCtxt<'tcx>) -> ty::ExistentialTraitRef<'tcx> {
let def_id = tcx.associated_item(self.item_def_id).container.id();

6
compiler/rustc_middle/src/ty/subst.rs
View File

@ -22,7 +22,7 @@
/// An entity in the Rust type system, which can be one of
/// several kinds (types, lifetimes, and consts).
/// To reduce memory usage, a `GenericArg` is a interned pointer,
/// To reduce memory usage, a `GenericArg` is an interned pointer,
/// with the lowest 2 bits being reserved for a tag to
/// indicate the type (`Ty`, `Region`, or `Const`) it points to.
#[derive(Copy, Clone, PartialEq, Eq, Hash)]
@ -204,12 +204,12 @@ pub fn as_generator(&'tcx self) -> GeneratorSubsts<'tcx> {
GeneratorSubsts { substs: self }
}
/// Creates a `InternalSubsts` that maps each generic parameter to itself.
/// Creates an `InternalSubsts` that maps each generic parameter to itself.
pub fn identity_for_item(tcx: TyCtxt<'tcx>, def_id: DefId) -> SubstsRef<'tcx> {
Self::for_item(tcx, def_id, |param, _| tcx.mk_param_from_def(param))
}
/// Creates a `InternalSubsts` for generic parameter definitions,
/// Creates an `InternalSubsts` for generic parameter definitions,
/// by calling closures to obtain each kind.
/// The closures get to observe the `InternalSubsts` as they're
/// being built, which can be used to correctly

4
compiler/rustc_mir/src/borrow_check/diagnostics/conflict_errors.rs
View File

@ -825,7 +825,7 @@ pub(in crate::borrow_check) fn describe_place_for_conflicting_borrow(
// We're going to want to traverse the first borrowed place to see if we can find
// field access to a union. If we find that, then we will keep the place of the
// union being accessed and the field that was being accessed so we can check the
// second borrowed place for the same union and a access to a different field.
// second borrowed place for the same union and an access to a different field.
for (place_base, elem) in first_borrowed_place.iter_projections().rev() {
match elem {
ProjectionElem::Field(field, _) if union_ty(place_base).is_some() => {
@ -838,7 +838,7 @@ pub(in crate::borrow_check) fn describe_place_for_conflicting_borrow(
})
.and_then(|(target_base, target_field)| {
// With the place of a union and a field access into it, we traverse the second
// borrowed place and look for a access to a different field of the same union.
// borrowed place and look for an access to a different field of the same union.
for (place_base, elem) in second_borrowed_place.iter_projections().rev() {
if let ProjectionElem::Field(field, _) = elem {
if let Some(union_ty) = union_ty(place_base) {

4
compiler/rustc_mir/src/borrow_check/diagnostics/mutability_errors.rs
View File

@ -72,7 +72,7 @@ pub(crate) fn report_mutability_error(
// If the place is immutable then:
//
// - Either we deref a immutable ref to get to our final place.
// - Either we deref an immutable ref to get to our final place.
// - We don't capture derefs of raw ptrs
// - Or the final place is immut because the root variable of the capture
// isn't marked mut and we should suggest that to the user.
@ -601,7 +601,7 @@ fn show_mutating_upvar(
let reason = if let PlaceBase::Upvar(upvar_id) = closure_kind_origin.base {
let upvar = ty::place_to_string_for_capture(tcx, closure_kind_origin);
let root_hir_id = upvar_id.var_path.hir_id;
// we have a origin for this closure kind starting at this root variable so it's safe to unwrap here
// we have an origin for this closure kind starting at this root variable so it's safe to unwrap here
let captured_places = tables.closure_min_captures[id].get(&root_hir_id).unwrap();
let origin_projection = closure_kind_origin

4
compiler/rustc_mir/src/borrow_check/diagnostics/region_errors.rs
View File

@ -423,7 +423,7 @@ fn report_fnmut_error(
diag
}
/// Reports a error specifically for when data is escaping a closure.
/// Reports an error specifically for when data is escaping a closure.
///
/// ```text
/// error: borrowed data escapes outside of function
@ -566,7 +566,7 @@ fn report_general_error(&self, errci: &ErrorConstraintInfo) -> DiagnosticBuilder
diag
}
/// Adds a suggestion to errors where a `impl Trait` is returned.
/// Adds a suggestion to errors where an `impl Trait` is returned.
///
/// ```text
/// help: to allow this `impl Trait` to capture borrowed data with lifetime `'1`, add `'_` as

6
compiler/rustc_mir/src/borrow_check/mod.rs
View File

@ -1241,7 +1241,7 @@ fn mutate_place(
}
}
// Special case: you can assign a immutable local variable
// Special case: you can assign an immutable local variable
// (e.g., `x = ...`) so long as it has never been initialized
// before (at this point in the flow).
if let Some(local) = place_span.0.as_local() {
@ -1702,7 +1702,7 @@ fn check_if_full_path_is_moved(
// initialization state of `a.b` is all we need to inspect to
// know if `a.b.c` is valid (and from that we infer that the
// dereference and `.d` access is also valid, since we assume
// `a.b.c` is assigned a reference to a initialized and
// `a.b.c` is assigned a reference to an initialized and
// well-formed record structure.)
// Therefore, if we seek out the *closest* prefix for which we
@ -2004,7 +2004,7 @@ fn check_parent_of_field<'cx, 'tcx>(
if let Some((prefix, mpi)) = shortest_uninit_seen {
// Check for a reassignment into a uninitialized field of a union (for example,
// after a move out). In this case, do not report a error here. There is an
// after a move out). In this case, do not report an error here. There is an
// exception, if this is the first assignment into the union (that is, there is
// no move out from an earlier location) then this is an attempt at initialization
// of the union - we should error in that case.

2
compiler/rustc_mir/src/borrow_check/universal_regions.rs
View File

@ -169,7 +169,7 @@ struct UniversalRegionIndices<'tcx> {
/// used because trait matching and type-checking will feed us
/// region constraints that reference those regions and we need to
/// be able to map them our internal `RegionVid`. This is
/// basically equivalent to a `InternalSubsts`, except that it also
/// basically equivalent to an `InternalSubsts`, except that it also
/// contains an entry for `ReStatic` -- it might be nice to just
/// use a substs, and then handle `ReStatic` another way.
indices: FxHashMap<ty::Region<'tcx>, RegionVid>,

2
compiler/rustc_mir/src/interpret/operand.rs
View File

@ -295,7 +295,7 @@ fn try_read_immediate_from_mplace(
/// we can find the data.
/// Note that for a given layout, this operation will either always fail or always
/// succeed! Whether it succeeds depends on whether the layout can be represented
/// in a `Immediate`, not on which data is stored there currently.
/// in an `Immediate`, not on which data is stored there currently.
pub(crate) fn try_read_immediate(
&self,
src: &OpTy<'tcx, M::PointerTag>,

2
compiler/rustc_mir/src/transform/coverage/counters.rs
View File

@ -100,7 +100,7 @@ fn next_counter(&mut self) -> CounterValueReference {
CounterValueReference::from(next)
}
/// Expression IDs start from u32::MAX and go down because a Expression can reference
/// Expression IDs start from u32::MAX and go down because an Expression can reference
/// (add or subtract counts) of both Counter regions and Expression regions. The counter
/// expression operand IDs must be unique across both types.
fn next_expression(&mut self) -> InjectedExpressionId {

2
compiler/rustc_mir/src/transform/coverage/mod.rs
View File

@ -334,7 +334,7 @@ fn inject_coverage_span_counters(
/// process (via `take_counter()`).
///
/// Any other counter associated with a `BasicCoverageBlock`, or its incoming edge, but not
/// associated with a `CoverageSpan`, should only exist if the counter is a `Expression`
/// associated with a `CoverageSpan`, should only exist if the counter is an `Expression`
/// dependency (one of the expression operands). Collect them, and inject the additional
/// counters into the MIR, without a reportable coverage span.
fn inject_indirect_counters(

2
compiler/rustc_mir/src/transform/rustc_peek.rs
View File

@ -88,7 +88,7 @@ fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
/// For each such call, determines what the dataflow bit-state is for
/// the L-value corresponding to `expr`; if the bit-state is a 1, then
/// that call to `rustc_peek` is ignored by the sanity check. If the
/// bit-state is a 0, then this pass emits a error message saying
/// bit-state is a 0, then this pass emits an error message saying
/// "rustc_peek: bit not set".
///
/// The intention is that one can write unit tests for dataflow by

2
compiler/rustc_mir_build/src/build/expr/into.rs
View File

@ -61,7 +61,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
unpack!(this.expr_into_dest(destination, else_blk, &this.thir[else_opt]))
} else {
// Body of the `if` expression without an `else` clause must return `()`, thus
// we implicitly generate a `else {}` if it is not specified.
// we implicitly generate an `else {}` if it is not specified.
let correct_si = this.source_info(expr_span.shrink_to_hi());
this.cfg.push_assign_unit(else_blk, correct_si, destination, this.tcx);
else_blk

2
compiler/rustc_mir_build/src/build/matches/mod.rs
View File

@ -1936,7 +1936,7 @@ fn bind_and_guard_matched_candidate<'pat>(
// }
// ```
//
// would yield a `arm_block` something like:
// would yield an `arm_block` something like:
//
// ```
// StorageLive(_4); // _4 is `x`

4
compiler/rustc_mir_build/src/build/mod.rs
View File

@ -700,7 +700,7 @@ fn construct_const<'a, 'tcx>(
builder.finish()
}
/// Construct MIR for a item that has had errors in type checking.
/// Construct MIR for an item that has had errors in type checking.
///
/// This is required because we may still want to run MIR passes on an item
/// with type errors, but normal MIR construction can't handle that in general.
@ -885,7 +885,7 @@ fn args_and_body(
let tcx_hir = tcx.hir();
let hir_typeck_results = self.typeck_results;
// In analyze_closure() in upvar.rs we gathered a list of upvars used by a
// In analyze_closure() in upvar.rs we gathered a list of upvars used by an
// indexed closure and we stored in a map called closure_min_captures in TypeckResults
// with the closure's DefId. Here, we run through that vec of UpvarIds for
// the given closure and use the necessary information to create upvar

4
compiler/rustc_parse/src/parser/attr_wrapper.rs
View File

@ -301,7 +301,7 @@ pub fn collect_tokens_trailing_token<R: AstLike>(
// If we 'broke' the last token (e.g. breaking a '>>' token to two '>' tokens),
// then extend the range of captured tokens to include it, since the parser
// was not actually bumped past it. When the `LazyTokenStream` gets converted
// into a `AttrAnnotatedTokenStream`, we will create the proper token.
// into an `AttrAnnotatedTokenStream`, we will create the proper token.
if self.token_cursor.break_last_token {
assert_eq!(
trailing,
@ -320,7 +320,7 @@ pub fn collect_tokens_trailing_token<R: AstLike>(
} else {
// Grab any replace ranges that occur *inside* the current AST node.
// We will perform the actual replacement when we convert the `LazyTokenStream`
// to a `AttrAnnotatedTokenStream`
// to an `AttrAnnotatedTokenStream`
let start_calls: u32 = cursor_snapshot_next_calls.try_into().unwrap();
self.capture_state.replace_ranges[replace_ranges_start..replace_ranges_end]
.iter()

2
compiler/rustc_parse/src/parser/expr.rs
View File

@ -1092,7 +1092,7 @@ fn parse_bottom_expr(&mut self) -> PResult<'a, P<Expr>> {
// added to the return value after the fact.
//
// Therefore, prevent sub-parser from parsing
// attributes by giving them a empty "already-parsed" list.
// attributes by giving them an empty "already-parsed" list.
let attrs = AttrVec::new();
// Note: when adding new syntax here, don't forget to adjust `TokenKind::can_begin_expr()`.

12
compiler/rustc_parse/src/parser/mod.rs
View File

@ -152,7 +152,7 @@ pub struct Parser<'a> {
/// attribute, we parse a nested AST node that has `#[cfg]` or `#[cfg_attr]`
/// In this case, we use a `ReplaceRange` to replace the entire inner AST node
/// with `FlatToken::AttrTarget`, allowing us to perform eager cfg-expansion
/// on a `AttrAnnotatedTokenStream`
/// on an `AttrAnnotatedTokenStream`
///
/// 2. When we parse an inner attribute while collecting tokens. We
/// remove inner attributes from the token stream entirely, and
@ -165,7 +165,7 @@ pub struct Parser<'a> {
/// Controls how we capture tokens. Capturing can be expensive,
/// so we try to avoid performing capturing in cases where
/// we will never need a `AttrAnnotatedTokenStream`
/// we will never need an `AttrAnnotatedTokenStream`
#[derive(Copy, Clone)]
pub enum Capturing {
/// We aren't performing any capturing - this is the default mode.
@ -1362,10 +1362,10 @@ pub fn emit_unclosed_delims(unclosed_delims: &mut Vec<UnmatchedBrace>, sess: &Pa
}
}
/// A helper struct used when building a `AttrAnnotatedTokenStream` from
/// A helper struct used when building an `AttrAnnotatedTokenStream` from
/// a `LazyTokenStream`. Both delimiter and non-delimited tokens
/// are stored as `FlatToken::Token`. A vector of `FlatToken`s
/// is then 'parsed' to build up a `AttrAnnotatedTokenStream` with nested
/// is then 'parsed' to build up an `AttrAnnotatedTokenStream` with nested
/// `AttrAnnotatedTokenTree::Delimited` tokens
#[derive(Debug, Clone)]
pub enum FlatToken {
@ -1375,10 +1375,10 @@ pub enum FlatToken {
/// Holds the `AttributesData` for an AST node. The
/// `AttributesData` is inserted directly into the
/// constructed `AttrAnnotatedTokenStream` as
/// a `AttrAnnotatedTokenTree::Attributes`
/// an `AttrAnnotatedTokenTree::Attributes`
AttrTarget(AttributesData),
/// A special 'empty' token that is ignored during the conversion
/// to a `AttrAnnotatedTokenStream`. This is used to simplify the
/// to an `AttrAnnotatedTokenStream`. This is used to simplify the
/// handling of replace ranges.
Empty,
}

2
compiler/rustc_privacy/src/lib.rs
View File

@ -575,7 +575,7 @@ fn update_macro_reachable_def(
}
}
/// Given the path segments of a `ItemKind::Use`, then we need
/// Given the path segments of an `ItemKind::Use`, then we need
/// to update the visibility of the intermediate use so that it isn't linted
/// by `unreachable_pub`.
///

6
compiler/rustc_resolve/src/lib.rs
View File

@ -668,7 +668,7 @@ enum NameBindingKind<'a> {
}
impl<'a> NameBindingKind<'a> {
/// Is this a name binding of a import?
/// Is this a name binding of an import?
fn is_import(&self) -> bool {
matches!(*self, NameBindingKind::Import { .. })
}
@ -3066,7 +3066,7 @@ fn report_conflict<'b>(
self.extern_prelude.get(&ident).map_or(true, |entry| entry.introduced_by_item);
// Only suggest removing an import if both bindings are to the same def, if both spans
// aren't dummy spans. Further, if both bindings are imports, then the ident must have
// been introduced by a item.
// been introduced by an item.
let should_remove_import = duplicate
&& !has_dummy_span
&& ((new_binding.is_extern_crate() || old_binding.is_extern_crate()) || from_item);
@ -3213,7 +3213,7 @@ fn add_suggestion_for_duplicate_nested_use(
Applicability::MaybeIncorrect,
);
} else {
// Remove the entire line if we cannot extend the span back, this indicates a
// Remove the entire line if we cannot extend the span back, this indicates an
// `issue_52891::{self}` case.
err.span_suggestion(
import.use_span_with_attributes,

2
compiler/rustc_serialize/src/serialize.rs
View File

@ -644,7 +644,7 @@ fn decode(d: &mut D) -> Result<Cell<T>, D::Error> {
}
// FIXME: #15036
// Should use `try_borrow`, returning a
// Should use `try_borrow`, returning an
// `encoder.error("attempting to Encode borrowed RefCell")`
// from `encode` when `try_borrow` returns `None`.

2
compiler/rustc_target/src/asm/mod.rs
View File

@ -469,7 +469,7 @@ pub fn default_modifier(self, arch: InlineAsmArch) -> Option<(char, &'static str
}
}
/// Returns a list of supported types for this register class, each with a
/// Returns a list of supported types for this register class, each with an
/// options target feature required to use this type.
pub fn supported_types(
self,

4
compiler/rustc_trait_selection/src/opaque_types.rs
View File

@ -77,7 +77,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
/// ?0: Iterator<Item = ?1>
/// ?1: Debug
///
/// Moreover, it returns a `OpaqueTypeMap` that would map `?0` to
/// Moreover, it returns an `OpaqueTypeMap` that would map `?0` to
/// info about the `impl Iterator<..>` type and `?1` to info about
/// the `impl Debug` type.
///
@ -886,7 +886,7 @@ fn instantiate_opaque_types_in_map<T: TypeFoldable<'tcx>>(&mut self, value: T) -
// }
// ```
//
// Here, the return type of `foo` references a
// Here, the return type of `foo` references an
// `Opaque` indeed, but not one whose value is
// presently being inferred. You can get into a
// similar situation with closure return types

2
compiler/rustc_trait_selection/src/traits/codegen.rs
View File

@ -12,7 +12,7 @@
use rustc_middle::ty::fold::TypeFoldable;
use rustc_middle::ty::{self, TyCtxt};
/// Attempts to resolve an obligation to a `ImplSource`. The result is
/// Attempts to resolve an obligation to an `ImplSource`. The result is
/// a shallow `ImplSource` resolution, meaning that we do not
/// (necessarily) resolve all nested obligations on the impl. Note
/// that type check should guarantee to us that all nested

2
compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
View File

@ -2009,7 +2009,7 @@ pub enum ArgKind {
Arg(String, String),
/// An argument of tuple type. For a "found" argument, the span is
/// the location in the source of the pattern. For a "expected"
/// the location in the source of the pattern. For an "expected"
/// argument, it will be None. The vector is a list of (name, ty)
/// strings for the components of the tuple.
Tuple(Option<Span>, Vec<(String, String)>),

2
compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
View File

@ -1365,7 +1365,7 @@ fn maybe_note_obligation_cause_for_async_await(
// When a future does not implement a trait because of a captured type in one of the
// generators somewhere in the call stack, then the result is a chain of obligations.
//
// Given a `async fn` A that calls a `async fn` B which captures a non-send type and that
// Given an `async fn` A that calls an `async fn` B which captures a non-send type and that
// future is passed as an argument to a function C which requires a `Send` type, then the
// chain looks something like this:
//

4
compiler/rustc_trait_selection/src/traits/project.rs
View File

@ -62,7 +62,7 @@ enum ProjectionTyCandidate<'tcx> {
/// Bounds specified on an object type
Object(ty::PolyProjectionPredicate<'tcx>),
/// From a "impl" (or a "pseudo-impl" returned by select)
/// From an "impl" (or a "pseudo-impl" returned by select)
Select(Selection<'tcx>),
}
@ -1011,7 +1011,7 @@ fn prune_cache_value_obligations<'a, 'tcx>(
/// Note that we used to return `Error` here, but that was quite
/// dubious -- the premise was that an error would *eventually* be
/// reported, when the obligation was processed. But in general once
/// you see a `Error` you are supposed to be able to assume that an
/// you see an `Error` you are supposed to be able to assume that an
/// error *has been* reported, so that you can take whatever heuristic
/// paths you want to take. To make things worse, it was possible for
/// cycles to arise, where you basically had a setup like `<MyType<$0>

2
compiler/rustc_trait_selection/src/traits/query/type_op/implied_outlives_bounds.rs
View File

@ -24,7 +24,7 @@ fn perform_query(
) -> Fallible<CanonicalizedQueryResponse<'tcx, Self::QueryResponse>> {
// FIXME this `unchecked_map` is only necessary because the
// query is defined as taking a `ParamEnvAnd<Ty>`; it should
// take a `ImpliedOutlivesBounds` instead
// take an `ImpliedOutlivesBounds` instead
let canonicalized = canonicalized.unchecked_map(|ParamEnvAnd { param_env, value }| {
let ImpliedOutlivesBounds { ty } = value;
param_env.and(ty)

2
compiler/rustc_trait_selection/src/traits/select/confirmation.rs
View File

@ -257,7 +257,7 @@ fn confirm_builtin_candidate(
ImplSourceBuiltinData { nested: obligations }
}
/// This handles the case where a `auto trait Foo` impl is being used.
/// This handles the case where an `auto trait Foo` impl is being used.
/// The idea is that the impl applies to `X : Foo` if the following conditions are met:
///
/// 1. For each constituent type `Y` in `X`, `Y : Foo` holds

2
compiler/rustc_trait_selection/src/traits/specialize/mod.rs
View File

@ -149,7 +149,7 @@ pub(super) fn specializes(tcx: TyCtxt<'_>, (impl1_def_id, impl2_def_id): (DefId,
let penv = tcx.param_env(impl1_def_id);
let impl1_trait_ref = tcx.impl_trait_ref(impl1_def_id).unwrap();
// Create a infcx, taking the predicates of impl1 as assumptions:
// Create an infcx, taking the predicates of impl1 as assumptions:
tcx.infer_ctxt().enter(|infcx| {
// Normalize the trait reference. The WF rules ought to ensure
// that this always succeeds.

2
compiler/rustc_traits/src/chalk/db.rs
View File

@ -718,7 +718,7 @@ fn adt_variance(
}
}
/// Creates a `InternalSubsts` that maps each generic parameter to a higher-ranked
/// Creates an `InternalSubsts` that maps each generic parameter to a higher-ranked
/// var bound at index `0`. For types, we use a `BoundVar` index equal to
/// the type parameter index. For regions, we use the `BoundRegionKind::BrNamed`
/// variant (which has a `DefId`).

4
compiler/rustc_ty_utils/src/ty.rs
View File

@ -185,7 +185,7 @@ fn impl_constness(tcx: TyCtxt<'_>, def_id: DefId) -> hir::Constness {
/// - a type parameter or projection whose Sizedness can't be known
/// - a tuple of type parameters or projections, if there are multiple
/// such.
/// - a Error, if a type contained itself. The representability
/// - an Error, if a type contained itself. The representability
/// check should catch this case.
fn adt_sized_constraint(tcx: TyCtxt<'_>, def_id: DefId) -> ty::AdtSizedConstraint<'_> {
let def = tcx.adt_def(def_id);
@ -253,7 +253,7 @@ fn param_env(tcx: TyCtxt<'_>, def_id: DefId) -> ty::ParamEnv<'_> {
// `<i32 as Foo>::Bar` where `i32` does not implement `Foo`. We
// report these errors right here; this doesn't actually feel
// right to me, because constructing the environment feels like a
// kind of a "idempotent" action, but I'm not sure where would be
// kind of an "idempotent" action, but I'm not sure where would be
// a better place. In practice, we construct environments for
// every fn once during type checking, and we'll abort if there
// are any errors at that point, so after type checking you can be

2
compiler/rustc_typeck/src/astconv/mod.rs
View File

@ -2350,7 +2350,7 @@ fn ast_ty_to_ty_inner(&self, ast_ty: &hir::Ty<'_>, borrowed: bool) -> Ty<'tcx> {
}
hir::TyKind::Infer => {
// Infer also appears as the type of arguments or return
// values in a ExprKind::Closure, or as
// values in an ExprKind::Closure, or as
// the type of local variables. Both of these cases are
// handled specially and will not descend into this routine.
self.ty_infer(None, ast_ty.span)

2
compiler/rustc_typeck/src/check/closure.rs
View File

@ -606,7 +606,7 @@ fn supplied_sig_of_closure(
/// Invoked when we are translating the generator that results
/// from desugaring an `async fn`. Returns the "sugared" return
/// type of the `async fn` -- that is, the return type that the
/// user specified. The "desugared" return type is a `impl
/// user specified. The "desugared" return type is an `impl
/// Future<Output = T>`, so we do this by searching through the
/// obligations to extract the `T`.
fn deduce_future_output_from_obligations(&self, expr_def_id: DefId) -> Option<Ty<'tcx>> {

2
compiler/rustc_typeck/src/check/fn_ctxt/mod.rs
View File

@ -96,7 +96,7 @@ pub struct FnCtxt<'a, 'tcx> {
/// `foo(return)`; we warn on the `foo()` expression. (We then
/// update the flag to `WarnedAlways` to suppress duplicate
/// reports.) Similarly, if we traverse to a fresh statement (or
/// tail expression) from a `Always` setting, we will issue a
/// tail expression) from an `Always` setting, we will issue a
/// warning. This corresponds to something like `{return;
/// foo();}` or `{return; 22}`, where we would warn on the
/// `foo()` or `22`.

2
compiler/rustc_typeck/src/check/upvar.rs
View File

@ -1427,7 +1427,7 @@ fn determine_capture_mutability(
// an immut-ref after on top of this.
ty::Ref(.., hir::Mutability::Mut) => is_mutbl = hir::Mutability::Mut,
// The place isn't mutable once we dereference a immutable reference.
// The place isn't mutable once we dereference an immutable reference.
ty::Ref(.., hir::Mutability::Not) => return hir::Mutability::Not,
// Dereferencing a box doesn't change mutability

2
compiler/rustc_typeck/src/expr_use_visitor.rs
View File

@ -819,7 +819,7 @@ fn copy_or_move<'a, 'tcx>(
}
// - If a place is used in a `ByValue` context then move it if it's not a `Copy` type.
// - If the place that is a `Copy` type consider it a `ImmBorrow`.
// - If the place that is a `Copy` type consider it an `ImmBorrow`.
fn delegate_consume<'a, 'tcx>(
mc: &mc::MemCategorizationContext<'a, 'tcx>,
delegate: &mut (dyn Delegate<'tcx> + 'a),

2
compiler/rustc_typeck/src/outlives/implicit_infer.rs
View File

@ -297,7 +297,7 @@ pub fn check_explicit_predicates<'tcx>(
// to apply the substs, and not filter this predicate, we might then falsely
// conclude that e.g., `X: 'x` was a reasonable inferred requirement.
//
// Another similar case is where we have a inferred
// Another similar case is where we have an inferred
// requirement like `<Self as Trait>::Foo: 'b`. We presently
// ignore such requirements as well (cc #54467)-- though
// conceivably it might be better if we could extract the `Foo

2
library/alloc/src/alloc.rs
View File

@ -387,7 +387,7 @@ pub mod __alloc_error_handler {
panic!("memory allocation of {} bytes failed", size)
}
// if there is a `#[alloc_error_handler]`
// if there is an `#[alloc_error_handler]`
#[rustc_std_internal_symbol]
pub unsafe extern "C" fn __rg_oom(size: usize, align: usize) -> ! {
let layout = unsafe { Layout::from_size_align_unchecked(size, align) };

2
library/core/src/iter/adapters/zip.rs
View File

@ -563,7 +563,7 @@ pub(in crate::iter::adapters) unsafe fn try_get_unchecked<I>(it: &mut I, idx: us
}
unsafe trait SpecTrustedRandomAccess: Iterator {
/// If `Self: TrustedRandomAccess`, it must be safe to call a
/// If `Self: TrustedRandomAccess`, it must be safe to call
/// `Iterator::__iterator_get_unchecked(self, index)`.
unsafe fn try_get_unchecked(&mut self, index: usize) -> Self::Item;
}

2
library/core/src/iter/traits/marker.rs
View File

@ -25,7 +25,7 @@ impl<I: FusedIterator + ?Sized> FusedIterator for &mut I {}
/// (lower bound is equal to upper bound), or the upper bound is [`None`].
/// The upper bound must only be [`None`] if the actual iterator length is
/// larger than [`usize::MAX`]. In that case, the lower bound must be
/// [`usize::MAX`], resulting in a [`Iterator::size_hint()`] of
/// [`usize::MAX`], resulting in an [`Iterator::size_hint()`] of
/// `(usize::MAX, None)`.
///
/// The iterator must produce exactly the number of elements it reported

2
library/core/src/num/dec2flt/lemire.rs
View File

@ -9,7 +9,7 @@
/// Compute a float using an extended-precision representation.
///
/// Fast conversion of a the significant digits and decimal exponent
/// a float to a extended representation with a binary float. This
/// a float to an extended representation with a binary float. This
/// algorithm will accurately parse the vast majority of cases,
/// and uses a 128-bit representation (with a fallback 192-bit
/// representation).

2
library/proc_macro/src/lib.rs
View File

@ -262,7 +262,7 @@ fn into_iter(self) -> IntoIter {
}
/// `quote!(..)` accepts arbitrary tokens and expands into a `TokenStream` describing the input.
/// For example, `quote!(a + b)` will produce a expression, that, when evaluated, constructs
/// For example, `quote!(a + b)` will produce an expression, that, when evaluated, constructs
/// the `TokenStream` `[Ident("a"), Punct('+', Alone), Ident("b")]`.
///
/// Unquoting is done with `$`, and works by taking the single next ident as the unquoted term.

6
library/std/src/collections/hash/map.rs
View File

@ -1239,7 +1239,7 @@ pub struct IterMut<'a, K: 'a, V: 'a> {
}
impl<'a, K, V> IterMut<'a, K, V> {
/// Returns a iterator of references over the remaining items.
/// Returns an iterator of references over the remaining items.
#[inline]
pub(super) fn iter(&self) -> Iter<'_, K, V> {
Iter { base: self.base.rustc_iter() }
@ -1268,7 +1268,7 @@ pub struct IntoIter<K, V> {
}
impl<K, V> IntoIter<K, V> {
/// Returns a iterator of references over the remaining items.
/// Returns an iterator of references over the remaining items.
#[inline]
pub(super) fn iter(&self) -> Iter<'_, K, V> {
Iter { base: self.base.rustc_iter() }
@ -1371,7 +1371,7 @@ pub struct Drain<'a, K: 'a, V: 'a> {
}
impl<'a, K, V> Drain<'a, K, V> {
/// Returns a iterator of references over the remaining items.
/// Returns an iterator of references over the remaining items.
#[inline]
pub(super) fn iter(&self) -> Iter<'_, K, V> {
Iter { base: self.base.rustc_iter() }

4
library/std/src/ffi/c_str.rs
View File

@ -46,7 +46,7 @@
///
/// # Extracting a raw pointer to the whole C string
///
/// `CString` implements a [`as_ptr`][`CStr::as_ptr`] method through the [`Deref`]
/// `CString` implements an [`as_ptr`][`CStr::as_ptr`] method through the [`Deref`]
/// trait. This method will give you a `*const c_char` which you can
/// feed directly to extern functions that expect a nul-terminated
/// string, like C's `strdup()`. Notice that [`as_ptr`][`CStr::as_ptr`] returns a
@ -730,7 +730,7 @@ pub unsafe fn from_vec_with_nul_unchecked(v: Vec<u8>) -> Self {
/// );
/// ```
///
/// A incorrectly formatted [`Vec`] will produce an error.
/// An incorrectly formatted [`Vec`] will produce an error.
///
/// ```
/// #![feature(cstring_from_vec_with_nul)]

8
library/std/src/ffi/os_str.rs
View File

@ -359,7 +359,7 @@ pub fn into_boxed_os_str(self) -> Box<OsStr> {
#[stable(feature = "rust1", since = "1.0.0")]
impl From<String> for OsString {
/// Converts a [`String`] into a [`OsString`].
/// Converts a [`String`] into an [`OsString`].
///
/// This conversion does not allocate or copy memory.
#[inline]
@ -880,7 +880,7 @@ fn from(boxed: Box<OsStr>) -> OsString {
#[stable(feature = "box_from_os_string", since = "1.20.0")]
impl From<OsString> for Box<OsStr> {
/// Converts a [`OsString`] into a [`Box`]`<OsStr>` without copying or allocating.
/// Converts an [`OsString`] into a [`Box`]`<OsStr>` without copying or allocating.
#[inline]
fn from(s: OsString) -> Box<OsStr> {
s.into_boxed_os_str()
@ -897,7 +897,7 @@ fn clone(&self) -> Self {
#[stable(feature = "shared_from_slice2", since = "1.24.0")]
impl From<OsString> for Arc<OsStr> {
/// Converts a [`OsString`] into a [`Arc`]`<OsStr>` without copying or allocating.
/// Converts an [`OsString`] into a [`Arc`]`<OsStr>` without copying or allocating.
#[inline]
fn from(s: OsString) -> Arc<OsStr> {
let arc = s.inner.into_arc();
@ -916,7 +916,7 @@ fn from(s: &OsStr) -> Arc<OsStr> {
#[stable(feature = "shared_from_slice2", since = "1.24.0")]
impl From<OsString> for Rc<OsStr> {
/// Converts a [`OsString`] into a [`Rc`]`<OsStr>` without copying or allocating.
/// Converts an [`OsString`] into a [`Rc`]`<OsStr>` without copying or allocating.
#[inline]
fn from(s: OsString) -> Rc<OsStr> {
let rc = s.inner.into_rc();

4
library/std/src/net/addr.rs
View File

@ -561,8 +561,8 @@ fn from(sock6: SocketAddrV6) -> SocketAddr {
impl<I: Into<IpAddr>> From<(I, u16)> for SocketAddr {
/// Converts a tuple struct (Into<[`IpAddr`]>, `u16`) into a [`SocketAddr`].
///
/// This conversion creates a [`SocketAddr::V4`] for a [`IpAddr::V4`]
/// and creates a [`SocketAddr::V6`] for a [`IpAddr::V6`].
/// This conversion creates a [`SocketAddr::V4`] for an [`IpAddr::V4`]
/// and creates a [`SocketAddr::V6`] for an [`IpAddr::V6`].
///
/// `u16` is treated as port of the newly created [`SocketAddr`].
fn from(pieces: (I, u16)) -> SocketAddr {

6
library/std/src/net/ip.rs
View File

@ -380,7 +380,7 @@ pub const fn is_ipv6(&self) -> bool {
matches!(self, IpAddr::V6(_))
}
/// Converts this address to an `IpAddr::V4` if it is a IPv4-mapped IPv6 addresses, otherwise it
/// Converts this address to an `IpAddr::V4` if it is an IPv4-mapped IPv6 addresses, otherwise it
/// return `self` as-is.
///
/// # Examples
@ -1621,8 +1621,8 @@ pub const fn to_ipv4(&self) -> Option<Ipv4Addr> {
}
}
/// Converts this address to an `IpAddr::V4` if it is a IPv4-mapped addresses, otherwise it
/// returns self wrapped in a `IpAddr::V6`.
/// Converts this address to an `IpAddr::V4` if it is an IPv4-mapped addresses, otherwise it
/// returns self wrapped in an `IpAddr::V6`.
///
/// # Examples
///

4
library/std/src/os/unix/net/ancillary.rs
View File

@ -279,7 +279,7 @@ pub enum AncillaryData<'a> {
}
impl<'a> AncillaryData<'a> {
/// Create a `AncillaryData::ScmRights` variant.
/// Create an `AncillaryData::ScmRights` variant.
///
/// # Safety
///
@ -291,7 +291,7 @@ unsafe fn as_rights(data: &'a [u8]) -> Self {
AncillaryData::ScmRights(scm_rights)
}
/// Create a `AncillaryData::ScmCredentials` variant.
/// Create an `AncillaryData::ScmCredentials` variant.
///
/// # Safety
///

2
library/std/src/os/windows/ffi.rs
View File

@ -30,7 +30,7 @@
//! [`OsString`] is the Rust wrapper for owned strings in the
//! preferred representation of the operating system. On Windows,
//! this struct gets augmented with an implementation of the
//! [`OsStringExt`] trait, which has a [`OsStringExt::from_wide`] method. This
//! [`OsStringExt`] trait, which has an [`OsStringExt::from_wide`] method. This
//! lets you create an [`OsString`] from a `&[u16]` slice; presumably
//! you get such a slice out of a `WCHAR` Windows API.
//!

2
src/librustdoc/html/static/js/search.js
View File

@ -1331,7 +1331,7 @@ window.initSearch = function(rawSearchIndex) {
// an array of [(Number) item type,
// (String) name]
var paths = rawSearchIndex[crate].p;
// a array of [(String) alias name
// an array of [(String) alias name
// [Number] index to items]
var aliases = rawSearchIndex[crate].a;

2
src/test/incremental/thinlto/cgu_invalidated_when_import_removed.rs
View File

@ -8,7 +8,7 @@
// functions and the modules are enclosed in `[]`)
//
// In our specific instance, the earlier compilations were inlining the call
// to`B` into `A`; thus `A` ended up with a external reference to the symbol `D`
// to`B` into `A`; thus `A` ended up with an external reference to the symbol `D`
// in its object code, to be resolved at subsequent link time. The LTO import
// information provided by LLVM for those runs reflected that information: it
// explicitly says during those runs, `B` definition and `D` declaration were

2
src/test/rustdoc-ui/coverage/allow_missing_docs.rs
View File

@ -8,7 +8,7 @@ pub mod mod_foo {
pub struct Bar;
}
/// This is a struct with a `#[allow(missing_docs)]`
/// This is a struct with an `#[allow(missing_docs)]`
pub struct AllowTheMissingDocs {
#[allow(missing_docs)]
pub empty_str: String,

2
src/test/ui/async-await/drop-order/drop-order-for-temporary-in-tail-return-expr.rs
View File

@ -10,7 +10,7 @@
// Test the drop order for parameters relative to local variables and
// temporaries created in the tail return expression of the function
// body. In particular, check that this drop order is the same between
// a `async fn` and an ordinary `fn`. See #64512.
// an `async fn` and an ordinary `fn`. See #64512.
extern crate arc_wake;

2
src/test/ui/async-await/issues/issue-69307.rs
View File

@ -1,6 +1,6 @@
// Regression test for #69307
//
// Having a `async { .. foo.await .. }` block appear inside of a `+=`
// Having an `async { .. foo.await .. }` block appear inside of a `+=`
// expression was causing an ICE due to a failure to save/restore
// state in the AST numbering pass when entering a nested body.
//

2
src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.fixed
View File

@ -3,7 +3,7 @@
#![deny(rust_2021_incompatible_closure_captures)]
//~^ NOTE: the lint level is defined here
// Test cases for types that implement a insignificant drop (stlib defined)
// Test cases for types that implement an insignificant drop (stlib defined)
// `t` needs Drop because one of its elements needs drop,
// therefore precise capture might affect drop ordering

2
src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.rs
View File

@ -3,7 +3,7 @@
#![deny(rust_2021_incompatible_closure_captures)]
//~^ NOTE: the lint level is defined here
// Test cases for types that implement a insignificant drop (stlib defined)
// Test cases for types that implement an insignificant drop (stlib defined)
// `t` needs Drop because one of its elements needs drop,
// therefore precise capture might affect drop ordering

2
src/test/ui/hrtb/hrtb-exists-forall-fn.rs
View File

@ -1,4 +1,4 @@
// Test a `exists<'a> { forall<'b> { 'a = 'b } }` pattern -- which should not compile!
// Test an `exists<'a> { forall<'b> { 'a = 'b } }` pattern -- which should not compile!
//
// In particular, we test this pattern in trait solving, where it is not connected
// to any part of the source code.

2
src/test/ui/hrtb/hrtb-exists-forall-trait-invariant.rs
View File

@ -1,4 +1,4 @@
// Test a `exists<'a> { forall<'b> { 'a = 'b } }` pattern -- which should not compile!
// Test an `exists<'a> { forall<'b> { 'a = 'b } }` pattern -- which should not compile!
//
// In particular, we test this pattern in trait solving, where it is not connected
// to any part of the source code.

2
src/test/ui/rfc-2008-non-exhaustive/enum.rs
View File

@ -30,7 +30,7 @@ fn main() {
match enum_unit {
NonExhaustiveEnum::Unit => 1,
NonExhaustiveEnum::Tuple(_) => 2,
// This particular arm tests that a enum marked as non-exhaustive
// This particular arm tests that an enum marked as non-exhaustive
// will not error if its variants are matched exhaustively.
NonExhaustiveEnum::Struct { field } => field,
_ => 0 // no error with wildcard

4
src/test/ui/traits/reservation-impl/non-lattice-ok.rs
View File

@ -5,7 +5,7 @@
// Why did we ever want to do this?
//
// We want to eventually add a `impl<T> From<!> for T` impl. That impl conflicts
// We want to eventually add an `impl<T> From<!> for T` impl. That impl conflicts
// with existing impls - at least the `impl<T> From<T> for T` impl. There are
// 2 ways we thought of for dealing with that conflict:
//
@ -23,7 +23,7 @@
// actually cause any ambiguity.
//
// Now it turned out lattice specialization doesn't work it, because an
// `impl<T> From<T> for Smaht<T>` would require a `impl From<!> for Smaht<!>`,
// `impl<T> From<T> for Smaht<T>` would require an `impl From<!> for Smaht<!>`,
// breaking backwards-compatibility in a fairly painful way. So if we want to
// go with a known approach, we should go with a "marker trait overlap"-style
// approach.

2
src/test/ui/union/union-nonzero.rs
View File

@ -13,7 +13,7 @@
// optimizations to types containing unions even if they're theoretically possible. (discussion:
// https://github.com/rust-lang/rust/issues/36394)
//
// Notably this nails down part of the behavior that `MaybeUninit` assumes: that a
// Notably this nails down part of the behavior that `MaybeUninit` assumes: that an
// `Option<MaybeUninit<&u8>>` does not take advantage of non-zero optimization, and thus is a safe
// construct.

2
src/tools/clippy/clippy_lints/src/loops/manual_memcpy.rs
View File

@ -268,7 +268,7 @@ fn sub(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
}
}
/// a wrapper around `MinifyingSugg`, which carries a operator like currying
/// a wrapper around `MinifyingSugg`, which carries an operator like currying
/// so that the suggested code become more efficient (e.g. `foo + -bar` `foo - bar`).
struct Offset {
value: MinifyingSugg<'static>,

2
src/tools/clippy/clippy_lints/src/non_copy_const.rs
View File

@ -293,7 +293,7 @@ fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx ImplItem<
}) => {
if_chain! {
// Lint a trait impl item only when the definition is a generic type,
// assuming a assoc const is not meant to be a interior mutable type.
// assuming an assoc const is not meant to be an interior mutable type.
if let Some(of_trait_def_id) = of_trait_ref.trait_def_id();
if let Some(of_assoc_item) = specialization_graph::Node::Trait(of_trait_def_id)
.item(cx.tcx, impl_item.ident, AssocKind::Const, of_trait_def_id);

2
src/tools/clippy/clippy_lints/src/ranges.rs
View File

@ -51,7 +51,7 @@
///
/// ### Known problems
/// Will add unnecessary pair of parentheses when the
/// expression is not wrapped in a pair but starts with a opening parenthesis
/// expression is not wrapped in a pair but starts with an opening parenthesis
/// and ends with a closing one.
/// I.e., `let _ = (f()+1)..(f()+1)` results in `let _ = ((f()+1)..=f())`.
///

2
src/tools/clippy/clippy_lints/src/shadow.rs
View File

@ -74,7 +74,7 @@
declare_clippy_lint! {
/// ### What it does
/// Checks for bindings that shadow other bindings already in
/// scope, either without a initialization or with one that does not even use
/// scope, either without an initialization or with one that does not even use
/// the original value.
///
/// ### Why is this bad?

2
src/tools/clippy/clippy_lints/src/utils/conf.rs
View File

@ -198,7 +198,7 @@ pub(crate) fn get_configuration_metadata() -> Vec<ClippyConfiguration> {
(enum_variant_name_threshold: u64 = 3),
/// Lint: LARGE_ENUM_VARIANT.
///
/// The maximum size of a enum's variant to avoid box suggestion
/// The maximum size of an enum's variant to avoid box suggestion
(enum_variant_size_threshold: u64 = 200),
/// Lint: VERBOSE_BIT_MASK.
///

2
src/tools/clippy/clippy_utils/src/consts.rs
View File

@ -329,7 +329,7 @@ fn multi(&mut self, vec: &[Expr<'_>]) -> Option<Vec<Constant>> {
vec.iter().map(|elem| self.expr(elem)).collect::<Option<_>>()
}
/// Lookup a possibly constant expression from a `ExprKind::Path`.
/// Lookup a possibly constant expression from an `ExprKind::Path`.
fn fetch_path(&mut self, qpath: &QPath<'_>, id: HirId, ty: Ty<'tcx>) -> Option<Constant> {
let res = self.typeck_results.qpath_res(qpath, id);
match res {

2
src/tools/clippy/clippy_utils/src/lib.rs
View File

@ -583,7 +583,7 @@ pub fn trait_ref_of_method<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Optio
/// For example, if `e` represents the `v[0].a.b[x]`
/// this method will return a tuple, composed of a `Vec`
/// containing the `Expr`s for `v[0], v[0].a, v[0].a.b, v[0].a.b[x]`
/// and a `Expr` for root of them, `v`
/// and an `Expr` for root of them, `v`
fn projection_stack<'a, 'hir>(mut e: &'a Expr<'hir>) -> (Vec<&'a Expr<'hir>>, &'a Expr<'hir>) {
let mut result = vec![];
let root = loop {

2
src/tools/clippy/clippy_utils/src/sugg.rs
View File

@ -434,7 +434,7 @@ fn is_shift(op: AssocOp) -> bool {
matches!(op, AssocOp::ShiftLeft | AssocOp::ShiftRight)
}
/// Returns `true` if the operator is a arithmetic operator
/// Returns `true` if the operator is an arithmetic operator
/// (i.e., `+`, `-`, `*`, `/`, `%`).
fn is_arith(op: AssocOp) -> bool {
matches!(

2
src/tools/clippy/tests/ui/declare_interior_mutable_const/traits.rs
View File

@ -117,7 +117,7 @@ impl SelfType for AtomicUsize {
const WRAPPED_SELF: Option<Self> = Some(AtomicUsize::new(21)); //~ ERROR interior mutable
}
// Even though a constant contains a generic type, if it also have a interior mutable type,
// Even though a constant contains a generic type, if it also have an interior mutable type,
// it should be linted at the definition site.
trait BothOfCellAndGeneric<T> {
// this is a false negative in the current implementation.

2
src/tools/compiletest/src/runtest.rs
View File

@ -1733,7 +1733,7 @@ fn exec_compiled_test(&self) -> ProcRes {
}
/// For each `aux-build: foo/bar` annotation, we check to find the
/// file in a `auxiliary` directory relative to the test itself.
/// file in an `auxiliary` directory relative to the test itself.
fn compute_aux_test_paths(&self, rel_ab: &str) -> TestPaths {
let test_ab = self
.testpaths