diff options
| author | Mara Bos <m-ou.se@m-ou.se> | 2021-08-23 20:45:49 +0200 |
|---|---|---|
| committer | GitHub <noreply@github.com> | 2021-08-23 20:45:49 +0200 |
| commit | 5cf025f076e76d235cc3e795a22499cff9f4fc62 (patch) | |
| tree | ec87c9302f210569542f1e7c0bbc68e2978d930c | |
| parent | 6d1c5b63607336c61926b3036aeea7b8c3fbb094 (diff) | |
| parent | 2f9ddf3bc7cfa79d272b1409be80905be946d831 (diff) | |
| download | rust-5cf025f076e76d235cc3e795a22499cff9f4fc62.tar.gz rust-5cf025f076e76d235cc3e795a22499cff9f4fc62.zip | |
Rollup merge of #88230 - steffahn:a_an, r=oli-obk
Fix typos “a”→“an” Fix typos in comments; found using a regex to find some easy instance of incorrect usage of a vs. an. While automation was used to find these, every change was checked manually. Changes in submodules get separate PRs: * https://github.com/rust-lang/stdarch/pull/1201 * https://github.com/rust-lang/cargo/pull/9821 * https://github.com/rust-lang/miri/pull/1874 * https://github.com/rust-lang/rls/pull/1746 * https://github.com/rust-analyzer/rust-analyzer/pull/9984 _folks @ rust-analyzer are fast at merging…_ * https://github.com/rust-analyzer/rust-analyzer/pull/9985 * https://github.com/rust-analyzer/rust-analyzer/pull/9987 * https://github.com/rust-analyzer/rust-analyzer/pull/9989 _For `clippy`, I don’t know if the changes should better better be moved to a PR to the original repo._ <hr> This has some overlap with #88226, but neither is a strict superset of the other. If you want multiple commits, I can split it up; in that case, make sure to suggest a criterion for splitting.
150 files changed, 234 insertions, 234 deletions
diff --git a/compiler/rustc_ast/src/token.rs b/compiler/rustc_ast/src/token.rs index 15f46ef5d7f..710a592e258 100644 --- a/compiler/rustc_ast/src/token.rs +++ b/compiler/rustc_ast/src/token.rs @@ -495,7 +495,7 @@ impl Token { 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) diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs index d41b3b81466..3eb38514b3c 100644 --- a/compiler/rustc_ast_lowering/src/lib.rs +++ b/compiler/rustc_ast_lowering/src/lib.rs @@ -1265,7 +1265,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { 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 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { } /// 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"), diff --git a/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs b/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs index 61af4979e70..4ad711ccaf1 100644 --- a/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs +++ b/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs @@ -1700,7 +1700,7 @@ where /// 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>( diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs index 2139f9776b7..07e1b55afe5 100644 --- a/compiler/rustc_codegen_llvm/src/builder.rs +++ b/compiler/rustc_codegen_llvm/src/builder.rs @@ -558,7 +558,7 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { fn range_metadata(&mut self, load: &'ll Value, range: Range<u128>) { if self.sess().target.arch == "amdgpu" { - // amdgpu/LLVM does something weird and thinks a i64 value is + // amdgpu/LLVM does something weird and thinks an i64 value is // split into a v2i32, halving the bitwidth LLVM expects, // tripping an assertion. So, for now, just disable this // optimization. diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs index fe2ed21c1e3..e30c49295ba 100644 --- a/compiler/rustc_codegen_llvm/src/intrinsic.rs +++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs @@ -137,9 +137,9 @@ impl IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> { 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 + // the integer to an `i32` and truncate the result // back to the smaller type. let promoted_result = emit_va_arg(self, args[0], tcx.types.i32); self.trunc(promoted_result, llret_ty) @@ -1031,7 +1031,7 @@ fn generic_simd_intrinsic( // vector mask and returns an unsigned integer containing the most // significant bit (MSB) of each lane. - // If the vector has less than 8 lanes, an u8 is returned with zeroed + // If the vector has less than 8 lanes, a u8 is returned with zeroed // trailing bits. let expected_int_bits = in_len.max(8); match ret_ty.kind() { diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs index 7e432d27402..65869483025 100644 --- a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs +++ b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs @@ -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. diff --git a/compiler/rustc_data_structures/src/owning_ref/mod.rs b/compiler/rustc_data_structures/src/owning_ref/mod.rs index ad4b79de236..5b27a407ad4 100644 --- a/compiler/rustc_data_structures/src/owning_ref/mod.rs +++ b/compiler/rustc_data_structures/src/owning_ref/mod.rs @@ -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 @@ impl<O, T: ?Sized> OwningRef<O, T> { /// 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 @@ impl<O, T: ?Sized> OwningRef<O, T> { /// 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 @@ impl<O, T: ?Sized> OwningRef<O, 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 @@ impl<O, T: ?Sized> OwningRef<O, T> { } 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 @@ impl<O, T: ?Sized> OwningRefMut<O, T> { /// 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 @@ impl<O, T: ?Sized> OwningRefMut<O, T> { /// 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 @@ impl<O, T: ?Sized> OwningRefMut<O, T> { /// 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 @@ impl<O, T: ?Sized> OwningRefMut<O, T> { /// 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 @@ impl<O, T: ?Sized> OwningRefMut<O, 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 @@ where } } -// ^ 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 @@ impl<T: 'static> ToHandleMut for RefCell<T> { // 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 an `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 @@ unsafe impl<'a, T: Send + Sync + 'a> IntoErasedSendSync<'a> for Arc<T> { } } -/// 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. diff --git a/compiler/rustc_data_structures/src/profiling.rs b/compiler/rustc_data_structures/src/profiling.rs index ef101c56ab5..0bbd0eda0c6 100644 --- a/compiler/rustc_data_structures/src/profiling.rs +++ b/compiler/rustc_data_structures/src/profiling.rs @@ -220,7 +220,7 @@ impl SelfProfilerRef { 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. diff --git a/compiler/rustc_data_structures/src/sync.rs b/compiler/rustc_data_structures/src/sync.rs index 722ce6b6367..f99ca53ab25 100644 --- a/compiler/rustc_data_structures/src/sync.rs +++ b/compiler/rustc_data_structures/src/sync.rs @@ -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}; diff --git a/compiler/rustc_data_structures/src/tiny_list.rs b/compiler/rustc_data_structures/src/tiny_list.rs index f88bcc29481..9b07f86846e 100644 --- a/compiler/rustc_data_structures/src/tiny_list.rs +++ b/compiler/rustc_data_structures/src/tiny_list.rs @@ -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 diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs index 4e233ed1457..888d1c1832b 100644 --- a/compiler/rustc_hir/src/hir.rs +++ b/compiler/rustc_hir/src/hir.rs @@ -974,7 +974,7 @@ pub enum PatKind<'hir> { /// Invariant: `pats.len() >= 2`. Or(&'hir [Pat<'hir>]), - /// A path pattern for an unit struct/variant or a (maybe-associated) constant. + /// A path pattern for a unit struct/variant or a (maybe-associated) constant. Path(QPath<'hir>), /// A tuple pattern (e.g., `(a, b)`). @@ -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 diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs index 1cbe3b12c82..7f153867596 100644 --- a/compiler/rustc_hir/src/intravisit.rs +++ b/compiler/rustc_hir/src/intravisit.rs @@ -313,7 +313,7 @@ pub trait Visitor<'v>: Sized { } /// 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 diff --git a/compiler/rustc_infer/src/infer/error_reporting/mod.rs b/compiler/rustc_infer/src/infer/error_reporting/mod.rs index 3d48d4c2fca..4830158c15a 100644 --- a/compiler/rustc_infer/src/infer/error_reporting/mod.rs +++ b/compiler/rustc_infer/src/infer/error_reporting/mod.rs @@ -1697,7 +1697,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { } // 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 = diff --git a/compiler/rustc_infer/src/infer/nll_relate/mod.rs b/compiler/rustc_infer/src/infer/nll_relate/mod.rs index 261c3471a98..042e6159aff 100644 --- a/compiler/rustc_infer/src/infer/nll_relate/mod.rs +++ b/compiler/rustc_infer/src/infer/nll_relate/mod.rs @@ -307,7 +307,7 @@ where /// relations between `'0` and `'a`). /// /// The variable `pair` can be either a `(vid, ty)` or `(ty, vid)` - /// -- in other words, it is always a (unresolved) inference + /// -- in other words, it is always an (unresolved) inference /// variable `vid` and a type `ty` that are being related, but the /// vid may appear either as the "a" type or the "b" type, /// depending on where it appears in the tuple. The trait @@ -389,7 +389,7 @@ where } } -/// 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 diff --git a/compiler/rustc_infer/src/infer/region_constraints/mod.rs b/compiler/rustc_infer/src/infer/region_constraints/mod.rs index 5adbfd469a4..af31ab0923d 100644 --- a/compiler/rustc_infer/src/infer/region_constraints/mod.rs +++ b/compiler/rustc_infer/src/infer/region_constraints/mod.rs @@ -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 diff --git a/compiler/rustc_infer/src/infer/undo_log.rs b/compiler/rustc_infer/src/infer/undo_log.rs index 5ad2519a93c..89db8f464b4 100644 --- a/compiler/rustc_infer/src/infer/undo_log.rs +++ b/compiler/rustc_infer/src/infer/undo_log.rs @@ -96,7 +96,7 @@ impl Default for InferCtxtUndoLogs<'_> { } /// The UndoLogs trait defines how we undo a particular kind of action (of type T). We can undo any -/// action that is convertable into a UndoLog (per the From impls above). +/// action that is convertable into an UndoLog (per the From impls above). impl<'tcx, T> UndoLogs<T> for InferCtxtUndoLogs<'tcx> where UndoLog<'tcx>: From<T>, diff --git a/compiler/rustc_infer/src/traits/mod.rs b/compiler/rustc_infer/src/traits/mod.rs index d5c17ede214..b450c398946 100644 --- a/compiler/rustc_infer/src/traits/mod.rs +++ b/compiler/rustc_infer/src/traits/mod.rs @@ -28,7 +28,7 @@ pub use self::project::{ 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 diff --git a/compiler/rustc_lexer/src/lib.rs b/compiler/rustc_lexer/src/lib.rs index b5e6d256a99..b64a891cb25 100644 --- a/compiler/rustc_lexer/src/lib.rs +++ b/compiler/rustc_lexer/src/lib.rs @@ -489,7 +489,7 @@ impl Cursor<'_> { // Start is already eaten, eat the rest of identifier. self.eat_while(is_id_continue); // Known prefixes must have been handled earlier. So if - // we see a prefix here, it is definitely a unknown prefix. + // we see a prefix here, it is definitely an unknown prefix. match self.first() { '#' | '"' | '\'' => UnknownPrefix, _ => Ident, diff --git a/compiler/rustc_lint/src/nonstandard_style.rs b/compiler/rustc_lint/src/nonstandard_style.rs index 7f71923c91a..03344973bb3 100644 --- a/compiler/rustc_lint/src/nonstandard_style.rs +++ b/compiler/rustc_lint/src/nonstandard_style.rs @@ -118,7 +118,7 @@ fn to_camel_case(s: &str) -> String { }) .fold((String::new(), None), |(acc, prev): (String, Option<String>), next| { // separate two components with an underscore if their boundary cannot - // be distinguished using a uppercase/lowercase case distinction + // be distinguished using an uppercase/lowercase case distinction let join = if let Some(prev) = prev { let l = prev.chars().last().unwrap(); let f = next.chars().next().unwrap(); diff --git a/compiler/rustc_lint/src/types.rs b/compiler/rustc_lint/src/types.rs index 34d342e6694..e25c51991f5 100644 --- a/compiler/rustc_lint/src/types.rs +++ b/compiler/rustc_lint/src/types.rs @@ -1171,7 +1171,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> { 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) diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs index 457be5e7a58..b51eaf8e353 100644 --- a/compiler/rustc_lint_defs/src/builtin.rs +++ b/compiler/rustc_lint_defs/src/builtin.rs @@ -3375,7 +3375,7 @@ declare_lint! { } declare_lint! { - /// The `unsupported_calling_conventions` lint is output whenever there is an use of the + /// The `unsupported_calling_conventions` lint is output whenever there is a use of the /// `stdcall`, `fastcall`, `thiscall`, `vectorcall` calling conventions (or their unwind /// variants) on targets that cannot meaningfully be supported for the requested target. /// diff --git a/compiler/rustc_metadata/src/rmeta/decoder.rs b/compiler/rustc_metadata/src/rmeta/decoder.rs index 8bdd4313de4..4e591b28f60 100644 --- a/compiler/rustc_metadata/src/rmeta/decoder.rs +++ b/compiler/rustc_metadata/src/rmeta/decoder.rs @@ -62,7 +62,7 @@ crate struct CrateMetadata { // --- Some data pre-decoded from the metadata blob, usually for performance --- /// Properties of the whole crate. /// NOTE(eddyb) we pass `'static` to a `'tcx` parameter because this - /// lifetime is only used behind `Lazy`, and therefore acts like an + /// lifetime is only used behind `Lazy`, and therefore acts like a /// universal (`for<'tcx>`), that is paired up with whichever `TyCtxt` /// is being used to decode those values. root: CrateRoot<'static>, diff --git a/compiler/rustc_middle/src/hir/map/blocks.rs b/compiler/rustc_middle/src/hir/map/blocks.rs index 706c7900949..8efec8ef567 100644 --- a/compiler/rustc_middle/src/hir/map/blocks.rs +++ b/compiler/rustc_middle/src/hir/map/blocks.rs @@ -63,7 +63,7 @@ impl MaybeFnLike for hir::Expr<'_> { } } -/// 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)] diff --git a/compiler/rustc_middle/src/middle/region.rs b/compiler/rustc_middle/src/middle/region.rs index ffa26b9f299..6c92c65a6dd 100644 --- a/compiler/rustc_middle/src/middle/region.rs +++ b/compiler/rustc_middle/src/middle/region.rs @@ -151,7 +151,7 @@ rustc_index::newtype_index! { 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`. diff --git a/compiler/rustc_middle/src/mir/interpret/error.rs b/compiler/rustc_middle/src/mir/interpret/error.rs index 4826c96000c..5d17bb9b15f 100644 --- a/compiler/rustc_middle/src/mir/interpret/error.rs +++ b/compiler/rustc_middle/src/mir/interpret/error.rs @@ -46,7 +46,7 @@ static_assert_size!(InterpErrorInfo<'_>, 8); /// 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>>); diff --git a/compiler/rustc_middle/src/mir/interpret/value.rs b/compiler/rustc_middle/src/mir/interpret/value.rs index 62b71b10d5a..cc31d8c2c18 100644 --- a/compiler/rustc_middle/src/mir/interpret/value.rs +++ b/compiler/rustc_middle/src/mir/interpret/value.rs @@ -17,7 +17,7 @@ use super::{ /// 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 @@ impl<'tcx> ConstValue<'tcx> { } /// 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` /// @@ -376,27 +376,27 @@ impl<'tcx, Tag: Provenance> Scalar<Tag> { self.to_bits(sz) } - /// Converts the scalar to produce an `u8`. Fails if the scalar is a pointer. + /// Converts the scalar to produce a `u8`. Fails if the scalar is a pointer. pub fn to_u8(self) -> InterpResult<'static, u8> { self.to_unsigned_with_bit_width(8).map(|v| u8::try_from(v).unwrap()) } - /// Converts the scalar to produce an `u16`. Fails if the scalar is a pointer. + /// Converts the scalar to produce a `u16`. Fails if the scalar is a pointer. pub fn to_u16(self) -> InterpResult<'static, u16> { self.to_unsigned_with_bit_width(16).map(|v| u16::try_from(v).unwrap()) } - /// Converts the scalar to produce an `u32`. Fails if the scalar is a pointer. + /// Converts the scalar to produce a `u32`. Fails if the scalar is a pointer. pub fn to_u32(self) -> InterpResult<'static, u32> { self.to_unsigned_with_bit_width(32).map(|v| u32::try_from(v).unwrap()) } - /// Converts the scalar to produce an `u64`. Fails if the scalar is a pointer. + /// Converts the scalar to produce a `u64`. Fails if the scalar is a pointer. pub fn to_u64(self) -> InterpResult<'static, u64> { self.to_unsigned_with_bit_width(64).map(|v| u64::try_from(v).unwrap()) } - /// Converts the scalar to produce an `u128`. Fails if the scalar is a pointer. + /// Converts the scalar to produce a `u128`. Fails if the scalar is a pointer. pub fn to_u128(self) -> InterpResult<'static, u128> { self.to_unsigned_with_bit_width(128) } diff --git a/compiler/rustc_middle/src/mir/tcx.rs b/compiler/rustc_middle/src/mir/tcx.rs index 6e819145976..74d303cee5d 100644 --- a/compiler/rustc_middle/src/mir/tcx.rs +++ b/compiler/rustc_middle/src/mir/tcx.rs @@ -265,7 +265,7 @@ impl BorrowKind { BorrowKind::Shared => hir::Mutability::Not, // We have no type corresponding to a unique imm borrow, so - // use `&mut`. It gives all the capabilities of an `&uniq` + // use `&mut`. It gives all the capabilities of a `&uniq` // and hence is a safe "over approximation". BorrowKind::Unique => hir::Mutability::Mut, diff --git a/compiler/rustc_middle/src/mir/visit.rs b/compiler/rustc_middle/src/mir/visit.rs index 5516a045c1d..45ea3e3d9f3 100644 --- a/compiler/rustc_middle/src/mir/visit.rs +++ b/compiler/rustc_middle/src/mir/visit.rs @@ -1202,7 +1202,7 @@ pub enum NonUseContext { StorageDead, /// User type annotation assertions for NLL. AscribeUserTy, - /// The data of an user variable, for debug info. + /// The data of a user variable, for debug info. VarDebugInfo, } diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs index 85b1274da10..68de7f29193 100644 --- a/compiler/rustc_middle/src/query/mod.rs +++ b/compiler/rustc_middle/src/query/mod.rs @@ -648,7 +648,7 @@ rustc_queries! { } } - /// HACK: when evaluated, this reports a "unsafe derive on repr(packed)" error. + /// HACK: when evaluated, this reports an "unsafe derive on repr(packed)" error. /// /// Unsafety checking is executed for each method separately, but we only want /// to emit this error once per derive. As there are some impls with multiple @@ -1733,7 +1733,7 @@ rustc_queries! { } /// Performs an HIR-based well-formed check on the item with the given `HirId`. If - /// we get an `Umimplemented` error that matches the provided `Predicate`, return + /// we get an `Unimplemented` error that matches the provided `Predicate`, return /// the cause of the newly created obligation. /// /// This is only used by error-reporting code to get a better cause (in particular, a better diff --git a/compiler/rustc_middle/src/traits/mod.rs b/compiler/rustc_middle/src/traits/mod.rs index 469da858ccf..457e80c1663 100644 --- a/compiler/rustc_middle/src/traits/mod.rs +++ b/compiler/rustc_middle/src/traits/mod.rs @@ -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>), diff --git a/compiler/rustc_middle/src/traits/select.rs b/compiler/rustc_middle/src/traits/select.rs index 3b7c201f3ee..62996bf4cbe 100644 --- a/compiler/rustc_middle/src/traits/select.rs +++ b/compiler/rustc_middle/src/traits/select.rs @@ -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 diff --git a/compiler/rustc_middle/src/ty/adt.rs b/compiler/rustc_middle/src/ty/adt.rs index 95159ea46ae..27927bcca72 100644 --- a/compiler/rustc_middle/src/ty/adt.rs +++ b/compiler/rustc_middle/src/ty/adt.rs @@ -209,7 +209,7 @@ impl<'tcx> AdtDef { 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) diff --git a/compiler/rustc_middle/src/ty/closure.rs b/compiler/rustc_middle/src/ty/closure.rs index dd6ca9bd8c8..4eacb3c4176 100644 --- a/compiler/rustc_middle/src/ty/closure.rs +++ b/compiler/rustc_middle/src/ty/closure.rs @@ -434,7 +434,7 @@ impl BorrowKind { ImmBorrow => hir::Mutability::Not, // We have no type corresponding to a unique imm borrow, so - // use `&mut`. It gives all the capabilities of an `&uniq` + // use `&mut`. It gives all the capabilities of a `&uniq` // and hence is a safe "over approximation". UniqueImmBorrow => hir::Mutability::Mut, } diff --git a/compiler/rustc_middle/src/ty/codec.rs b/compiler/rustc_middle/src/ty/codec.rs index fb13614e4b3..36db258e92d 100644 --- a/compiler/rustc_middle/src/ty/codec.rs +++ b/compiler/rustc_middle/src/ty/codec.rs @@ -209,7 +209,7 @@ where impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for Ty<'tcx> { #[allow(rustc::usage_of_ty_tykind)] fn decode(decoder: &mut D) -> Result<Ty<'tcx>, D::Error> { - // Handle shorthands first, if we have an usize > 0x80. + // Handle shorthands first, if we have a usize > 0x80. if decoder.positioned_at_shorthand() { let pos = decoder.read_usize()?; assert!(pos >= SHORTHAND_OFFSET); @@ -228,7 +228,7 @@ impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for Ty<'tcx> { impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for ty::Binder<'tcx, ty::PredicateKind<'tcx>> { fn decode(decoder: &mut D) -> Result<ty::Binder<'tcx, ty::PredicateKind<'tcx>>, D::Error> { let bound_vars = Decodable::decode(decoder)?; - // Handle shorthands first, if we have an usize > 0x80. + // Handle shorthands first, if we have a usize > 0x80. Ok(ty::Binder::bind_with_vars( if decoder.positioned_at_shorthand() { let pos = decoder.read_usize()?; diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs index 106b443ee3c..28e894c5cae 100644 --- a/compiler/rustc_middle/src/ty/context.rs +++ b/compiler/rustc_middle/src/ty/context.rs @@ -1792,7 +1792,7 @@ pub mod tls { 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<'_, '_>>(); diff --git a/compiler/rustc_middle/src/ty/inhabitedness/mod.rs b/compiler/rustc_middle/src/ty/inhabitedness/mod.rs index 119cb135046..77d82ee6eae 100644 --- a/compiler/rustc_middle/src/ty/inhabitedness/mod.rs +++ b/compiler/rustc_middle/src/ty/inhabitedness/mod.rs @@ -9,7 +9,7 @@ use crate::ty::{DefId, SubstsRef}; 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 diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs index 3caca313ffd..80c99872dd7 100644 --- a/compiler/rustc_middle/src/ty/layout.rs +++ b/compiler/rustc_middle/src/ty/layout.rs @@ -2571,14 +2571,14 @@ where /// 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( diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs index 9fcf35b7320..62e093581b8 100644 --- a/compiler/rustc_middle/src/ty/mod.rs +++ b/compiler/rustc_middle/src/ty/mod.rs @@ -865,7 +865,7 @@ impl<'tcx> Predicate<'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 @@ bitflags! { } } -/// 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. diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs index a1edb8071c4..8e0a2d4a28d 100644 --- a/compiler/rustc_middle/src/ty/sty.rs +++ b/compiler/rustc_middle/src/ty/sty.rs @@ -239,7 +239,7 @@ static_assert_size!(TyKind<'_>, 32); /// implements `CK<(u32, u32), Output = u32>`, where `CK` is the trait /// specified above. /// - U is a type parameter representing the types of its upvars, tupled up -/// (borrowed, if appropriate; that is, if an U field represents a by-ref upvar, +/// (borrowed, if appropriate; that is, if a U field represents a by-ref upvar, /// and the up-var has the type `Foo`, then that field of U will be `&Foo`). /// /// So, for example, given this function: @@ -1323,7 +1323,7 @@ pub type Region<'tcx> = &'tcx RegionKind; /// 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 type PolyExistentialProjection<'tcx> = Binder<'tcx, ExistentialProjection<'t 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(); diff --git a/compiler/rustc_middle/src/ty/subst.rs b/compiler/rustc_middle/src/ty/subst.rs index 9b8d22d8eaf..4fbb4d1806f 100644 --- a/compiler/rustc_middle/src/ty/subst.rs +++ b/compiler/rustc_middle/src/ty/subst.rs @@ -22,7 +22,7 @@ use std::ops::ControlFlow; /// 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 @@ impl<'a, 'tcx> InternalSubsts<'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 diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs index 9ba85e58018..a78206034f0 100644 --- a/compiler/rustc_middle/src/ty/util.rs +++ b/compiler/rustc_middle/src/ty/util.rs @@ -681,7 +681,7 @@ impl<'tcx> ty::TyS<'tcx> { } /// Checks whether values of this type `T` implement the `Freeze` - /// trait -- frozen types are those that do not contain a + /// trait -- frozen types are those that do not contain an /// `UnsafeCell` anywhere. This is a language concept used to /// distinguish "true immutability", which is relevant to /// optimization as well as the rules around static values. Note diff --git a/compiler/rustc_mir/src/borrow_check/diagnostics/conflict_errors.rs b/compiler/rustc_mir/src/borrow_check/diagnostics/conflict_errors.rs index a3ea1700634..6561fe37c1c 100644 --- a/compiler/rustc_mir/src/borrow_check/diagnostics/conflict_errors.rs +++ b/compiler/rustc_mir/src/borrow_check/diagnostics/conflict_errors.rs @@ -825,7 +825,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { // 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 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { }) .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) { diff --git a/compiler/rustc_mir/src/borrow_check/diagnostics/explain_borrow.rs b/compiler/rustc_mir/src/borrow_check/diagnostics/explain_borrow.rs index 76de010d139..f40a2db330a 100644 --- a/compiler/rustc_mir/src/borrow_check/diagnostics/explain_borrow.rs +++ b/compiler/rustc_mir/src/borrow_check/diagnostics/explain_borrow.rs @@ -606,7 +606,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { /// Checks if a borrowed value was captured by a trait object. We do this by /// looking forward in the MIR from the reserve location and checking if we see - /// a unsized cast to a trait object on our data. + /// an unsized cast to a trait object on our data. fn was_captured_by_trait_object(&self, borrow: &BorrowData<'tcx>) -> bool { // Start at the reserve location, find the place that we want to see cast to a trait object. let location = borrow.reserve_location; @@ -666,7 +666,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { } _ => {} }, - // If we see a unsized cast, then if it is our data we should check + // If we see an unsized cast, then if it is our data we should check // whether it is being cast to a trait object. Rvalue::Cast(CastKind::Pointer(PointerCast::Unsize), operand, ty) => { match operand { diff --git a/compiler/rustc_mir/src/borrow_check/diagnostics/mutability_errors.rs b/compiler/rustc_mir/src/borrow_check/diagnostics/mutability_errors.rs index 5932cb9e775..7be3f541487 100644 --- a/compiler/rustc_mir/src/borrow_check/diagnostics/mutability_errors.rs +++ b/compiler/rustc_mir/src/borrow_check/diagnostics/mutability_errors.rs @@ -72,7 +72,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> { // 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 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> { 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 diff --git a/compiler/rustc_mir/src/borrow_check/diagnostics/region_errors.rs b/compiler/rustc_mir/src/borrow_check/diagnostics/region_errors.rs index fe9df41db45..cbb8f064bb8 100644 --- a/compiler/rustc_mir/src/borrow_check/diagnostics/region_errors.rs +++ b/compiler/rustc_mir/src/borrow_check/diagnostics/region_errors.rs @@ -423,7 +423,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> { 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 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> { 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 diff --git a/compiler/rustc_mir/src/borrow_check/mod.rs b/compiler/rustc_mir/src/borrow_check/mod.rs index 9f7decad969..1dcb0676562 100644 --- a/compiler/rustc_mir/src/borrow_check/mod.rs +++ b/compiler/rustc_mir/src/borrow_check/mod.rs @@ -1241,7 +1241,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { } } - // 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 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { // 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 @@ -1889,7 +1889,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { ProjectionElem::Downcast(_/*adt_def*/, _/*variant_idx*/) => // assigning to (P->variant) is okay if assigning to `P` is okay // - // FIXME: is this true even if P is a adt with a dtor? + // FIXME: is this true even if P is an adt with a dtor? { } // assigning to (*P) requires P to be initialized @@ -2003,8 +2003,8 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'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 + // Check for a reassignment into an uninitialized field of a union (for example, + // 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. diff --git a/compiler/rustc_mir/src/borrow_check/universal_regions.rs b/compiler/rustc_mir/src/borrow_check/universal_regions.rs index c2ac1e289ce..3c9b4272b36 100644 --- a/compiler/rustc_mir/src/borrow_check/universal_regions.rs +++ b/compiler/rustc_mir/src/borrow_check/universal_regions.rs @@ -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>, diff --git a/compiler/rustc_mir/src/interpret/operand.rs b/compiler/rustc_mir/src/interpret/operand.rs index baef2a5a52c..81f78621d14 100644 --- a/compiler/rustc_mir/src/interpret/operand.rs +++ b/compiler/rustc_mir/src/interpret/operand.rs @@ -295,7 +295,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { /// 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>, diff --git a/compiler/rustc_mir/src/interpret/validity.rs b/compiler/rustc_mir/src/interpret/validity.rs index 0c7f89c1a36..b0cd6405eb9 100644 --- a/compiler/rustc_mir/src/interpret/validity.rs +++ b/compiler/rustc_mir/src/interpret/validity.rs @@ -857,7 +857,7 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValueVisitor<'mir, 'tcx, M> // types above, in `visit_primitive`. // In run-time mode, we accept pointers in here. This is actually more // permissive than a per-element check would be, e.g., we accept - // an &[u8] that contains a pointer even though bytewise checking would + // a &[u8] that contains a pointer even though bytewise checking would // reject it. However, that's good: We don't inherently want // to reject those pointers, we just do not have the machinery to // talk about parts of a pointer. diff --git a/compiler/rustc_mir/src/monomorphize/partitioning/default.rs b/compiler/rustc_mir/src/monomorphize/partitioning/default.rs index 541c825416c..a559a6ce415 100644 --- a/compiler/rustc_mir/src/monomorphize/partitioning/default.rs +++ b/compiler/rustc_mir/src/monomorphize/partitioning/default.rs @@ -455,7 +455,7 @@ fn mono_item_visibility( def_id } else { return if export_generics && is_generic { - // If it is a upstream monomorphization and we export generics, we must make + // If it is an upstream monomorphization and we export generics, we must make // it available to downstream crates. *can_be_internalized = false; default_visibility(tcx, def_id, true) diff --git a/compiler/rustc_mir/src/transform/check_consts/ops.rs b/compiler/rustc_mir/src/transform/check_consts/ops.rs index ddca22aebd2..8923d989b29 100644 --- a/compiler/rustc_mir/src/transform/check_consts/ops.rs +++ b/compiler/rustc_mir/src/transform/check_consts/ops.rs @@ -86,7 +86,7 @@ impl NonConstOp for FnCallNonConst { } } -/// A call to a `#[unstable]` const fn or `#[rustc_const_unstable]` function. +/// A call to an `#[unstable]` const fn or `#[rustc_const_unstable]` function. /// /// Contains the name of the feature that would allow the use of this function. #[derive(Debug)] diff --git a/compiler/rustc_mir/src/transform/const_prop.rs b/compiler/rustc_mir/src/transform/const_prop.rs index e02e41d6206..4578f04c034 100644 --- a/compiler/rustc_mir/src/transform/const_prop.rs +++ b/compiler/rustc_mir/src/transform/const_prop.rs @@ -145,7 +145,7 @@ impl<'tcx> MirPass<'tcx> for ConstProp { // FIXME(oli-obk, eddyb) Optimize locals (or even local paths) to hold // constants, instead of just checking for const-folding succeeding. - // That would require an uniform one-def no-mutation analysis + // That would require a uniform one-def no-mutation analysis // and RPO (or recursing when needing the value of a local). let mut optimization_finder = ConstPropagator::new(body, dummy_body, tcx); optimization_finder.visit_body(body); diff --git a/compiler/rustc_mir/src/transform/coverage/counters.rs b/compiler/rustc_mir/src/transform/coverage/counters.rs index 272a7bf9617..6726b669ff2 100644 --- a/compiler/rustc_mir/src/transform/coverage/counters.rs +++ b/compiler/rustc_mir/src/transform/coverage/counters.rs @@ -100,7 +100,7 @@ impl CoverageCounters { 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 { diff --git a/compiler/rustc_mir/src/transform/coverage/mod.rs b/compiler/rustc_mir/src/transform/coverage/mod.rs index 406a8832d26..f7fbea6ad53 100644 --- a/compiler/rustc_mir/src/transform/coverage/mod.rs +++ b/compiler/rustc_mir/src/transform/coverage/mod.rs @@ -334,7 +334,7 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> { /// 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( diff --git a/compiler/rustc_mir/src/transform/rustc_peek.rs b/compiler/rustc_mir/src/transform/rustc_peek.rs index a6b8f20f6d4..f4a1b0ddba5 100644 --- a/compiler/rustc_mir/src/transform/rustc_peek.rs +++ b/compiler/rustc_mir/src/transform/rustc_peek.rs @@ -88,11 +88,11 @@ impl<'tcx> MirPass<'tcx> for SanityCheck { /// 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 -/// putting code into an UI test and using `rustc_peek` to +/// putting code into a UI test and using `rustc_peek` to /// make observations about the results of dataflow static analyses. /// /// (If there are any calls to `rustc_peek` that do not match the diff --git a/compiler/rustc_mir_build/src/build/expr/into.rs b/compiler/rustc_mir_build/src/build/expr/into.rs index b2e03f13479..21c5a64f823 100644 --- a/compiler/rustc_mir_build/src/build/expr/into.rs +++ b/compiler/rustc_mir_build/src/build/expr/into.rs @@ -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 @@ -208,7 +208,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { ); this.diverge_from(loop_block); - // The “return” value of the loop body must always be an unit. We therefore + // The “return” value of the loop body must always be a unit. We therefore // introduce a unit temporary as the destination for the loop body. let tmp = this.get_unit_temp(); // Execute the body, branching back to the test. diff --git a/compiler/rustc_mir_build/src/build/matches/mod.rs b/compiler/rustc_mir_build/src/build/matches/mod.rs index 6e16ee94c50..a36af024ad8 100644 --- a/compiler/rustc_mir_build/src/build/matches/mod.rs +++ b/compiler/rustc_mir_build/src/build/matches/mod.rs @@ -1936,7 +1936,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { // } // ``` // - // would yield a `arm_block` something like: + // would yield an `arm_block` something like: // // ``` // StorageLive(_4); // _4 is `x` diff --git a/compiler/rustc_mir_build/src/build/mod.rs b/compiler/rustc_mir_build/src/build/mod.rs index 988cc625422..bfebe860971 100644 --- a/compiler/rustc_mir_build/src/build/mod.rs +++ b/compiler/rustc_mir_build/src/build/mod.rs @@ -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 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { 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 diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs index 6bbf1faf483..f1d882e1ddd 100644 --- a/compiler/rustc_mir_build/src/thir/cx/expr.rs +++ b/compiler/rustc_mir_build/src/thir/cx/expr.rs @@ -788,7 +788,7 @@ impl<'tcx> Cx<'tcx> { self.user_substs_applied_to_ty_of_hir_id(hir_id) } - // `Self` is used in expression as a tuple struct constructor or an unit struct constructor + // `Self` is used in expression as a tuple struct constructor or a unit struct constructor Res::SelfCtor(_) => self.user_substs_applied_to_ty_of_hir_id(hir_id), _ => bug!("user_substs_applied_to_res: unexpected res {:?} at {:?}", res, hir_id), diff --git a/compiler/rustc_mir_build/src/thir/pattern/usefulness.rs b/compiler/rustc_mir_build/src/thir/pattern/usefulness.rs index 5d4eb75155a..344006e9fb4 100644 --- a/compiler/rustc_mir_build/src/thir/pattern/usefulness.rs +++ b/compiler/rustc_mir_build/src/thir/pattern/usefulness.rs @@ -762,7 +762,7 @@ impl<'p, 'tcx> SubPatSet<'p, 'tcx> { for i in 0..*alt_count { let sub_set = subpats.get(&i).unwrap_or(&SubPatSet::Empty); if sub_set.is_empty() { - // Found a unreachable subpattern. + // Found an unreachable subpattern. spans.push(expanded[i].span); } else { fill_spans(sub_set, spans); diff --git a/compiler/rustc_parse/src/parser/attr_wrapper.rs b/compiler/rustc_parse/src/parser/attr_wrapper.rs index e1d0b84f419..9f06bdcc135 100644 --- a/compiler/rustc_parse/src/parser/attr_wrapper.rs +++ b/compiler/rustc_parse/src/parser/attr_wrapper.rs @@ -301,7 +301,7 @@ impl<'a> Parser<'a> { // 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 @@ impl<'a> Parser<'a> { } 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() @@ -486,7 +486,7 @@ fn make_token_stream( if let AttrAnnotatedTokenTree::Token(last_token) = last_token { let unglued_first = last_token.kind.break_two_token_op().unwrap().0; - // A 'unglued' token is always two ASCII characters + // An 'unglued' token is always two ASCII characters let mut first_span = last_token.span.shrink_to_lo(); first_span = first_span.with_hi(first_span.lo() + rustc_span::BytePos(1)); diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs index 6259eff5a1a..326c8f81ffb 100644 --- a/compiler/rustc_parse/src/parser/expr.rs +++ b/compiler/rustc_parse/src/parser/expr.rs @@ -1092,7 +1092,7 @@ impl<'a> Parser<'a> { // 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()`. diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs index 51d4e007b59..4c3c140d171 100644 --- a/compiler/rustc_parse/src/parser/mod.rs +++ b/compiler/rustc_parse/src/parser/mod.rs @@ -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 type ReplaceRange = (Range<u32>, Vec<(FlatToken, Spacing)>); /// 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, } diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs index a683cb05e16..281995c3755 100644 --- a/compiler/rustc_privacy/src/lib.rs +++ b/compiler/rustc_privacy/src/lib.rs @@ -575,7 +575,7 @@ impl EmbargoVisitor<'tcx> { } } - /// 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`. /// diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs index a602a58e517..9d923599db7 100644 --- a/compiler/rustc_resolve/src/late/diagnostics.rs +++ b/compiler/rustc_resolve/src/late/diagnostics.rs @@ -1826,7 +1826,7 @@ impl<'tcx> LifetimeContext<'_, 'tcx> { err.emit(); } - // FIXME(const_generics): This patches over a ICE caused by non-'static lifetimes in const + // FIXME(const_generics): This patches over an ICE caused by non-'static lifetimes in const // generics. We are disallowing this until we can decide on how we want to handle non-'static // lifetimes in const generics. See issue #74052 for discussion. crate fn emit_non_static_lt_in_const_generic_error(&self, lifetime_ref: &hir::Lifetime) { diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs index 465007507da..18475444f68 100644 --- a/compiler/rustc_resolve/src/lib.rs +++ b/compiler/rustc_resolve/src/lib.rs @@ -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 { .. }) } @@ -3065,7 +3065,7 @@ impl<'a> Resolver<'a> { 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); @@ -3160,7 +3160,7 @@ impl<'a> Resolver<'a> { } } - /// This function adds a suggestion to remove a unnecessary binding from an import that is + /// This function adds a suggestion to remove an unnecessary binding from an import that is /// nested. In the following example, this function will be invoked to remove the `a` binding /// in the second use statement: /// @@ -3212,7 +3212,7 @@ impl<'a> Resolver<'a> { 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, diff --git a/compiler/rustc_serialize/src/json.rs b/compiler/rustc_serialize/src/json.rs index 4d213207fb6..e5369b4bbfd 100644 --- a/compiler/rustc_serialize/src/json.rs +++ b/compiler/rustc_serialize/src/json.rs @@ -1202,7 +1202,7 @@ impl Json { matches!(*self, Json::I64(_) | Json::U64(_) | Json::F64(_)) } - /// Returns `true` if the Json value is a `i64`. + /// Returns `true` if the Json value is an `i64`. pub fn is_i64(&self) -> bool { matches!(*self, Json::I64(_)) } @@ -1217,7 +1217,7 @@ impl Json { matches!(*self, Json::F64(_)) } - /// If the Json value is a number, returns or cast it to a `i64`; + /// If the Json value is a number, returns or cast it to an `i64`; /// returns `None` otherwise. pub fn as_i64(&self) -> Option<i64> { match *self { diff --git a/compiler/rustc_serialize/src/serialize.rs b/compiler/rustc_serialize/src/serialize.rs index 4d9aaaecec8..ecc8dae0480 100644 --- a/compiler/rustc_serialize/src/serialize.rs +++ b/compiler/rustc_serialize/src/serialize.rs @@ -644,7 +644,7 @@ impl<D: Decoder, T: Decodable<D> + Copy> Decodable<D> for Cell<T> { } // 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`. diff --git a/compiler/rustc_span/src/source_map.rs b/compiler/rustc_span/src/source_map.rs index 77a3ad931d5..f700397fcdf 100644 --- a/compiler/rustc_span/src/source_map.rs +++ b/compiler/rustc_span/src/source_map.rs @@ -100,7 +100,7 @@ pub trait FileLoader { /// Query the existence of a file. fn file_exists(&self, path: &Path) -> bool; - /// Read the contents of an UTF-8 file into memory. + /// Read the contents of a UTF-8 file into memory. fn read_file(&self, path: &Path) -> io::Result<String>; } diff --git a/compiler/rustc_target/src/asm/mod.rs b/compiler/rustc_target/src/asm/mod.rs index 9ebf8235e20..bb24f7bb135 100644 --- a/compiler/rustc_target/src/asm/mod.rs +++ b/compiler/rustc_target/src/asm/mod.rs @@ -469,7 +469,7 @@ impl InlineAsmRegClass { } } - /// 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, diff --git a/compiler/rustc_trait_selection/src/opaque_types.rs b/compiler/rustc_trait_selection/src/opaque_types.rs index e6686b8cc70..c5a6e301deb 100644 --- a/compiler/rustc_trait_selection/src/opaque_types.rs +++ b/compiler/rustc_trait_selection/src/opaque_types.rs @@ -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 @@ impl<'a, 'tcx> Instantiator<'a, 'tcx> { // } // ``` // - // 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 diff --git a/compiler/rustc_trait_selection/src/traits/codegen.rs b/compiler/rustc_trait_selection/src/traits/codegen.rs index 45853a66efc..f06f0e32f41 100644 --- a/compiler/rustc_trait_selection/src/traits/codegen.rs +++ b/compiler/rustc_trait_selection/src/traits/codegen.rs @@ -12,7 +12,7 @@ use rustc_errors::ErrorReported; 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 diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs index 2c09c551b65..90b6ee5f5a6 100644 --- a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs +++ b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs @@ -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)>), diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs index 003642ff259..40841a6e32d 100644 --- a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs +++ b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs @@ -1365,7 +1365,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> { // 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: // diff --git a/compiler/rustc_trait_selection/src/traits/project.rs b/compiler/rustc_trait_selection/src/traits/project.rs index f75f7b887a5..19e3c1afb9f 100644 --- a/compiler/rustc_trait_selection/src/traits/project.rs +++ b/compiler/rustc_trait_selection/src/traits/project.rs @@ -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> diff --git a/compiler/rustc_trait_selection/src/traits/query/type_op/implied_outlives_bounds.rs b/compiler/rustc_trait_selection/src/traits/query/type_op/implied_outlives_bounds.rs index 3863dd61cef..03087e3353a 100644 --- a/compiler/rustc_trait_selection/src/traits/query/type_op/implied_outlives_bounds.rs +++ b/compiler/rustc_trait_selection/src/traits/query/type_op/implied_outlives_bounds.rs @@ -24,7 +24,7 @@ impl<'tcx> super::QueryTypeOp<'tcx> for ImpliedOutlivesBounds<'tcx> { ) -> 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) diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs index 0f2f5357eb7..ba62ce1d531 100644 --- a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs +++ b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs @@ -257,7 +257,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { 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 diff --git a/compiler/rustc_trait_selection/src/traits/specialize/mod.rs b/compiler/rustc_trait_selection/src/traits/specialize/mod.rs index 4b563a87a15..88aca794a6b 100644 --- a/compiler/rustc_trait_selection/src/traits/specialize/mod.rs +++ b/compiler/rustc_trait_selection/src/traits/specialize/mod.rs @@ -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. diff --git a/compiler/rustc_traits/src/chalk/db.rs b/compiler/rustc_traits/src/chalk/db.rs index 8c97e606c56..1d457d6761f 100644 --- a/compiler/rustc_traits/src/chalk/db.rs +++ b/compiler/rustc_traits/src/chalk/db.rs @@ -718,7 +718,7 @@ impl<'tcx> chalk_ir::UnificationDatabase<RustInterner<'tcx>> for RustIrDatabase< } } -/// 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`). diff --git a/compiler/rustc_ty_utils/src/ty.rs b/compiler/rustc_ty_utils/src/ty.rs index b0d644ae028..8332e738411 100644 --- a/compiler/rustc_ty_utils/src/ty.rs +++ b/compiler/rustc_ty_utils/src/ty.rs @@ -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 diff --git a/compiler/rustc_typeck/src/astconv/mod.rs b/compiler/rustc_typeck/src/astconv/mod.rs index 3f72a431bd1..7d7d69b4079 100644 --- a/compiler/rustc_typeck/src/astconv/mod.rs +++ b/compiler/rustc_typeck/src/astconv/mod.rs @@ -2350,7 +2350,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { } 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) diff --git a/compiler/rustc_typeck/src/check/closure.rs b/compiler/rustc_typeck/src/check/closure.rs index e4b615e4ade..65ba1c08b62 100644 --- a/compiler/rustc_typeck/src/check/closure.rs +++ b/compiler/rustc_typeck/src/check/closure.rs @@ -617,7 +617,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { /// 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>> { diff --git a/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs b/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs index bb80f0879a4..f9b7bb8ea99 100644 --- a/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs +++ b/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs @@ -743,7 +743,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { // possibly be referring to the current closure, // because we haven't produced the `Closure` for // this closure yet; this is exactly why the other - // code is looking for a self type of a unresolved + // code is looking for a self type of an unresolved // inference variable. ty::PredicateKind::ClosureKind(..) => None, ty::PredicateKind::TypeWellFormedFromEnv(..) => None, diff --git a/compiler/rustc_typeck/src/check/fn_ctxt/mod.rs b/compiler/rustc_typeck/src/check/fn_ctxt/mod.rs index a466a04bd98..16f3de58078 100644 --- a/compiler/rustc_typeck/src/check/fn_ctxt/mod.rs +++ b/compiler/rustc_typeck/src/check/fn_ctxt/mod.rs @@ -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`. diff --git a/compiler/rustc_typeck/src/check/upvar.rs b/compiler/rustc_typeck/src/check/upvar.rs index f4da3d3c870..c0b28a885db 100644 --- a/compiler/rustc_typeck/src/check/upvar.rs +++ b/compiler/rustc_typeck/src/check/upvar.rs @@ -1427,7 +1427,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { // 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 diff --git a/compiler/rustc_typeck/src/check_unused.rs b/compiler/rustc_typeck/src/check_unused.rs index 7e5cc771b31..95d3bb11723 100644 --- a/compiler/rustc_typeck/src/check_unused.rs +++ b/compiler/rustc_typeck/src/check_unused.rs @@ -155,7 +155,7 @@ fn unused_crates_lint(tcx: TyCtxt<'_>) { } // If the extern crate isn't in the extern prelude, - // there is no way it can be written as an `use`. + // there is no way it can be written as a `use`. let orig_name = extern_crate.orig_name.unwrap_or(item.ident.name); if !extern_prelude.get(&orig_name).map_or(false, |from_item| !from_item) { continue; diff --git a/compiler/rustc_typeck/src/expr_use_visitor.rs b/compiler/rustc_typeck/src/expr_use_visitor.rs index b0c95939bb7..77834feb9ad 100644 --- a/compiler/rustc_typeck/src/expr_use_visitor.rs +++ b/compiler/rustc_typeck/src/expr_use_visitor.rs @@ -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), diff --git a/compiler/rustc_typeck/src/outlives/implicit_infer.rs b/compiler/rustc_typeck/src/outlives/implicit_infer.rs index 6e6ecf6a22b..ccf0fb72738 100644 --- a/compiler/rustc_typeck/src/outlives/implicit_infer.rs +++ b/compiler/rustc_typeck/src/outlives/implicit_infer.rs @@ -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 diff --git a/library/alloc/src/alloc.rs b/library/alloc/src/alloc.rs index a10a027ffda..3ed3c2382ca 100644 --- a/library/alloc/src/alloc.rs +++ b/library/alloc/src/alloc.rs @@ -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) }; diff --git a/library/alloc/src/collections/binary_heap.rs b/library/alloc/src/collections/binary_heap.rs index fb340734e0b..28e4f8bba05 100644 --- a/library/alloc/src/collections/binary_heap.rs +++ b/library/alloc/src/collections/binary_heap.rs @@ -46,7 +46,7 @@ //! } //! } //! -//! // Each node is represented as an `usize`, for a shorter implementation. +//! // Each node is represented as a `usize`, for a shorter implementation. //! struct Edge { //! node: usize, //! cost: usize, diff --git a/library/core/src/array/iter.rs b/library/core/src/array/iter.rs index f6616399610..77c52e51abb 100644 --- a/library/core/src/array/iter.rs +++ b/library/core/src/array/iter.rs @@ -45,7 +45,7 @@ impl<T, const N: usize> IntoIter<T, N> { /// use std::array; /// /// for value in array::IntoIter::new([1, 2, 3, 4, 5]) { - /// // The type of `value` is a `i32` here, instead of `&i32` + /// // The type of `value` is an `i32` here, instead of `&i32` /// let _: i32 = value; /// } /// ``` diff --git a/library/core/src/char/methods.rs b/library/core/src/char/methods.rs index e5af22c8fbb..0dadbdd1bd0 100644 --- a/library/core/src/char/methods.rs +++ b/library/core/src/char/methods.rs @@ -958,7 +958,7 @@ impl char { /// Returns an iterator that yields the uppercase mapping of this `char` as one or more /// `char`s. /// - /// If this `char` does not have a uppercase mapping, the iterator yields the same `char`. + /// If this `char` does not have an uppercase mapping, the iterator yields the same `char`. /// /// If this `char` has a one-to-one uppercase mapping given by the [Unicode Character /// Database][ucd] [`UnicodeData.txt`], the iterator yields that `char`. diff --git a/library/core/src/intrinsics.rs b/library/core/src/intrinsics.rs index 272b1e3a1d7..9278dbb5498 100644 --- a/library/core/src/intrinsics.rs +++ b/library/core/src/intrinsics.rs @@ -1013,7 +1013,7 @@ extern "rust-intrinsic" { /// let val_casts = unsafe { &mut *(ptr as *mut i32 as *mut u32) }; /// ``` /// - /// Turning an `&str` into an `&[u8]`: + /// Turning an `&str` into a `&[u8]`: /// /// ``` /// // this is not a good way to do this. diff --git a/library/core/src/iter/adapters/zip.rs b/library/core/src/iter/adapters/zip.rs index c7e69e922c1..17697fa0e04 100644 --- a/library/core/src/iter/adapters/zip.rs +++ b/library/core/src/iter/adapters/zip.rs @@ -563,7 +563,7 @@ where } 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; } diff --git a/library/core/src/iter/traits/marker.rs b/library/core/src/iter/traits/marker.rs index ebf37f97bc6..844459d77cd 100644 --- a/library/core/src/iter/traits/marker.rs +++ b/library/core/src/iter/traits/marker.rs @@ -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 diff --git a/library/core/src/mem/mod.rs b/library/core/src/mem/mod.rs index d6eb535fd2e..84fd1a532c1 100644 --- a/library/core/src/mem/mod.rs +++ b/library/core/src/mem/mod.rs @@ -660,7 +660,7 @@ pub unsafe fn zeroed<T>() -> T { #[rustc_diagnostic_item = "mem_uninitialized"] #[track_caller] pub unsafe fn uninitialized<T>() -> T { - // SAFETY: the caller must guarantee that an unitialized value is valid for `T`. + // SAFETY: the caller must guarantee that an uninitialized value is valid for `T`. unsafe { intrinsics::assert_uninit_valid::<T>(); MaybeUninit::uninit().assume_init() diff --git a/library/core/src/num/dec2flt/lemire.rs b/library/core/src/num/dec2flt/lemire.rs index 9b7efc3d556..75405f47154 100644 --- a/library/core/src/num/dec2flt/lemire.rs +++ b/library/core/src/num/dec2flt/lemire.rs @@ -9,7 +9,7 @@ use crate::num::dec2flt::table::{ /// 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). diff --git a/library/core/src/ptr/mod.rs b/library/core/src/ptr/mod.rs index 47fad15e333..02c9dadc086 100644 --- a/library/core/src/ptr/mod.rs +++ b/library/core/src/ptr/mod.rs @@ -767,7 +767,7 @@ pub const unsafe fn read<T>(src: *const T) -> T { /// /// # Examples /// -/// Read an usize value from a byte buffer: +/// Read a usize value from a byte buffer: /// /// ``` /// use std::mem; @@ -960,7 +960,7 @@ pub const unsafe fn write<T>(dst: *mut T, src: T) { /// /// # Examples /// -/// Write an usize value to a byte buffer: +/// Write a usize value to a byte buffer: /// /// ``` /// use std::mem; @@ -1232,7 +1232,7 @@ pub(crate) unsafe fn align_offset<T: Sized>(p: *const T, a: usize) -> usize { let smoda = stride & a_minus_one; // SAFETY: a is power-of-two hence non-zero. stride == 0 case is handled above. let gcdpow = unsafe { intrinsics::cttz_nonzero(stride).min(intrinsics::cttz_nonzero(a)) }; - // SAFETY: gcdpow has an upper-bound that’s at most the number of bits in an usize. + // SAFETY: gcdpow has an upper-bound that’s at most the number of bits in a usize. let gcd = unsafe { unchecked_shl(1usize, gcdpow) }; // SAFETY: gcd is always greater or equal to 1. diff --git a/library/proc_macro/src/lib.rs b/library/proc_macro/src/lib.rs index f25e257bf31..243922b18b5 100644 --- a/library/proc_macro/src/lib.rs +++ b/library/proc_macro/src/lib.rs @@ -262,7 +262,7 @@ pub mod token_stream { } /// `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. diff --git a/library/std/src/collections/hash/map.rs b/library/std/src/collections/hash/map.rs index 4238c1db8b8..36077a42b48 100644 --- a/library/std/src/collections/hash/map.rs +++ b/library/std/src/collections/hash/map.rs @@ -1247,7 +1247,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() } @@ -1276,7 +1276,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() } @@ -1379,7 +1379,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() } diff --git a/library/std/src/ffi/c_str.rs b/library/std/src/ffi/c_str.rs index be7e099b73a..0d082648591 100644 --- a/library/std/src/ffi/c_str.rs +++ b/library/std/src/ffi/c_str.rs @@ -46,7 +46,7 @@ use crate::sys_common::memchr; /// /// # 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 @@ impl CString { /// ); /// ``` /// - /// A incorrectly formatted [`Vec`] will produce an error. + /// An incorrectly formatted [`Vec`] will produce an error. /// /// ``` /// #![feature(cstring_from_vec_with_nul)] @@ -939,7 +939,7 @@ impl<'a> From<&'a CString> for Cow<'a, CStr> { #[stable(feature = "shared_from_slice2", since = "1.24.0")] impl From<CString> for Arc<CStr> { - /// Converts a [`CString`] into a [`Arc`]`<CStr>` without copying or allocating. + /// Converts a [`CString`] into an [`Arc`]`<CStr>` without copying or allocating. #[inline] fn from(s: CString) -> Arc<CStr> { let arc: Arc<[u8]> = Arc::from(s.into_inner()); diff --git a/library/std/src/ffi/mod.rs b/library/std/src/ffi/mod.rs index 0b7dc256db8..fe4e3af91ad 100644 --- a/library/std/src/ffi/mod.rs +++ b/library/std/src/ffi/mod.rs @@ -94,7 +94,7 @@ //! //! * [`OsStr`] represents a borrowed reference to a string in a //! format that can be passed to the operating system. It can be -//! converted into an UTF-8 Rust string slice in a similar way to +//! converted into a UTF-8 Rust string slice in a similar way to //! [`OsString`]. //! //! # Conversions diff --git a/library/std/src/ffi/os_str.rs b/library/std/src/ffi/os_str.rs index 8f4cd6c691c..f05295f89af 100644 --- a/library/std/src/ffi/os_str.rs +++ b/library/std/src/ffi/os_str.rs @@ -359,7 +359,7 @@ impl OsString { #[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 @@ impl From<Box<OsStr>> for 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 @@ impl Clone for Box<OsStr> { #[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 an [`Arc`]`<OsStr>` without copying or allocating. #[inline] fn from(s: OsString) -> Arc<OsStr> { let arc = s.inner.into_arc(); @@ -916,7 +916,7 @@ impl From<&OsStr> for 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(); diff --git a/library/std/src/io/mod.rs b/library/std/src/io/mod.rs index fa073d080c6..28254fea0d3 100644 --- a/library/std/src/io/mod.rs +++ b/library/std/src/io/mod.rs @@ -1150,7 +1150,7 @@ impl<'a> DerefMut for IoSliceMut<'a> { /// A buffer type used with `Write::write_vectored`. /// -/// It is semantically a wrapper around an `&[u8]`, but is guaranteed to be +/// It is semantically a wrapper around a `&[u8]`, but is guaranteed to be /// ABI compatible with the `iovec` type on Unix platforms and `WSABUF` on /// Windows. #[stable(feature = "iovec", since = "1.36.0")] diff --git a/library/std/src/keyword_docs.rs b/library/std/src/keyword_docs.rs index 605bd33a4bf..749a441d182 100644 --- a/library/std/src/keyword_docs.rs +++ b/library/std/src/keyword_docs.rs @@ -2289,7 +2289,7 @@ mod dyn_keyword {} /// } /// /// let mut u = IntOrFloat { f: 1.0 }; -/// // Reading the fields of an union is always unsafe +/// // Reading the fields of a union is always unsafe /// assert_eq!(unsafe { u.i }, 1065353216); /// // Updating through any of the field will modify all of them /// u.i = 1073741824; diff --git a/library/std/src/net/addr.rs b/library/std/src/net/addr.rs index d3569710c2b..43d930677fa 100644 --- a/library/std/src/net/addr.rs +++ b/library/std/src/net/addr.rs @@ -561,8 +561,8 @@ impl From<SocketAddrV6> for 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 { diff --git a/library/std/src/net/ip.rs b/library/std/src/net/ip.rs index ac92cfe19cd..4165a7beaa8 100644 --- a/library/std/src/net/ip.rs +++ b/library/std/src/net/ip.rs @@ -380,7 +380,7 @@ impl IpAddr { 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 @@ impl Ipv6Addr { } } - /// 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 /// diff --git a/library/std/src/os/unix/net/ancillary.rs b/library/std/src/os/unix/net/ancillary.rs index cd429d14269..1f9d42812ec 100644 --- a/library/std/src/os/unix/net/ancillary.rs +++ b/library/std/src/os/unix/net/ancillary.rs @@ -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 @@ impl<'a> AncillaryData<'a> { AncillaryData::ScmRights(scm_rights) } - /// Create a `AncillaryData::ScmCredentials` variant. + /// Create an `AncillaryData::ScmCredentials` variant. /// /// # Safety /// diff --git a/library/std/src/os/windows/ffi.rs b/library/std/src/os/windows/ffi.rs index c89b9ff1efa..8d29fa7d66f 100644 --- a/library/std/src/os/windows/ffi.rs +++ b/library/std/src/os/windows/ffi.rs @@ -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. //! diff --git a/library/std/src/sys/windows/stdio.rs b/library/std/src/sys/windows/stdio.rs index 1cf0e9f0cf1..6f2618c63b5 100644 --- a/library/std/src/sys/windows/stdio.rs +++ b/library/std/src/sys/windows/stdio.rs @@ -162,7 +162,7 @@ impl io::Read for Stdin { } let mut utf16_buf = [0u16; MAX_BUFFER_SIZE / 2]; - // In the worst case, an UTF-8 string can take 3 bytes for every `u16` of an UTF-16. So + // In the worst case, a UTF-8 string can take 3 bytes for every `u16` of a UTF-16. So // we can read at most a third of `buf.len()` chars and uphold the guarantee no data gets // lost. let amount = cmp::min(buf.len() / 3, utf16_buf.len()); diff --git a/library/std/src/sys_common/remutex/tests.rs b/library/std/src/sys_common/remutex/tests.rs index 88453ded2f9..64873b850d3 100644 --- a/library/std/src/sys_common/remutex/tests.rs +++ b/library/std/src/sys_common/remutex/tests.rs @@ -30,7 +30,7 @@ fn smoke() { #[test] fn is_mutex() { let m = unsafe { - // FIXME: Simplify this if Arc gets a Arc::get_pin_mut. + // FIXME: Simplify this if Arc gets an Arc::get_pin_mut. let mut m = Arc::new(ReentrantMutex::new(RefCell::new(0))); Pin::new_unchecked(Arc::get_mut_unchecked(&mut m)).init(); Pin::new_unchecked(m) @@ -52,7 +52,7 @@ fn is_mutex() { #[test] fn trylock_works() { let m = unsafe { - // FIXME: Simplify this if Arc gets a Arc::get_pin_mut. + // FIXME: Simplify this if Arc gets an Arc::get_pin_mut. let mut m = Arc::new(ReentrantMutex::new(())); Pin::new_unchecked(Arc::get_mut_unchecked(&mut m)).init(); Pin::new_unchecked(m) diff --git a/library/std/src/sys_common/wtf8.rs b/library/std/src/sys_common/wtf8.rs index 1bd3cfd2200..9508bd7da59 100644 --- a/library/std/src/sys_common/wtf8.rs +++ b/library/std/src/sys_common/wtf8.rs @@ -785,7 +785,7 @@ pub fn is_code_point_boundary(slice: &Wtf8, index: usize) -> bool { /// Copied from core::str::raw::slice_unchecked #[inline] pub unsafe fn slice_unchecked(s: &Wtf8, begin: usize, end: usize) -> &Wtf8 { - // memory layout of an &[u8] and &Wtf8 are the same + // memory layout of a &[u8] and &Wtf8 are the same Wtf8::from_bytes_unchecked(slice::from_raw_parts(s.bytes.as_ptr().add(begin), end - begin)) } diff --git a/library/std/src/time/monotonic.rs b/library/std/src/time/monotonic.rs index 27fee6acff3..fa96b7abff6 100644 --- a/library/std/src/time/monotonic.rs +++ b/library/std/src/time/monotonic.rs @@ -84,7 +84,7 @@ pub mod inner { pub(super) fn monotonize(raw: time::Instant) -> time::Instant { let delta = raw.checked_sub_instant(&ZERO).unwrap(); // Split into seconds and nanos since Duration doesn't have a - // constructor that takes an u128 + // constructor that takes a u128 let secs = delta.as_secs() as u128; let nanos = delta.subsec_nanos() as u128; let timestamp: u128 = secs << 64 | nanos; diff --git a/src/librustdoc/formats/cache.rs b/src/librustdoc/formats/cache.rs index d45f277a0a8..1830909d944 100644 --- a/src/librustdoc/formats/cache.rs +++ b/src/librustdoc/formats/cache.rs @@ -22,7 +22,7 @@ use crate::html::render::IndexItem; /// /// This structure purposefully does not implement `Clone` because it's intended /// to be a fairly large and expensive structure to clone. Instead this adheres -/// to `Send` so it may be stored in a `Arc` instance and shared among the various +/// to `Send` so it may be stored in an `Arc` instance and shared among the various /// rendering threads. #[derive(Default)] crate struct Cache { diff --git a/src/librustdoc/html/static/js/search.js b/src/librustdoc/html/static/js/search.js index 76e7295bce3..5eb545f7582 100644 --- a/src/librustdoc/html/static/js/search.js +++ b/src/librustdoc/html/static/js/search.js @@ -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; diff --git a/src/test/incremental/thinlto/cgu_invalidated_when_import_removed.rs b/src/test/incremental/thinlto/cgu_invalidated_when_import_removed.rs index 1214e37f982..fc53acf75cb 100644 --- a/src/test/incremental/thinlto/cgu_invalidated_when_import_removed.rs +++ b/src/test/incremental/thinlto/cgu_invalidated_when_import_removed.rs @@ -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 diff --git a/src/test/mir-opt/dest-prop/copy_propagation_arg.rs b/src/test/mir-opt/dest-prop/copy_propagation_arg.rs index 41796247789..a5fb0f640b2 100644 --- a/src/test/mir-opt/dest-prop/copy_propagation_arg.rs +++ b/src/test/mir-opt/dest-prop/copy_propagation_arg.rs @@ -7,7 +7,7 @@ fn dummy(x: u8) -> u8 { // EMIT_MIR copy_propagation_arg.foo.DestinationPropagation.diff fn foo(mut x: u8) { - // calling `dummy` to make an use of `x` that copyprop cannot eliminate + // calling `dummy` to make a use of `x` that copyprop cannot eliminate x = dummy(x); // this will assign a local to `x` } diff --git a/src/test/rustdoc-ui/coverage/allow_missing_docs.rs b/src/test/rustdoc-ui/coverage/allow_missing_docs.rs index c077be31b20..c771c09da88 100644 --- a/src/test/rustdoc-ui/coverage/allow_missing_docs.rs +++ b/src/test/rustdoc-ui/coverage/allow_missing_docs.rs @@ -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, diff --git a/src/test/ui-fulldeps/internal-lints/pass_ty_by_ref_self.rs b/src/test/ui-fulldeps/internal-lints/pass_ty_by_ref_self.rs index 25f6490aa35..48b140d9174 100644 --- a/src/test/ui-fulldeps/internal-lints/pass_ty_by_ref_self.rs +++ b/src/test/ui-fulldeps/internal-lints/pass_ty_by_ref_self.rs @@ -1,6 +1,6 @@ // compile-flags: -Z unstable-options // NOTE: This test doesn't actually require `fulldeps` -// so we could instead use it as an `ui` test. +// so we could instead use it as a `ui` test. // // Considering that all other `internal-lints` are tested here // this seems like the cleaner solution though. diff --git a/src/test/ui/async-await/drop-order/drop-order-for-temporary-in-tail-return-expr.rs b/src/test/ui/async-await/drop-order/drop-order-for-temporary-in-tail-return-expr.rs index 4ec43708584..edfecb91036 100644 --- a/src/test/ui/async-await/drop-order/drop-order-for-temporary-in-tail-return-expr.rs +++ b/src/test/ui/async-await/drop-order/drop-order-for-temporary-in-tail-return-expr.rs @@ -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; diff --git a/src/test/ui/async-await/issues/issue-53249.rs b/src/test/ui/async-await/issues/issue-53249.rs index e9079bfdd85..3a33af2d2ee 100644 --- a/src/test/ui/async-await/issues/issue-53249.rs +++ b/src/test/ui/async-await/issues/issue-53249.rs @@ -8,7 +8,7 @@ use std::future::Future; use std::marker::Unpin; use std::pin::Pin; -// This is a regression test for a ICE/unbounded recursion issue relating to async-await. +// This is a regression test for an ICE/unbounded recursion issue relating to async-await. #[derive(Debug)] #[must_use = "futures do nothing unless polled"] diff --git a/src/test/ui/async-await/issues/issue-69307.rs b/src/test/ui/async-await/issues/issue-69307.rs index 4dae96ec8a6..59309a7f288 100644 --- a/src/test/ui/async-await/issues/issue-69307.rs +++ b/src/test/ui/async-await/issues/issue-69307.rs @@ -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. // diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.fixed b/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.fixed index 982407e2e25..c82bc369f43 100644 --- a/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.fixed +++ b/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.fixed @@ -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 diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.rs b/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.rs index 1ac034959cb..57ab15ae8f2 100644 --- a/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.rs +++ b/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.rs @@ -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 diff --git a/src/test/ui/consts/cast-discriminant-zst-enum.rs b/src/test/ui/consts/cast-discriminant-zst-enum.rs index 66b76627c02..e59ae297da1 100644 --- a/src/test/ui/consts/cast-discriminant-zst-enum.rs +++ b/src/test/ui/consts/cast-discriminant-zst-enum.rs @@ -1,5 +1,5 @@ // run-pass -// Test a ZST enum whose dicriminant is ~0i128. This caused an ICE when casting to a i32. +// Test a ZST enum whose dicriminant is ~0i128. This caused an ICE when casting to an i32. #![feature(bench_black_box)] use std::hint::black_box; diff --git a/src/test/ui/hrtb/hrtb-exists-forall-fn.rs b/src/test/ui/hrtb/hrtb-exists-forall-fn.rs index 828331cb950..56780237618 100644 --- a/src/test/ui/hrtb/hrtb-exists-forall-fn.rs +++ b/src/test/ui/hrtb/hrtb-exists-forall-fn.rs @@ -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. diff --git a/src/test/ui/hrtb/hrtb-exists-forall-trait-invariant.rs b/src/test/ui/hrtb/hrtb-exists-forall-trait-invariant.rs index b1b7ec6bcf1..9b9e4496a87 100644 --- a/src/test/ui/hrtb/hrtb-exists-forall-trait-invariant.rs +++ b/src/test/ui/hrtb/hrtb-exists-forall-trait-invariant.rs @@ -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. diff --git a/src/test/ui/lint/lint-nonstandard-style-unicode-1.rs b/src/test/ui/lint/lint-nonstandard-style-unicode-1.rs index 527d0ea9432..7c45c099304 100644 --- a/src/test/ui/lint/lint-nonstandard-style-unicode-1.rs +++ b/src/test/ui/lint/lint-nonstandard-style-unicode-1.rs @@ -30,7 +30,7 @@ struct 对__否; struct ヒ__χ; //~^ ERROR type `ヒ__χ` should have an upper camel case name -// also cannot have lowercase letter next to a underscore. +// also cannot have lowercase letter next to an underscore. // so this triggers the lint: struct Hello_你好; diff --git a/src/test/ui/nll/issue-21232-partial-init-and-erroneous-use.rs b/src/test/ui/nll/issue-21232-partial-init-and-erroneous-use.rs index 1983e13db0a..ebea6d3d9d1 100644 --- a/src/test/ui/nll/issue-21232-partial-init-and-erroneous-use.rs +++ b/src/test/ui/nll/issue-21232-partial-init-and-erroneous-use.rs @@ -1,4 +1,4 @@ -// This test enumerates various cases of interest where a ADT or tuple is +// This test enumerates various cases of interest where an ADT or tuple is // partially initialized and then used in some way that is wrong *even* // after rust-lang/rust#54987 is implemented. // diff --git a/src/test/ui/rfc-2008-non-exhaustive/enum.rs b/src/test/ui/rfc-2008-non-exhaustive/enum.rs index 73e0b98296b..9d2855f5c61 100644 --- a/src/test/ui/rfc-2008-non-exhaustive/enum.rs +++ b/src/test/ui/rfc-2008-non-exhaustive/enum.rs @@ -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 diff --git a/src/test/ui/traits/reservation-impl/non-lattice-ok.rs b/src/test/ui/traits/reservation-impl/non-lattice-ok.rs index b894577c1f7..a71051243c8 100644 --- a/src/test/ui/traits/reservation-impl/non-lattice-ok.rs +++ b/src/test/ui/traits/reservation-impl/non-lattice-ok.rs @@ -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. diff --git a/src/test/ui/union/union-nonzero.rs b/src/test/ui/union/union-nonzero.rs index d29e7a97180..3f4f7ea1c10 100644 --- a/src/test/ui/union/union-nonzero.rs +++ b/src/test/ui/union/union-nonzero.rs @@ -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. diff --git a/src/tools/clippy/clippy_lints/src/formatting.rs b/src/tools/clippy/clippy_lints/src/formatting.rs index b4cf1971d78..4dd0ffe77ea 100644 --- a/src/tools/clippy/clippy_lints/src/formatting.rs +++ b/src/tools/clippy/clippy_lints/src/formatting.rs @@ -164,7 +164,7 @@ fn check_unop(cx: &EarlyContext<'_>, expr: &Expr) { if !differing_macro_contexts(lhs.span, rhs.span) && !lhs.span.from_expansion(); // span between BinOp LHS and RHS let binop_span = lhs.span.between(rhs.span); - // if RHS is a UnOp + // if RHS is an UnOp if let ExprKind::Unary(op, ref un_rhs) = rhs.kind; // from UnOp operator to UnOp operand let unop_operand_span = rhs.span.until(un_rhs.span); diff --git a/src/tools/clippy/clippy_lints/src/loops/manual_memcpy.rs b/src/tools/clippy/clippy_lints/src/loops/manual_memcpy.rs index 2525b14e1c5..2296842e86f 100644 --- a/src/tools/clippy/clippy_lints/src/loops/manual_memcpy.rs +++ b/src/tools/clippy/clippy_lints/src/loops/manual_memcpy.rs @@ -268,7 +268,7 @@ impl std::ops::Sub<&MinifyingSugg<'static>> for 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>, diff --git a/src/tools/clippy/clippy_lints/src/non_copy_const.rs b/src/tools/clippy/clippy_lints/src/non_copy_const.rs index aa3067876eb..3f9110295fc 100644 --- a/src/tools/clippy/clippy_lints/src/non_copy_const.rs +++ b/src/tools/clippy/clippy_lints/src/non_copy_const.rs @@ -122,7 +122,7 @@ fn is_unfrozen<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool { // Ignore types whose layout is unknown since `is_freeze` reports every generic types as `!Freeze`, // making it indistinguishable from `UnsafeCell`. i.e. it isn't a tool to prove a type is // 'unfrozen'. However, this code causes a false negative in which - // a type contains a layout-unknown type, but also a unsafe cell like `const CELL: Cell<T>`. + // a type contains a layout-unknown type, but also an unsafe cell like `const CELL: Cell<T>`. // Yet, it's better than `ty.has_type_flags(TypeFlags::HAS_TY_PARAM | TypeFlags::HAS_PROJECTION)` // since it works when a pointer indirection involves (`Cell<*const T>`). // Making up a `ParamEnv` where every generic params and assoc types are `Freeze`is another option; @@ -266,7 +266,7 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst { // in other words, lint consts whose value *could* be unfrozen, not definitely is. // This feels inconsistent with how the lint treats generic types, // which avoids linting types which potentially become unfrozen. - // One could check whether a unfrozen type have a *frozen variant* + // One could check whether an unfrozen type have a *frozen variant* // (like `body_id_opt.map_or_else(|| !has_frozen_variant(...), ...)`), // and do the same as the case of generic types at impl items. // Note that it isn't sufficient to check if it has an enum @@ -293,7 +293,7 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst { }) => { 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); diff --git a/src/tools/clippy/clippy_lints/src/ptr_eq.rs b/src/tools/clippy/clippy_lints/src/ptr_eq.rs index d6d7049fb61..3258c9fb3fe 100644 --- a/src/tools/clippy/clippy_lints/src/ptr_eq.rs +++ b/src/tools/clippy/clippy_lints/src/ptr_eq.rs @@ -74,7 +74,7 @@ impl LateLintPass<'_> for PtrEq { } } -// If the given expression is a cast to an usize, return the lhs of the cast +// If the given expression is a cast to a usize, return the lhs of the cast // E.g., `foo as *const _ as usize` returns `foo as *const _`. fn expr_as_cast_to_usize<'tcx>(cx: &LateContext<'tcx>, cast_expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> { if cx.typeck_results().expr_ty(cast_expr) == cx.tcx.types.usize { diff --git a/src/tools/clippy/clippy_lints/src/ranges.rs b/src/tools/clippy/clippy_lints/src/ranges.rs index 0114a2f97a2..4fa361fedaf 100644 --- a/src/tools/clippy/clippy_lints/src/ranges.rs +++ b/src/tools/clippy/clippy_lints/src/ranges.rs @@ -51,7 +51,7 @@ declare_clippy_lint! { /// /// ### 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())`. /// diff --git a/src/tools/clippy/clippy_lints/src/shadow.rs b/src/tools/clippy/clippy_lints/src/shadow.rs index b28a37cabd4..b9e317a3cfd 100644 --- a/src/tools/clippy/clippy_lints/src/shadow.rs +++ b/src/tools/clippy/clippy_lints/src/shadow.rs @@ -74,7 +74,7 @@ declare_clippy_lint! { 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? diff --git a/src/tools/clippy/clippy_lints/src/utils/conf.rs b/src/tools/clippy/clippy_lints/src/utils/conf.rs index a28b1d78f7d..c192f9094a8 100644 --- a/src/tools/clippy/clippy_lints/src/utils/conf.rs +++ b/src/tools/clippy/clippy_lints/src/utils/conf.rs @@ -198,7 +198,7 @@ define_Conf! { (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. /// diff --git a/src/tools/clippy/clippy_utils/src/consts.rs b/src/tools/clippy/clippy_utils/src/consts.rs index 15c27d1a996..9ba1381da65 100644 --- a/src/tools/clippy/clippy_utils/src/consts.rs +++ b/src/tools/clippy/clippy_utils/src/consts.rs @@ -329,7 +329,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> { 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 { diff --git a/src/tools/clippy/clippy_utils/src/lib.rs b/src/tools/clippy/clippy_utils/src/lib.rs index 2777e5bd0c4..32a73984674 100644 --- a/src/tools/clippy/clippy_utils/src/lib.rs +++ b/src/tools/clippy/clippy_utils/src/lib.rs @@ -587,7 +587,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 { diff --git a/src/tools/clippy/clippy_utils/src/sugg.rs b/src/tools/clippy/clippy_utils/src/sugg.rs index 3b494e1fc85..65d93e8f86e 100644 --- a/src/tools/clippy/clippy_utils/src/sugg.rs +++ b/src/tools/clippy/clippy_utils/src/sugg.rs @@ -434,7 +434,7 @@ pub fn make_assoc(op: AssocOp, lhs: &Sugg<'_>, rhs: &Sugg<'_>) -> Sugg<'static> 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!( diff --git a/src/tools/clippy/tests/ui/declare_interior_mutable_const/traits.rs b/src/tools/clippy/tests/ui/declare_interior_mutable_const/traits.rs index 535147ccc64..256a336db82 100644 --- a/src/tools/clippy/tests/ui/declare_interior_mutable_const/traits.rs +++ b/src/tools/clippy/tests/ui/declare_interior_mutable_const/traits.rs @@ -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. diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs index dee1d315b3d..f291918225f 100644 --- a/src/tools/compiletest/src/runtest.rs +++ b/src/tools/compiletest/src/runtest.rs @@ -1733,7 +1733,7 @@ impl<'test> TestCx<'test> { } /// 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 diff --git a/src/tools/rustfmt/src/macros.rs b/src/tools/rustfmt/src/macros.rs index c8ee590b6cc..a9bc89544d8 100644 --- a/src/tools/rustfmt/src/macros.rs +++ b/src/tools/rustfmt/src/macros.rs @@ -401,7 +401,7 @@ fn rewrite_macro_inner( handle_vec_semi(context, shape, arg_vec, macro_name, style) } else { // If we are rewriting `vec!` macro or other special macros, - // then we can rewrite this as an usual array literal. + // then we can rewrite this as a usual array literal. // Otherwise, we must preserve the original existence of trailing comma. let macro_name = ¯o_name.as_str(); let mut force_trailing_comma = if trailing_comma { diff --git a/src/tools/rustfmt/src/string.rs b/src/tools/rustfmt/src/string.rs index 0cb9d817ca2..64ae15672df 100644 --- a/src/tools/rustfmt/src/string.rs +++ b/src/tools/rustfmt/src/string.rs @@ -153,7 +153,7 @@ pub(crate) fn rewrite_string<'a>( wrap_str(result, fmt.config.max_width(), fmt.shape) } -/// Returns the index to the end of the URL if the split at index of the given string includes an +/// Returns the index to the end of the URL if the split at index of the given string includes a /// URL or alike. Otherwise, returns `None`. fn detect_url(s: &[&str], index: usize) -> Option<usize> { let start = match s[..=index].iter().rposition(|g| is_whitespace(g)) { diff --git a/src/tools/rustfmt/src/visitor.rs b/src/tools/rustfmt/src/visitor.rs index 3f251bf7c16..770693d165b 100644 --- a/src/tools/rustfmt/src/visitor.rs +++ b/src/tools/rustfmt/src/visitor.rs @@ -36,7 +36,7 @@ pub(crate) struct SnippetProvider { big_snippet: Lrc<String>, /// A position of the start of `big_snippet`, used as an offset. start_pos: usize, - /// A end position of the file that this snippet lives. + /// An end position of the file that this snippet lives. end_pos: usize, } diff --git a/src/tools/rustfmt/tests/source/cfg_if/detect/arch/x86.rs b/src/tools/rustfmt/tests/source/cfg_if/detect/arch/x86.rs index 50d5cfa87c4..4c71a2c6ab9 100644 --- a/src/tools/rustfmt/tests/source/cfg_if/detect/arch/x86.rs +++ b/src/tools/rustfmt/tests/source/cfg_if/detect/arch/x86.rs @@ -2,7 +2,7 @@ //! //! The features are detected using the `detect_features` function below. //! This function uses the CPUID instruction to read the feature flags from the -//! CPU and encodes them in an `usize` where each bit position represents +//! CPU and encodes them in a `usize` where each bit position represents //! whether a feature is available (bit is set) or unavaiable (bit is cleared). //! //! The enum `Feature` is used to map bit positions to feature names, and the diff --git a/src/tools/rustfmt/tests/target/cfg_if/detect/arch/x86.rs b/src/tools/rustfmt/tests/target/cfg_if/detect/arch/x86.rs index 9219a4a577f..b985dd8caa1 100644 --- a/src/tools/rustfmt/tests/target/cfg_if/detect/arch/x86.rs +++ b/src/tools/rustfmt/tests/target/cfg_if/detect/arch/x86.rs @@ -2,7 +2,7 @@ //! //! The features are detected using the `detect_features` function below. //! This function uses the CPUID instruction to read the feature flags from the -//! CPU and encodes them in an `usize` where each bit position represents +//! CPU and encodes them in a `usize` where each bit position represents //! whether a feature is available (bit is set) or unavaiable (bit is cleared). //! //! The enum `Feature` is used to map bit positions to feature names, and the diff --git a/src/tools/tidy/src/style.rs b/src/tools/tidy/src/style.rs index d8d3dc3ddb1..022a3dfde82 100644 --- a/src/tools/tidy/src/style.rs +++ b/src/tools/tidy/src/style.rs @@ -66,7 +66,7 @@ enum LIUState { EXP_END, } -/// Returns `true` if `line` appears to be a line comment containing an URL, +/// Returns `true` if `line` appears to be a line comment containing a URL, /// possibly with a Markdown link label in front, and nothing else. /// The Markdown link label, if present, may not contain whitespace. /// Lines of this form are allowed to be overlength, because Markdown |