[read_line_without_trim]: catch string eq checks

Author: y21

clippy_lints/src/methods/read_line_without_trim.rs

@@ -4,7 +4,9 @@ use clippy_utils::{
     diagnostics::span_lint_and_then, get_parent_expr, match_def_path, source::snippet, ty::is_type_diagnostic_item,
     visitors::for_each_local_use_after_expr,
 };
+use rustc_ast::LitKind;
 use rustc_errors::Applicability;
+use rustc_hir::BinOpKind;
 use rustc_hir::Expr;
 use rustc_hir::QPath;
 use rustc_hir::{def::Res, ExprKind};
@@ -31,33 +33,61 @@ pub fn check(cx: &LateContext<'_>, call: &Expr<'_>, recv: &Expr<'_>, arg: &Expr<
         // parsed into a type that will always fail if it has a trailing newline.
         for_each_local_use_after_expr(cx, local_id, call.hir_id, |expr| {
             if let Some(parent) = get_parent_expr(cx, expr)
-                && let ExprKind::MethodCall(segment, .., span) = parent.kind
-                && segment.ident.name == sym!(parse)
-                && let parse_result_ty = cx.typeck_results().expr_ty(parent)
-                && is_type_diagnostic_item(cx, parse_result_ty, sym::Result)
-                && let ty::Adt(_, substs) = parse_result_ty.kind()
-                && let Some(ok_ty) = substs[0].as_type()
-                && parse_fails_on_trailing_newline(ok_ty)
             {
-                let local_snippet = snippet(cx, expr.span, "<expr>");
-                span_lint_and_then(
-                    cx,
-                    READ_LINE_WITHOUT_TRIM,
-                    span,
-                    "calling `.parse()` without trimming the trailing newline character",
-                    |diag| {
-                        diag.span_note(call.span, "call to `.read_line()` here, \
-                            which leaves a trailing newline character in the buffer, \
-                            which in turn will cause `.parse()` to fail");
+                if let ExprKind::MethodCall(segment, .., span) = parent.kind
+                    && segment.ident.name == sym!(parse)
+                    && let parse_result_ty = cx.typeck_results().expr_ty(parent)
+                    && is_type_diagnostic_item(cx, parse_result_ty, sym::Result)
+                    && let ty::Adt(_, substs) = parse_result_ty.kind()
+                    && let Some(ok_ty) = substs[0].as_type()
+                    && parse_fails_on_trailing_newline(ok_ty)
+                {
+                    let local_snippet: std::borrow::Cow<'_, str> = snippet(cx, expr.span, "<expr>");
+                    span_lint_and_then(
+                        cx,
+                        READ_LINE_WITHOUT_TRIM,
+                        span,
+                        "calling `.parse()` without trimming the trailing newline character",
+                        |diag| {
+                            diag.span_note(call.span, "call to `.read_line()` here, \
+                                which leaves a trailing newline character in the buffer, \
+                                which in turn will cause `.parse()` to fail");
 
-                        diag.span_suggestion(
-                            expr.span,
-                            "try",
-                            format!("{local_snippet}.trim_end()"),
-                            Applicability::MachineApplicable,
-                        );
-                    }
-                );
+                            diag.span_suggestion(
+                                expr.span,
+                                "try",
+                                format!("{local_snippet}.trim_end()"),
+                                Applicability::MachineApplicable,
+                            );
+                        }
+                    );
+                } else if let ExprKind::Binary(binop, left, right) = parent.kind
+                    && let BinOpKind::Eq = binop.node
+                    && let ExprKind::Lit(lit) = right.kind
+                    && let LitKind::Str(sym, _) = lit.node
+                    && !sym.as_str().ends_with('\n')
+                {
+                    span_lint_and_then(
+                        cx,
+                        READ_LINE_WITHOUT_TRIM,
+                        parent.span,
+                        "comparing a string literal without trimming the trailing newline character",
+                        |diag| {
+                            let local_snippet: std::borrow::Cow<'_, str> = snippet(cx, expr.span, "<expr>");
+
+                            diag.span_note(call.span, "call to `.read_line()` here, \
+                                which leaves a trailing newline character in the buffer, \
+                                which in turn will cause the comparison to always fail");
+                                
+                            diag.span_suggestion(
+                                expr.span,
+                                "try",
+                                format!("{local_snippet}.trim_end()"),
+                                Applicability::MachineApplicable,
+                            );
+                        }
+                    );
+                }
             }
 
             // only consider the first use to prevent this scenario: