Merge branch 'macro-use' into HEAD

[rust.git] / clippy_lints / src / redundant_field_names.rs

diff --git a/clippy_lints/src/redundant_field_names.rs b/clippy_lints/src/redundant_field_names.rs
index 587454f64ebe9e330e2c89e9dde983323831be94..4f28d36e2a8f72e66533d11f1ca709be7b937a84 100644 (file)
--- a/clippy_lints/src/redundant_field_names.rs
+++ b/clippy_lints/src/redundant_field_names.rs
@@ -1,30 +1,29 @@
-use syntax::ast::Name;
 use rustc::lint::*;
+use rustc::{declare_lint, lint_array};
 use rustc::hir::*;
-use utils::{match_qpath, match_var, span_lint_and_sugg};
-use utils::paths;
+use crate::utils::{in_macro, is_range_expression, match_var, span_lint_and_sugg};
 
 /// **What it does:** Checks for fields in struct literals where shorthands
 /// could be used.
-/// 
+///
 /// **Why is this bad?** If the field and variable names are the same,
 /// the field name is redundant.
-/// 
+///
 /// **Known problems:** None.
-/// 
+///
 /// **Example:**
 /// ```rust
 /// let bar: u8 = 123;
-/// 
+///
 /// struct Foo {
 ///     bar: u8,
 /// }
-/// 
+///
 /// let foo = Foo{ bar: bar }
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub REDUNDANT_FIELD_NAMES,
-    Warn,
+    style,
     "checks for fields in struct literals where shorthands could be used"
 }
 
@@ -38,13 +37,16 @@ fn get_lints(&self) -> LintArray {
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for RedundantFieldNames {
     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
-        if let ExprStruct(ref path, ref fields, _) = expr.node {
-            for field in fields {
-                let name = field.name.node;
+        // Ignore all macros including range expressions.
+        // They can have redundant field names when expanded.
+        // e.g. range expression `start..end` is desugared to `Range { start: start, end: end }`
+        if in_macro(expr.span) || is_range_expression(expr.span) {
+            return;
+        }
 
-                if is_range_struct_field(path, &name) {
-                    continue;
-                }
+        if let ExprKind::Struct(_, ref fields, _) = expr.node {
+            for field in fields {
+                let name = field.ident.name;
 
                 if match_var(&field.expr, name) && !field.is_shorthand {
                     span_lint_and_sugg (
@@ -60,27 +62,3 @@ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
         }
     }
 }
-
-/// ```rust
-/// let start = 0;
-/// let _ = start..;
-///
-/// let end = 0;
-/// let _ = ..end;
-///
-/// let _ = start..end;
-/// ```
-fn is_range_struct_field(path: &QPath, name: &Name) -> bool {
-    match name.as_str().as_ref() {
-        "start" => {
-            match_qpath(path, &paths::RANGE_STD) || match_qpath(path, &paths::RANGE_FROM_STD)
-                || match_qpath(path, &paths::RANGE_INCLUSIVE_STD)
-        },
-        "end" => {
-            match_qpath(path, &paths::RANGE_STD) || match_qpath(path, &paths::RANGE_TO_STD)
-                || match_qpath(path, &paths::RANGE_INCLUSIVE_STD)
-                || match_qpath(path, &paths::RANGE_TO_INCLUSIVE_STD)
-        },
-        _ => false,
-    }
-}