Rustup "Remove Spanned from {ast,hir}::FieldPat"

tesuji · tesuji · commit 65b906a8fced · 2019-08-16T09:32:27.000+07:00
diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
@@ -300,7 +300,7 @@ fn bindings<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &Pat) -> FxHashMap<LocalI
             },
             PatKind::Struct(_, ref fields, _) => {
                 for pat in fields {
-                    bindings_impl(cx, &pat.node.pat, map);
+                    bindings_impl(cx, &pat.pat, map);
                 }
             },
             PatKind::Tuple(ref fields, _) => {
diff --git a/clippy_lints/src/dbg_macro.rs b/clippy_lints/src/dbg_macro.rs
@@ -31,8 +31,8 @@ declare_lint_pass!(DbgMacro => [DBG_MACRO]);
 
 impl EarlyLintPass for DbgMacro {
     fn check_mac(&mut self, cx: &EarlyContext<'_>, mac: &ast::Mac) {
-        if mac.node.path == sym!(dbg) {
-            if let Some(sugg) = tts_span(mac.node.tts.clone()).and_then(|span| snippet_opt(cx, span)) {
+        if mac.path == sym!(dbg) {
+            if let Some(sugg) = tts_span(mac.tts.clone()).and_then(|span| snippet_opt(cx, span)) {
                 span_lint_and_sugg(
                     cx,
                     DBG_MACRO,
diff --git a/clippy_lints/src/misc_early.rs b/clippy_lints/src/misc_early.rs
@@ -234,7 +234,7 @@ impl EarlyLintPass for MiscEarlyLints {
                 .name;
 
             for field in pfields {
-                if let PatKind::Wild = field.node.pat.node {
+                if let PatKind::Wild = field.pat.node {
                     wilds += 1;
                 }
             }
@@ -252,7 +252,7 @@ impl EarlyLintPass for MiscEarlyLints {
                 let mut normal = vec![];
 
                 for field in pfields {
-                    match field.node.pat.node {
+                    match field.pat.node {
                         PatKind::Wild => {},
                         _ => {
                             if let Ok(n) = cx.sess().source_map().span_to_snippet(field.span) {
@@ -262,7 +262,7 @@ impl EarlyLintPass for MiscEarlyLints {
                     }
                 }
                 for field in pfields {
-                    if let PatKind::Wild = field.node.pat.node {
+                    if let PatKind::Wild = field.pat.node {
                         wilds -= 1;
                         if wilds > 0 {
                             span_lint(
diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
@@ -131,8 +131,8 @@ impl<'a, 'tcx, 'b> Visitor<'tcx> for SimilarNamesNameVisitor<'a, 'tcx, 'b> {
             PatKind::Ident(_, ident, _) => self.check_ident(ident),
             PatKind::Struct(_, ref fields, _) => {
                 for field in fields {
-                    if !field.node.is_shorthand {
-                        self.visit_pat(&field.node.pat);
+                    if !field.is_shorthand {
+                        self.visit_pat(&field.pat);
                     }
                 }
             },
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
@@ -190,20 +190,20 @@ fn check_pat<'a, 'tcx>(
             if let Some(init_struct) = init {
                 if let ExprKind::Struct(_, ref efields, _) = init_struct.node {
                     for field in pfields {
-                        let name = field.node.ident.name;
+                        let name = field.ident.name;
                         let efield = efields
                             .iter()
                             .find_map(|f| if f.ident.name == name { Some(&*f.expr) } else { None });
-                        check_pat(cx, &field.node.pat, efield, span, bindings);
+                        check_pat(cx, &field.pat, efield, span, bindings);
                     }
                 } else {
                     for field in pfields {
-                        check_pat(cx, &field.node.pat, init, span, bindings);
+                        check_pat(cx, &field.pat, init, span, bindings);
                     }
                 }
             } else {
                 for field in pfields {
-                    check_pat(cx, &field.node.pat, None, span, bindings);
+                    check_pat(cx, &field.pat, None, span, bindings);
                 }
             }
         },
diff --git a/clippy_lints/src/utils/inspector.rs b/clippy_lints/src/utils/inspector.rs
@@ -420,11 +420,11 @@ fn print_pat(cx: &LateContext<'_, '_>, pat: &hir::Pat, indent: usize) {
             println!("{}ignore leftover fields: {}", ind, ignore);
             println!("{}fields:", ind);
             for field in fields {
-                println!("{}  field name: {}", ind, field.node.ident.name);
-                if field.node.is_shorthand {
+                println!("{}  field name: {}", ind, field.ident.name);
+                if field.is_shorthand {
                     println!("{}  in shorthand notation", ind);
                 }
-                print_pat(cx, &field.node.pat, indent + 1);
+                print_pat(cx, &field.pat, indent + 1);
             }
         },
         hir::PatKind::TupleStruct(ref path, ref fields, opt_dots_position) => {
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
@@ -783,7 +783,7 @@ pub fn is_refutable(cx: &LateContext<'_, '_>, pat: &Pat) -> bool {
             if is_enum_variant(cx, qpath, pat.hir_id) {
                 true
             } else {
-                are_refutable(cx, fields.iter().map(|field| &*field.node.pat))
+                are_refutable(cx, fields.iter().map(|field| &*field.pat))
             }
         },
         PatKind::TupleStruct(ref qpath, ref pats, _) => {
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
@@ -183,9 +183,9 @@ declare_lint_pass!(Write => [
 
 impl EarlyLintPass for Write {
     fn check_mac(&mut self, cx: &EarlyContext<'_>, mac: &Mac) {
-        if mac.node.path == sym!(println) {
+        if mac.path == sym!(println) {
             span_lint(cx, PRINT_STDOUT, mac.span, "use of `println!`");
-            if let (Some(fmt_str), _) = check_tts(cx, &mac.node.tts, false) {
+            if let (Some(fmt_str), _) = check_tts(cx, &mac.tts, false) {
                 if fmt_str.contents.is_empty() {
                     span_lint_and_sugg(
                         cx,
@@ -198,9 +198,9 @@ impl EarlyLintPass for Write {
                     );
                 }
             }
-        } else if mac.node.path == sym!(print) {
+        } else if mac.path == sym!(print) {
             span_lint(cx, PRINT_STDOUT, mac.span, "use of `print!`");
-            if let (Some(fmt_str), _) = check_tts(cx, &mac.node.tts, false) {
+            if let (Some(fmt_str), _) = check_tts(cx, &mac.tts, false) {
                 if check_newlines(&fmt_str) {
                     span_lint_and_then(
                         cx,
@@ -211,7 +211,7 @@ impl EarlyLintPass for Write {
                             err.multipart_suggestion(
                                 "use `println!` instead",
                                 vec![
-                                    (mac.node.path.span, String::from("println")),
+                                    (mac.path.span, String::from("println")),
                                     (fmt_str.newline_span(), String::new()),
                                 ],
                                 Applicability::MachineApplicable,
@@ -220,8 +220,8 @@ impl EarlyLintPass for Write {
                     );
                 }
             }
-        } else if mac.node.path == sym!(write) {
-            if let (Some(fmt_str), _) = check_tts(cx, &mac.node.tts, true) {
+        } else if mac.path == sym!(write) {
+            if let (Some(fmt_str), _) = check_tts(cx, &mac.tts, true) {
                 if check_newlines(&fmt_str) {
                     span_lint_and_then(
                         cx,
@@ -232,7 +232,7 @@ impl EarlyLintPass for Write {
                             err.multipart_suggestion(
                                 "use `writeln!()` instead",
                                 vec![
-                                    (mac.node.path.span, String::from("writeln")),
+                                    (mac.path.span, String::from("writeln")),
                                     (fmt_str.newline_span(), String::new()),
                                 ],
                                 Applicability::MachineApplicable,
@@ -241,8 +241,8 @@ impl EarlyLintPass for Write {
                     )
                 }
             }
-        } else if mac.node.path == sym!(writeln) {
-            if let (Some(fmt_str), expr) = check_tts(cx, &mac.node.tts, true) {
+        } else if mac.path == sym!(writeln) {
+            if let (Some(fmt_str), expr) = check_tts(cx, &mac.tts, true) {
                 if fmt_str.contents.is_empty() {
                     let mut applicability = Applicability::MachineApplicable;
                     let suggestion = expr.map_or_else(

Original file line number	Diff line number	Diff line change
`@@ -300,7 +300,7 @@ fn bindings<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &Pat) -> FxHashMap<LocalI`
`300`	`300`	`},`
`301`	`301`	`PatKind::Struct(_, ref fields, _) => {`
`302`	`302`	`for pat in fields {`
`303`		`- bindings_impl(cx, &pat.node.pat, map);`
	`303`	`+ bindings_impl(cx, &pat.pat, map);`
`304`	`304`	`}`
`305`	`305`	`},`
`306`	`306`	`PatKind::Tuple(ref fields, _) => {`
Original file line number	Diff line number	Diff line change
`@@ -234,7 +234,7 @@ impl EarlyLintPass for MiscEarlyLints {`
`234`	`234`	`.name;`
`235`	`235`
`236`	`236`	`for field in pfields {`
`237`		`- if let PatKind::Wild = field.node.pat.node {`
	`237`	`+ if let PatKind::Wild = field.pat.node {`
`238`	`238`	`wilds += 1;`
`239`	`239`	`}`
`240`	`240`	`}`
`@@ -252,7 +252,7 @@ impl EarlyLintPass for MiscEarlyLints {`
`252`	`252`	`let mut normal = vec![];`
`253`	`253`
`254`	`254`	`for field in pfields {`
`255`		`- match field.node.pat.node {`
	`255`	`+ match field.pat.node {`
`256`	`256`	`PatKind::Wild => {},`
`257`	`257`	`_ => {`
`258`	`258`	`if let Ok(n) = cx.sess().source_map().span_to_snippet(field.span) {`
`@@ -262,7 +262,7 @@ impl EarlyLintPass for MiscEarlyLints {`
`262`	`262`	`}`
`263`	`263`	`}`
`264`	`264`	`for field in pfields {`
`265`		`- if let PatKind::Wild = field.node.pat.node {`
	`265`	`+ if let PatKind::Wild = field.pat.node {`
`266`	`266`	`wilds -= 1;`
`267`	`267`	`if wilds > 0 {`
`268`	`268`	`span_lint(`
Original file line number	Diff line number	Diff line change
`@@ -131,8 +131,8 @@ impl<'a, 'tcx, 'b> Visitor<'tcx> for SimilarNamesNameVisitor<'a, 'tcx, 'b> {`
`131`	`131`	`PatKind::Ident(_, ident, _) => self.check_ident(ident),`
`132`	`132`	`PatKind::Struct(_, ref fields, _) => {`
`133`	`133`	`for field in fields {`
`134`		`- if !field.node.is_shorthand {`
`135`		`- self.visit_pat(&field.node.pat);`
	`134`	`+ if !field.is_shorthand {`
	`135`	`+ self.visit_pat(&field.pat);`
`136`	`136`	`}`
`137`	`137`	`}`
`138`	`138`	`},`
Original file line number	Diff line number	Diff line change
`@@ -190,20 +190,20 @@ fn check_pat<'a, 'tcx>(`
`190`	`190`	`if let Some(init_struct) = init {`
`191`	`191`	`if let ExprKind::Struct(_, ref efields, _) = init_struct.node {`
`192`	`192`	`for field in pfields {`
`193`		`- let name = field.node.ident.name;`
	`193`	`+ let name = field.ident.name;`
`194`	`194`	`let efield = efields`
`195`	`195`	`.iter()`
`196`	`196`	`.find_map(\|f\| if f.ident.name == name { Some(&*f.expr) } else { None });`
`197`		`- check_pat(cx, &field.node.pat, efield, span, bindings);`
	`197`	`+ check_pat(cx, &field.pat, efield, span, bindings);`
`198`	`198`	`}`
`199`	`199`	`} else {`
`200`	`200`	`for field in pfields {`
`201`		`- check_pat(cx, &field.node.pat, init, span, bindings);`
	`201`	`+ check_pat(cx, &field.pat, init, span, bindings);`
`202`	`202`	`}`
`203`	`203`	`}`
`204`	`204`	`} else {`
`205`	`205`	`for field in pfields {`
`206`		`- check_pat(cx, &field.node.pat, None, span, bindings);`
	`206`	`+ check_pat(cx, &field.pat, None, span, bindings);`
`207`	`207`	`}`
`208`	`208`	`}`
`209`	`209`	`},`
Original file line number	Diff line number	Diff line change
`@@ -783,7 +783,7 @@ pub fn is_refutable(cx: &LateContext<'_, '_>, pat: &Pat) -> bool {`
`783`	`783`	`if is_enum_variant(cx, qpath, pat.hir_id) {`
`784`	`784`	`true`
`785`	`785`	`} else {`
`786`		`- are_refutable(cx, fields.iter().map(\|field\| &*field.node.pat))`
	`786`	`+ are_refutable(cx, fields.iter().map(\|field\| &*field.pat))`
`787`	`787`	`}`
`788`	`788`	`},`
`789`	`789`	`PatKind::TupleStruct(ref qpath, ref pats, _) => {`