Implement default_could_be_derived and default_overrides_default_fields lints

compiler/rustc_ast/src/ast.rs

@@ -1455,8 +1455,8 @@ pub enum StructRest {
     Base(P<Expr>),
     /// `..`.
     Rest(Span),
-    /// No trailing `..` or expression.
-    None,
+    /// No trailing `..` or expression. The `Span` points at the trailing `,` or spot before `}`.
+    None(Span),
 }
 
 #[derive(Clone, Encodable, Decodable, Debug)]

compiler/rustc_ast/src/mut_visit.rs

@@ -1771,7 +1771,7 @@ pub fn walk_expr<T: MutVisitor>(vis: &mut T, Expr { kind, id, span, attrs, token
             match rest {
                 StructRest::Base(expr) => vis.visit_expr(expr),
                 StructRest::Rest(_span) => {}
-                StructRest::None => {}
+                StructRest::None(_span) => {}
             }
         }
         ExprKind::Paren(expr) => {

compiler/rustc_ast/src/visit.rs

@@ -1094,7 +1094,7 @@ pub fn walk_expr<'a, V: Visitor<'a>>(visitor: &mut V, expression: &'a Expr) -> V
             match rest {
                 StructRest::Base(expr) => try_visit!(visitor.visit_expr(expr)),
                 StructRest::Rest(_span) => {}
-                StructRest::None => {}
+                StructRest::None(_span) => {}
             }
         }
         ExprKind::Tup(subexpressions) => {

compiler/rustc_ast_lowering/src/expr.rs

@@ -358,7 +358,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     let rest = match &se.rest {
                         StructRest::Base(e) => hir::StructTailExpr::Base(self.lower_expr(e)),
                         StructRest::Rest(sp) => hir::StructTailExpr::DefaultFields(*sp),
-                        StructRest::None => hir::StructTailExpr::None,
+                        StructRest::None(sp) => hir::StructTailExpr::None(*sp),
                     };
                     hir::ExprKind::Struct(
                         self.arena.alloc(self.lower_qpath(
@@ -1419,7 +1419,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         true
                     }
                     StructRest::Rest(_) => true,
-                    StructRest::None => false,
+                    StructRest::None(_) => false,
                 };
                 let struct_pat = hir::PatKind::Struct(qpath, field_pats, fields_omitted);
                 return self.pat_without_dbm(lhs.span, struct_pat);
@@ -1530,7 +1530,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         hir::ExprKind::Struct(
             self.arena.alloc(hir::QPath::LangItem(lang_item, self.lower_span(span))),
             fields,
-            hir::StructTailExpr::None,
+            hir::StructTailExpr::None(DUMMY_SP),
         )
     }
 

compiler/rustc_ast_pretty/src/pprust/state/expr.rs

@@ -161,7 +161,7 @@ impl<'a> State<'a> {
         self.word("{");
         let has_rest = match rest {
             ast::StructRest::Base(_) | ast::StructRest::Rest(_) => true,
-            ast::StructRest::None => false,
+            ast::StructRest::None(_) => false,
         };
         if fields.is_empty() && !has_rest {
             self.word("}");

compiler/rustc_expand/src/build.rs

@@ -367,7 +367,7 @@ impl<'a> ExtCtxt<'a> {
                 qself: None,
                 path,
                 fields,
-                rest: ast::StructRest::None,
+                rest: ast::StructRest::None(DUMMY_SP),
             })),
         )
     }

compiler/rustc_hir/src/hir.rs

@@ -2116,7 +2116,7 @@ impl Expr<'_> {
             ExprKind::Struct(_, fields, init) => {
                 let init_side_effects = match init {
                     StructTailExpr::Base(init) => init.can_have_side_effects(),
-                    StructTailExpr::DefaultFields(_) | StructTailExpr::None => false,
+                    StructTailExpr::DefaultFields(_) | StructTailExpr::None(_) => false,
                 };
                 fields.iter().map(|field| field.expr).any(|e| e.can_have_side_effects())
                     || init_side_effects
@@ -2191,48 +2191,48 @@ impl Expr<'_> {
                 ExprKind::Struct(
                     QPath::LangItem(LangItem::RangeTo, _),
                     [val1],
-                    StructTailExpr::None,
+                    StructTailExpr::None(_),
                 ),
                 ExprKind::Struct(
                     QPath::LangItem(LangItem::RangeTo, _),
                     [val2],
-                    StructTailExpr::None,
+                    StructTailExpr::None(_),
                 ),
             )
             | (
                 ExprKind::Struct(
                     QPath::LangItem(LangItem::RangeToInclusive, _),
                     [val1],
-                    StructTailExpr::None,
+                    StructTailExpr::None(_),
                 ),
                 ExprKind::Struct(
                     QPath::LangItem(LangItem::RangeToInclusive, _),
                     [val2],
-                    StructTailExpr::None,
+                    StructTailExpr::None(_),
                 ),
             )
             | (
                 ExprKind::Struct(
                     QPath::LangItem(LangItem::RangeFrom, _),
                     [val1],
-                    StructTailExpr::None,
+                    StructTailExpr::None(_),
                 ),
                 ExprKind::Struct(
                     QPath::LangItem(LangItem::RangeFrom, _),
                     [val2],
-                    StructTailExpr::None,
+                    StructTailExpr::None(_),
                 ),
             ) => val1.expr.equivalent_for_indexing(val2.expr),
             (
                 ExprKind::Struct(
                     QPath::LangItem(LangItem::Range, _),
                     [val1, val3],
-                    StructTailExpr::None,
+                    StructTailExpr::None(_),
                 ),
                 ExprKind::Struct(
                     QPath::LangItem(LangItem::Range, _),
                     [val2, val4],
-                    StructTailExpr::None,
+                    StructTailExpr::None(_),
                 ),
             ) => {
                 val1.expr.equivalent_for_indexing(val2.expr)
@@ -2428,7 +2428,7 @@ pub enum ExprKind<'hir> {
 #[derive(Debug, Clone, Copy, HashStable_Generic)]
 pub enum StructTailExpr<'hir> {
     /// A struct expression where all the fields are explicitly enumerated: `Foo { a, b }`.
-    None,
+    None(Span),
     /// A struct expression with a "base", an expression of the same type as the outer struct that
     /// will be used to populate any fields not explicitly mentioned: `Foo { ..base }`
     Base(&'hir Expr<'hir>),

compiler/rustc_hir/src/intravisit.rs

@@ -749,7 +749,7 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr<'v>)
             walk_list!(visitor, visit_expr_field, fields);
             match optional_base {
                 StructTailExpr::Base(base) => try_visit!(visitor.visit_expr(base)),
-                StructTailExpr::None | StructTailExpr::DefaultFields(_) => {}
+                StructTailExpr::None(_) | StructTailExpr::DefaultFields(_) => {}
             }
         }
         ExprKind::Tup(subexpressions) => {

compiler/rustc_hir_pretty/src/lib.rs

@@ -1226,7 +1226,7 @@ impl<'a> State<'a> {
                 self.word("..");
                 self.end();
             }
-            hir::StructTailExpr::None => {
+            hir::StructTailExpr::None(_) => {
                 if !fields.is_empty() {
                     self.word(",");
                 }

compiler/rustc_hir_typeck/src/expr_use_visitor.rs

@@ -707,7 +707,7 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
 
         let with_expr = match *opt_with {
             hir::StructTailExpr::Base(w) => &*w,
-            hir::StructTailExpr::DefaultFields(_) | hir::StructTailExpr::None => {
+            hir::StructTailExpr::DefaultFields(_) | hir::StructTailExpr::None(_) => {
                 return Ok(());
             }
         };