ast: add Defaultness to Item, making AssocItem an alias.

Author: Centril

src/librustc_ast_pretty/pprust.rs

@@ -1016,8 +1016,8 @@ impl<'a> State<'a> {
     }
 
     crate fn print_foreign_item(&mut self, item: &ast::ForeignItem) {
-        let ast::ForeignItem { id, span, ident, attrs, kind, vis, tokens: _ } = item;
-        self.print_nested_item_kind(*id, *span, *ident, attrs, ast::Defaultness::Final, kind, vis);
+        let ast::Item { id, span, ident, attrs, kind, vis, defaultness, tokens: _ } = item;
+        self.print_nested_item_kind(*id, *span, *ident, attrs, *defaultness, kind, vis);
     }
 
     fn print_nested_item_kind(

src/librustc_builtin_macros/global_asm.rs

@@ -30,6 +30,7 @@ pub fn expand_global_asm<'cx>(
             id: ast::DUMMY_NODE_ID,
             kind: ast::ItemKind::GlobalAsm(P(global_asm)),
             vis: respan(sp.shrink_to_lo(), ast::VisibilityKind::Inherited),
+            defaultness: ast::Defaultness::Final,
             span: cx.with_def_site_ctxt(sp),
             tokens: None,
         })]),

src/librustc_builtin_macros/test_harness.rs

@@ -162,30 +162,21 @@ impl MutVisitor for EntryPointCleaner {
         // #[allow(dead_code)] to avoid printing warnings.
         let item = match entry::entry_point_type(&item, self.depth) {
             EntryPointType::MainNamed | EntryPointType::MainAttr | EntryPointType::Start => item
-                .map(|ast::Item { id, ident, attrs, kind, vis, span, tokens }| {
+                .map(|ast::Item { id, ident, attrs, kind, vis, defaultness, span, tokens }| {
                     let allow_ident = Ident::new(sym::allow, self.def_site);
                     let dc_nested = attr::mk_nested_word_item(Ident::from_str_and_span(
                         "dead_code",
                         self.def_site,
                     ));
                     let allow_dead_code_item = attr::mk_list_item(allow_ident, vec![dc_nested]);
                     let allow_dead_code = attr::mk_attr_outer(allow_dead_code_item);
+                    let attrs = attrs
+                        .into_iter()
+                        .filter(|attr| !attr.check_name(sym::main) && !attr.check_name(sym::start))
+                        .chain(iter::once(allow_dead_code))
+                        .collect();
 
-                    ast::Item {
-                        id,
-                        ident,
-                        attrs: attrs
-                            .into_iter()
-                            .filter(|attr| {
-                                !attr.check_name(sym::main) && !attr.check_name(sym::start)
-                            })
-                            .chain(iter::once(allow_dead_code))
-                            .collect(),
-                        kind,
-                        vis,
-                        span,
-                        tokens,
-                    }
+                    ast::Item { id, ident, attrs, kind, vis, defaultness, span, tokens }
                 }),
             EntryPointType::None | EntryPointType::OtherMain => item,
         };
@@ -321,6 +312,7 @@ fn mk_main(cx: &mut TestCtxt<'_>) -> P<ast::Item> {
         id: ast::DUMMY_NODE_ID,
         kind: main,
         vis: respan(sp, ast::VisibilityKind::Public),
+        defaultness: ast::Defaultness::Final,
         span: sp,
         tokens: None,
     });

src/librustc_expand/build.rs

@@ -588,6 +588,7 @@ impl<'a> ExtCtxt<'a> {
             id: ast::DUMMY_NODE_ID,
             kind,
             vis: respan(span.shrink_to_lo(), ast::VisibilityKind::Inherited),
+            defaultness: ast::Defaultness::Final,
             span,
             tokens: None,
         })

src/librustc_expand/expand.rs

@@ -358,6 +358,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
             ident: Ident::invalid(),
             id: ast::DUMMY_NODE_ID,
             vis: respan(krate.span.shrink_to_lo(), ast::VisibilityKind::Public),
+            defaultness: ast::Defaultness::Final,
             tokens: None,
         })]);
 

src/librustc_expand/placeholders.rs

@@ -26,6 +26,7 @@ pub fn placeholder(
     let ident = ast::Ident::invalid();
     let attrs = Vec::new();
     let vis = vis.unwrap_or_else(|| dummy_spanned(ast::VisibilityKind::Inherited));
+    let defaultness = ast::Defaultness::Final;
     let span = DUMMY_SP;
     let expr_placeholder = || {
         P(ast::Expr {
@@ -46,6 +47,7 @@ pub fn placeholder(
             span,
             ident,
             vis,
+            defaultness,
             attrs,
             kind: ast::ItemKind::Mac(mac_placeholder()),
             tokens: None,
@@ -76,6 +78,7 @@ pub fn placeholder(
                 span,
                 ident,
                 vis,
+                defaultness,
                 attrs,
                 kind: ast::ForeignItemKind::Macro(mac_placeholder()),
                 tokens: None,

src/librustc_metadata/rmeta/decoder/cstore_impl.rs

@@ -464,6 +464,7 @@ impl CStore {
                     legacy: def.legacy,
                 }),
                 vis: source_map::respan(local_span.shrink_to_lo(), ast::VisibilityKind::Inherited),
+                defaultness: ast::Defaultness::Final,
                 tokens: None,
             },
             data.root.edition,

src/librustc_parse/parser/item.rs

@@ -85,7 +85,7 @@ impl<'a> Parser<'a> {
         let vis = self.parse_visibility(FollowedByType::No)?;
 
         if let Some((ident, kind)) = self.parse_item_kind(&mut attrs, macros_allowed, lo, &vis)? {
-            return Ok(Some(P(self.mk_item(lo, ident, kind, vis, attrs))));
+            return Ok(Some(P(self.mk_item(lo, ident, kind, vis, Defaultness::Final, attrs))));
         }
 
         // FAILURE TO PARSE ITEM
@@ -866,7 +866,7 @@ impl<'a> Parser<'a> {
         let lo = self.token.span;
         let vis = self.parse_visibility(FollowedByType::No)?;
         let (ident, kind) = self.parse_assoc_item_kind(at_end, &mut attrs, |_| true, &vis)?;
-        let item = self.mk_item(lo, ident, kind, vis, attrs);
+        let item = self.mk_item(lo, ident, kind, vis, Defaultness::Final, attrs);
         self.error_on_foreign_const(&item);
         Ok(P(item))
     }
@@ -1420,10 +1420,11 @@ impl<'a> Parser<'a> {
         ident: Ident,
         kind: K,
         vis: Visibility,
+        defaultness: Defaultness,
         attrs: Vec<Attribute>,
     ) -> Item<K> {
         let span = lo.to(self.prev_span);
-        Item { ident, attrs, id: DUMMY_NODE_ID, kind, vis, span, tokens: None }
+        Item { ident, attrs, id: DUMMY_NODE_ID, kind, vis, defaultness, span, tokens: None }
     }
 }
 

src/libsyntax/ast.rs

@@ -2411,16 +2411,19 @@ impl VariantData {
     }
 }
 
-/// An item.
-///
-/// The name might be a dummy name in case of anonymous items.
+/// An item definition.
 #[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
 pub struct Item<K = ItemKind> {
     pub attrs: Vec<Attribute>,
     pub id: NodeId,
     pub span: Span,
     pub vis: Visibility,
+    /// The name of the item.
+    /// It might be a dummy name in case of anonymous items.
     pub ident: Ident,
+    /// The `default`ness of this item.
+    /// This should only occur in syntactically well-formed code in associated contexts.
+    pub defaultness: Defaultness,
 
     pub kind: K,
 
@@ -2613,19 +2616,7 @@ pub type ForeignItemKind = AssocItemKind;
 
 /// Represents associated items.
 /// These include items in `impl` and `trait` definitions.
-#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
-pub struct AssocItem {
-    pub attrs: Vec<Attribute>,
-    pub id: NodeId,
-    pub span: Span,
-    pub vis: Visibility,
-    pub ident: Ident,
-
-    pub defaultness: Defaultness,
-    pub kind: AssocItemKind,
-    /// See `Item::tokens` for what this is.
-    pub tokens: Option<TokenStream>,
-}
+pub type AssocItem = Item<AssocItemKind>;
 
 /// Represents non-free item kinds.
 ///

src/libsyntax/attr/mod.rs

@@ -722,6 +722,6 @@ macro_rules! derive_has_attrs {
 }
 
 derive_has_attrs! {
-    Item, Expr, Local, ast::ForeignItem, ast::StructField, ast::AssocItem, ast::Arm,
+    Item, Expr, Local, ast::ForeignItem, ast::StructField, ast::Arm,
     ast::Field, ast::FieldPat, ast::Variant, ast::Param, GenericParam
 }