Auto merge of #11058 - Centri3:typos, r=xFrednet

Fix typos

Just a couple misc typos I found

changelog: none

Author: bors

clippy_lints/src/methods/map_unwrap_or.rs

@@ -11,7 +11,8 @@ use rustc_span::symbol::sym;
 use super::MAP_UNWRAP_OR;
 
 /// lint use of `map().unwrap_or_else()` for `Option`s and `Result`s
-/// Return true if lint triggered
+///
+/// Returns true if the lint was emitted
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx hir::Expr<'_>,

clippy_lints/src/min_ident_chars.rs

@@ -25,7 +25,7 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust,ignore
     /// for m in movies {
-    ///	    let title = m.t;
+    ///     let title = m.t;
     /// }
     /// ```
     /// Use instead:

clippy_lints/src/needless_else.rs

@@ -51,7 +51,7 @@ impl EarlyLintPass for NeedlessElse {
                 cx,
                 NEEDLESS_ELSE,
                 span,
-                "this else branch is empty",
+                "this `else` branch is empty",
                 "you can remove it",
                 String::new(),
                 Applicability::MachineApplicable,

clippy_lints/src/utils/conf.rs

@@ -319,7 +319,7 @@ define_Conf! {
     /// Lint: DISALLOWED_NAMES.
     ///
     /// The list of disallowed names to lint about. NB: `bar` is not here since it has legitimate uses. The value
-    /// `".."` can be used as part of the list to indicate, that the configured values should be appended to the
+    /// `".."` can be used as part of the list to indicate that the configured values should be appended to the
     /// default configuration of Clippy. By default, any configuration will replace the default value.
     (disallowed_names: Vec<String> = super::DEFAULT_DISALLOWED_NAMES.iter().map(ToString::to_string).collect()),
     /// Lint: SEMICOLON_INSIDE_BLOCK.

clippy_utils/src/attrs.rs

@@ -143,13 +143,13 @@ pub fn get_unique_attr<'a>(
     unique_attr
 }
 
-/// Return true if the attributes contain any of `proc_macro`,
+/// Returns true if the attributes contain any of `proc_macro`,
 /// `proc_macro_derive` or `proc_macro_attribute`, false otherwise
 pub fn is_proc_macro(attrs: &[ast::Attribute]) -> bool {
     attrs.iter().any(rustc_ast::Attribute::is_proc_macro_attr)
 }
 
-/// Return true if the attributes contain `#[doc(hidden)]`
+/// Returns true if the attributes contain `#[doc(hidden)]`
 pub fn is_doc_hidden(attrs: &[ast::Attribute]) -> bool {
     attrs
         .iter()

clippy_utils/src/check_proc_macro.rs

@@ -339,7 +339,7 @@ fn ty_search_pat(ty: &Ty<'_>) -> (Pat, Pat) {
         TyKind::Tup(..) => (Pat::Str("("), Pat::Str(")")),
         TyKind::OpaqueDef(..) => (Pat::Str("impl"), Pat::Str("")),
         TyKind::Path(qpath) => qpath_search_pat(&qpath),
-        // NOTE: This is missing `TraitObject`. It always return true then.
+        // NOTE: This is missing `TraitObject`. It will always return true then.
         _ => (Pat::Str(""), Pat::Str("")),
     }
 }

clippy_utils/src/comparisons.rs

@@ -1,11 +1,11 @@
-//! Utility functions about comparison operators.
+//! Utility functions for comparison operators.
 
 #![deny(clippy::missing_docs_in_private_items)]
 
 use rustc_hir::{BinOpKind, Expr};
 
 #[derive(PartialEq, Eq, Debug, Copy, Clone)]
-/// Represent a normalized comparison operator.
+/// Represents a normalized comparison operator.
 pub enum Rel {
     /// `<`
     Lt,

clippy_utils/src/consts.rs

@@ -267,7 +267,7 @@ pub fn constant_with_source<'tcx>(
     res.map(|x| (x, ctxt.source))
 }
 
-/// Attempts to evaluate an expression only if it's value is not dependent on other items.
+/// Attempts to evaluate an expression only if its value is not dependent on other items.
 pub fn constant_simple<'tcx>(
     lcx: &LateContext<'tcx>,
     typeck_results: &ty::TypeckResults<'tcx>,

clippy_utils/src/eager_or_lazy.rs

@@ -1,7 +1,7 @@
 //! Utilities for evaluating whether eagerly evaluated expressions can be made lazy and vice versa.
 //!
 //! Things to consider:
-//!  - has the expression side-effects?
+//!  - does the expression have side-effects?
 //!  - is the expression computationally expensive?
 //!
 //! See lints:

clippy_utils/src/higher.rs

@@ -13,7 +13,7 @@ use rustc_lint::LateContext;
 use rustc_span::{sym, symbol, Span};
 
 /// The essential nodes of a desugared for loop as well as the entire span:
-/// `for pat in arg { body }` becomes `(pat, arg, body)`. Return `(pat, arg, body, span)`.
+/// `for pat in arg { body }` becomes `(pat, arg, body)`. Returns `(pat, arg, body, span)`.
 pub struct ForLoop<'tcx> {
     /// `for` loop item
     pub pat: &'tcx hir::Pat<'tcx>,
@@ -264,7 +264,7 @@ impl<'a> Range<'a> {
     }
 }
 
-/// Represent the pre-expansion arguments of a `vec!` invocation.
+/// Represents the pre-expansion arguments of a `vec!` invocation.
 pub enum VecArgs<'a> {
     /// `vec![elem; len]`
     Repeat(&'a hir::Expr<'a>, &'a hir::Expr<'a>),
@@ -398,7 +398,7 @@ impl<'hir> WhileLet<'hir> {
     }
 }
 
-/// Converts a hir binary operator to the corresponding `ast` type.
+/// Converts a `hir` binary operator to the corresponding `ast` type.
 #[must_use]
 pub fn binop(op: hir::BinOpKind) -> ast::BinOpKind {
     match op {
@@ -436,7 +436,7 @@ pub enum VecInitKind {
     WithExprCapacity(HirId),
 }
 
-/// Checks if given expression is an initialization of `Vec` and returns its kind.
+/// Checks if the given expression is an initialization of `Vec` and returns its kind.
 pub fn get_vec_init_kind<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<VecInitKind> {
     if let ExprKind::Call(func, args) = expr.kind {
         match func.kind {