internal lints

Author: peter-shen-dev

clippy_lints/src/comparison_chain.rs

@@ -73,7 +73,7 @@ impl<'tcx> LateLintPass<'tcx> for ComparisonChain {
         }
 
         // Check that there exists at least one explicit else condition
-        let (conds, _) = if_sequence(expr);
+        let conds = if_sequence(expr).0;
         if conds.len() < 2 {
             return;
         }

clippy_lints/src/dereference.rs

@@ -508,7 +508,7 @@ fn report(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data: Stat
             let mut app = Applicability::MachineApplicable;
             let (expr_str, expr_is_macro_call) = snippet_with_context(cx, expr.span, data.span.ctxt(), "..", &mut app);
             let ty = cx.typeck_results().expr_ty(expr);
-            let (_, ref_count) = peel_mid_ty_refs(ty);
+            let ref_count = peel_mid_ty_refs(ty).1;
             let deref_str = if ty_changed_count >= ref_count && ref_count != 0 {
                 // a deref call changing &T -> &U requires two deref operators the first time
                 // this occurs. One to remove the reference, a second to call the deref impl.

clippy_lints/src/indexing_slicing.rs

@@ -109,7 +109,7 @@ impl<'tcx> LateLintPass<'tcx> for IndexingSlicing {
 
                     let const_range = to_const_range(cx, range, size);
 
-                    if let (Some(start), _) = const_range {
+                    if let Some(start) = const_range.0 {
                         if start > size {
                             span_lint(
                                 cx,
@@ -121,7 +121,7 @@ impl<'tcx> LateLintPass<'tcx> for IndexingSlicing {
                         }
                     }
 
-                    if let (_, Some(end)) = const_range {
+                    if let Some(end) = const_range.1 {
                         if end > size {
                             span_lint(
                                 cx,

clippy_lints/src/manual_map.rs

@@ -150,7 +150,7 @@ impl LateLintPass<'_> for ManualMap {
         // Remove address-of expressions from the scrutinee. Either `as_ref` will be called, or
         // it's being passed by value.
         let scrutinee = peel_hir_expr_refs(scrutinee).0;
-        let (scrutinee_str, _) = snippet_with_context(cx, scrutinee.span, expr_ctxt, "..", &mut app);
+        let scrutinee_str = snippet_with_context(cx, scrutinee.span, expr_ctxt, "..", &mut app).0;
         let scrutinee_str =
             if scrutinee.span.ctxt() == expr.span.ctxt() && scrutinee.precedence().order() < PREC_POSTFIX {
                 format!("({})", scrutinee_str)

clippy_lints/src/manual_strip.rs

@@ -146,7 +146,7 @@ fn len_arg<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx E
 
 // Returns the length of the `expr` if it's a constant string or char.
 fn constant_length(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<u128> {
-    let (value, _) = constant(cx, cx.typeck_results(), expr)?;
+    let value = constant(cx, cx.typeck_results(), expr)?.0;
     match value {
         Constant::Str(value) => Some(value.len() as u128),
         Constant::Char(value) => Some(value.len_utf8() as u128),

clippy_lints/src/open_options.rs

@@ -67,11 +67,7 @@ fn get_open_options(cx: &LateContext<'_>, argument: &Expr<'_>, options: &mut Vec
         if match_type(cx, obj_ty, &paths::OPEN_OPTIONS) && arguments.len() >= 2 {
             let argument_option = match arguments[1].kind {
                 ExprKind::Lit(ref span) => {
-                    if let Spanned {
-                        node: LitKind::Bool(lit),
-                        ..
-                    } = *span
-                    {
+                    if let LitKind::Bool(lit) = span.node {
                         if lit { Argument::True } else { Argument::False }
                     } else {
                         // The function is called with a literal which is not a boolean literal.

clippy_lints/src/utils/internal_lints/metadata_collector.rs

@@ -677,7 +677,7 @@ fn extract_emission_info<'hir>(
     let mut multi_part = false;
 
     for arg in args {
-        let (arg_ty, _) = walk_ptrs_ty_depth(cx.typeck_results().expr_ty(arg));
+        let arg_ty = walk_ptrs_ty_depth(cx.typeck_results().expr_ty(arg)).0;
 
         if match_type(cx, arg_ty, &paths::LINT) {
             // If we found the lint arg, extract the lint name
@@ -810,7 +810,7 @@ impl<'a, 'hir> intravisit::Visitor<'hir> for ApplicabilityResolver<'a, 'hir> {
     }
 
     fn visit_expr(&mut self, expr: &'hir hir::Expr<'hir>) {
-        let (expr_ty, _) = walk_ptrs_ty_depth(self.cx.typeck_results().expr_ty(expr));
+        let expr_ty = walk_ptrs_ty_depth(self.cx.typeck_results().expr_ty(expr)).0;
 
         if_chain! {
             if match_type(self.cx, expr_ty, &paths::APPLICABILITY);
@@ -900,7 +900,7 @@ impl<'a, 'hir> intravisit::Visitor<'hir> for IsMultiSpanScanner<'a, 'hir> {
                 }
             },
             ExprKind::MethodCall(path, _path_span, arg, _arg_span) => {
-                let (self_ty, _) = walk_ptrs_ty_depth(self.cx.typeck_results().expr_ty(&arg[0]));
+                let self_ty = walk_ptrs_ty_depth(self.cx.typeck_results().expr_ty(&arg[0])).0;
                 if match_type(self.cx, self_ty, &paths::DIAGNOSTIC_BUILDER) {
                     let called_method = path.ident.name.as_str().to_string();
                     for (method_name, is_multi_part) in &SUGGESTION_DIAGNOSTIC_BUILDER_METHODS {

clippy_lints/src/write.rs

@@ -624,7 +624,7 @@ impl Write {
     }
 
     fn lint_println_empty_string(&self, cx: &EarlyContext<'_>, mac: &MacCall) {
-        if let (Some(fmt_str), _) = self.check_tts(cx, mac.args.inner_tokens(), false) {
+        if let Some(fmt_str) = self.check_tts(cx, mac.args.inner_tokens(), false).0 {
             if fmt_str.symbol == kw::Empty {
                 let name = mac.path.segments[0].ident.name;
                 span_lint_and_sugg(
@@ -641,7 +641,7 @@ impl Write {
     }
 
     fn lint_print_with_newline(&self, cx: &EarlyContext<'_>, mac: &MacCall) {
-        if let (Some(fmt_str), _) = self.check_tts(cx, mac.args.inner_tokens(), false) {
+        if let Some(fmt_str) = self.check_tts(cx, mac.args.inner_tokens(), false).0 {
             if check_newlines(&fmt_str) {
                 let name = mac.path.segments[0].ident.name;
                 let suggested = format!("{}ln", name);