Update from 'syn' to 'rustc_ast::ast'

Author: Henri Lunnikivi

clippy_lints/src/field_reassign_with_default.rs

@@ -1,10 +1,9 @@
-use crate::utils::span_lint_and_note;
+use crate::utils::{snippet, span_lint_and_note};
 use if_chain::if_chain;
-use rustc_ast_pretty::pprust::{expr_to_string, ty_to_string};
+use rustc_ast::ast::{BindingMode, Block, ExprKind, Mutability, PatKind, StmtKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::Symbol;
-use syntax::ast::{BindingMode, Block, ExprKind, Mutability, PatKind, StmtKind};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for immediate reassignment of fields initialized
@@ -39,6 +38,10 @@ declare_clippy_lint! {
 
 declare_lint_pass!(FieldReassignWithDefault => [FIELD_REASSIGN_WITH_DEFAULT]);
 
+/// The token for the Default -trait.
+const DEFAULT_TRAIT_TOKEN: &str = "Default";
+const DEFAULT_FUNC_TOKEN: &str = "default";
+
 impl EarlyLintPass for FieldReassignWithDefault {
     fn check_block(&mut self, cx: &EarlyContext<'_>, block: &Block) {
         // store statement index and name of binding for all statements like
@@ -49,17 +52,18 @@ impl EarlyLintPass for FieldReassignWithDefault {
             .enumerate()
             .filter_map(|(idx, stmt)| {
                 if_chain! {
-                    // only take `let ...`
+                    // only take `let ...` statements
                     if let StmtKind::Local(ref local) = stmt.kind;
-                    // only take `... mut <binding> ...`
+                    // only take `... mut binding ...`
                     if let PatKind::Ident(BindingMode::ByValue(Mutability::Mut), binding, _) = local.pat.kind;
                     // only when assigning `... = Default::default()`
                     if let Some(ref expr) = local.init;
                     if let ExprKind::Call(ref fn_expr, _) = &expr.kind;
-                    if let ExprKind::Path(_, path) = &fn_expr.kind;
+                    if let ExprKind::Path( _, path ) = &fn_expr.kind;
                     if path.segments.len() >= 2;
-                    if path.segments[path.segments.len()-2].ident.as_str() == "Default";
-                    if path.segments.last().unwrap().ident.as_str() == "default";
+                    // right hand side of assignment is `Default::default`
+                    if path.segments[path.segments.len()-2].ident.to_string() == DEFAULT_TRAIT_TOKEN;
+                    if path.segments.last().unwrap().ident.to_string() == DEFAULT_FUNC_TOKEN;
                     then {
                         Some((idx, binding.name))
                     }
@@ -87,7 +91,7 @@ impl EarlyLintPass for FieldReassignWithDefault {
                 if let ExprKind::Assign(ref later_lhs, ref later_rhs, _) = later_expr.kind;
                 // only take assignments to fields where the field refers to the same binding as the previous statement
                 if let ExprKind::Field(ref binding_name_candidate, later_field_ident) = later_lhs.kind;
-                if let ExprKind::Path(_, path) = &binding_name_candidate.kind;
+                if let ExprKind::Path( _, ref path ) = binding_name_candidate.kind;
                 if let Some(second_binding_name) = path.segments.last();
                 if second_binding_name.ident.name == binding_name;
                 then {
@@ -96,17 +100,17 @@ impl EarlyLintPass for FieldReassignWithDefault {
                     if let StmtKind::Local(preceding_local) = &stmt.kind {
                         // reorganize the latter assigment statement into `field` and `value` for the lint
                         let field = later_field_ident.name.as_str();
-                        let value = expr_to_string(later_rhs);
+                        let value_snippet = snippet(cx, later_rhs.span, "..");
                         if let Some(ty) = &preceding_local.ty {
-                            let ty = ty_to_string(ty);
+                            let ty_snippet = snippet(cx, ty.span, "_");
 
                             span_lint_and_note(
                                 cx,
                                 FIELD_REASSIGN_WITH_DEFAULT,
                                 later_stmt.span,
                                 "field assignment outside of initializer for an instance created with Default::default()",
-                                preceding_local.span,
-                                &format!("consider initializing the variable immutably with `{} {{ {}: {}, ..Default::default() }}`", ty, field, value),
+                                Some(preceding_local.span),
+                                &format!("consider initializing the variable immutably with `{} {{ {}: {}, ..Default::default() }}`", ty_snippet, field, value_snippet),
                             );
                         }
                     }