Create diagnostic::on_unimplemented attr which can roundtrip through ast lowering

Author: mejrs

compiler/rustc_ast/src/ast.rs

@@ -36,6 +36,7 @@ use rustc_span::{
 use thin_vec::{ThinVec, thin_vec};
 
 use crate::attr::data_structures::CfgEntry;
+use crate::attr::diagnostic::Directive;
 pub use crate::format::*;
 use crate::token::{self, CommentKind, Delimiter};
 use crate::tokenstream::{DelimSpan, LazyAttrTokenStream, TokenStream};
@@ -3795,6 +3796,8 @@ pub struct Trait {
     pub bounds: GenericBounds,
     #[visitable(extra = AssocCtxt::Trait)]
     pub items: ThinVec<Box<AssocItem>>,
+    #[visitable(ignore)]
+    pub on_unimplemented: Option<Directive>,
 }
 
 #[derive(Clone, Encodable, Decodable, Debug, Walkable)]

compiler/rustc_ast_lowering/src/item.rs

@@ -225,7 +225,12 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 .lower_eii_decl(id, *name, target)
                 .map(|decl| vec![hir::Attribute::Parsed(AttributeKind::EiiDeclaration(decl))])
                 .unwrap_or_default(),
-
+            ItemKind::Trait(Trait { on_unimplemented: Some(ou), .. }) => {
+                // FIXME Lower here
+                vec![hir::Attribute::Parsed(AttributeKind::OnUnimplemented {
+                    directive: Some(Box::new(ou.clone())),
+                })]
+            }
             ItemKind::ExternCrate(..)
             | ItemKind::Use(..)
             | ItemKind::Const(..)
@@ -546,6 +551,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 generics,
                 bounds,
                 items,
+                on_unimplemented: _,
             }) => {
                 let constness = self.lower_constness(*constness);
                 let impl_restriction = self.lower_impl_restriction(impl_restriction);

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

@@ -379,6 +379,7 @@ impl<'a> State<'a> {
                 generics,
                 bounds,
                 items,
+                on_unimplemented,
             }) => {
                 let (cb, ib) = self.head("");
                 self.print_visibility(&item.vis);
@@ -397,6 +398,10 @@ impl<'a> State<'a> {
                 self.word(" ");
                 self.bopen(ib);
                 self.print_inner_attributes(&item.attrs);
+                if on_unimplemented.is_some() {
+                    // FIXME make this nicer
+                    self.word("#[diagnostic::rustc_on_unimplemented(...)]")
+                }
                 for trait_item in items {
                     self.print_assoc_item(trait_item);
                 }

compiler/rustc_attr_parsing/src/attributes/diagnostic/mod.rs

@@ -112,6 +112,15 @@ impl Mode {
     }
 }
 
+pub fn parse_rustc_on_unimplemented(
+    cx: &mut AcceptContext<'_, '_>,
+    args: &ArgParser,
+) -> Option<Directive> {
+    let items = parse_list(cx, args, Mode::RustcOnUnimplemented)?;
+
+    parse_directive_items(cx, Mode::RustcOnUnimplemented, items.mixed(), true)
+}
+
 fn merge_directives(
     cx: &mut AcceptContext<'_, '_>,
     first: &mut Option<(Span, Directive)>,

compiler/rustc_attr_parsing/src/lib.rs

@@ -118,6 +118,7 @@ pub use attributes::cfg::{
     CFG_TEMPLATE, EvalConfigResult, eval_config_entry, parse_cfg, parse_cfg_attr, parse_cfg_entry,
 };
 pub use attributes::cfg_select::*;
+pub use attributes::diagnostic::parse_rustc_on_unimplemented;
 pub use attributes::util::{is_builtin_attr, parse_version};
 pub use context::{OmitDoc, ShouldEmit};
 pub use interface::{AttributeParser, EmitAttribute};

compiler/rustc_builtin_macros/src/diagnostic.rs

@@ -0,0 +1,69 @@
+#![allow(warnings)]
+
+use std::convert::identity;
+
+use rustc_ast::{AttrArgs, AttrStyle, Item, ItemKind, Trait, ast};
+use rustc_attr_parsing::parser::{AllowExprMetavar, ArgParser};
+use rustc_attr_parsing::{AttributeParser, AttributeSafety, ParsedDescription, ShouldEmit};
+use rustc_expand::base::{Annotatable, ExtCtxt};
+use rustc_feature::template;
+use rustc_hir::{AttrPath, Target};
+use rustc_parse::parser::Recovery;
+use rustc_span::{Span, sym};
+
+pub(crate) mod rustc_on_unimplemented {
+    use super::*;
+    pub(crate) fn expand(ecx: &mut ExtCtxt<'_>, attr: &ast::Attribute, item: &mut Annotatable) {
+        let attr = attr.get_normal_item();
+        let span = attr.span();
+        let Some(args) = ArgParser::from_attr_args(
+            &attr.args.unparsed_ref().unwrap(),
+            &[sym::diagnostic, sym::rustc_on_unimplemented],
+            &ecx.sess.psess,
+            ShouldEmit::ErrorsAndLints { recovery: Recovery::Forbidden },
+            AllowExprMetavar::No,
+        ) else {
+            // Lints/errors are/will be emitted by ArgParser.
+            return;
+        };
+
+        match item {
+            Annotatable::Item(box Item {
+                span: target_span,
+                kind: ItemKind::Trait(box Trait { on_unimplemented, .. }),
+                ..
+            }) => {
+                if on_unimplemented.is_some() {
+                    // FIXME(mejrs) coalescing multiple rustc_on_unimplemented attrs isn't
+                    // (and was never) supported - might be nice to have at some point
+                    ecx.dcx().span_err(
+                        span,
+                        "using multiple `#[diagnostic::rustc_on_unimplemented]` is not supported",
+                    );
+                }
+                *on_unimplemented = AttributeParser::parse_single_args(
+                    ecx.sess,
+                    span,
+                    span,
+                    AttrStyle::Inner,
+                    AttrPath::from_ast(&attr.path, identity),
+                    None,
+                    AttributeSafety::Normal,
+                    ParsedDescription::Macro,
+                    *target_span,
+                    ecx.current_expansion.lint_node_id,
+                    Target::Trait,
+                    Some(ecx.ecfg.features),
+                    ShouldEmit::ErrorsAndLints { recovery: Recovery::Forbidden },
+                    &args,
+                    rustc_attr_parsing::parse_rustc_on_unimplemented,
+                    &template!(List: &[r#"/*opt*/ message = "...", /*opt*/ label = "...", /*opt*/ note = "...""#]),
+                );
+            }
+            _ => {
+                ecx.dcx()
+                    .span_err(item.span(), "`#[diagnostic::rustc_on_unimplemented]` is only supported on trait definitions");
+            }
+        }
+    }
+}

compiler/rustc_builtin_macros/src/lib.rs

@@ -33,6 +33,7 @@ mod concat_bytes;
 mod define_opaque;
 mod derive;
 mod deriving;
+mod diagnostic;
 mod edition_panic;
 mod eii;
 mod env;
@@ -143,4 +144,9 @@ pub fn register_builtin_macros(resolver: &mut dyn ResolverExpand) {
     register(sym::contracts_requires, requires);
     let ensures = SyntaxExtensionKind::Attr(Arc::new(contracts::ExpandEnsures));
     register(sym::contracts_ensures, ensures);
+
+    resolver.insert_inert_attr(
+        &[sym::diagnostic, sym::rustc_on_unimplemented],
+        SyntaxExtensionKind::InertAttr(Arc::new(diagnostic::rustc_on_unimplemented::expand)),
+    );
 }

compiler/rustc_expand/src/base.rs

@@ -409,6 +409,19 @@ pub trait GlobDelegationExpander {
     fn expand(&self, ecx: &mut ExtCtxt<'_>) -> ExpandResult<Vec<(Ident, Option<Ident>)>, ()>;
 }
 
+pub trait AstAnnotate {
+    fn annotate(&self, ecx: &mut ExtCtxt<'_>, attr: &ast::Attribute, item: &mut Annotatable);
+}
+
+impl<F> AstAnnotate for F
+where
+    F: Fn(&mut ExtCtxt<'_>, &ast::Attribute, &mut Annotatable),
+{
+    fn annotate(&self, ecx: &mut ExtCtxt<'_>, attr: &ast::Attribute, item: &mut Annotatable) {
+        self(ecx, attr, item)
+    }
+}
+
 fn make_stmts_default(expr: Option<Box<ast::Expr>>) -> Option<SmallVec<[ast::Stmt; 1]>> {
     expr.map(|e| {
         smallvec![ast::Stmt { id: ast::DUMMY_NODE_ID, span: e.span, kind: ast::StmtKind::Expr(e) }]
@@ -787,6 +800,16 @@ pub enum SyntaxExtensionKind {
     ///
     /// This is for delegated function implementations, and has nothing to do with glob imports.
     GlobDelegation(Arc<dyn GlobDelegationExpander + sync::DynSync + sync::DynSend>),
+
+    /// An AST-based "inert" attribute.
+    ///
+    /// These represent otherwise inert attributes. Instead of creating or modifying items like
+    /// a macro would, they instead attach state to these items which is carried through
+    /// ast/hir lowering and then emitted like an actual inert attribute.
+    InertAttr(
+        /// An expander with signature (&mut AST).
+        Arc<dyn AstAnnotate + sync::DynSync + sync::DynSend>,
+    ),
 }
 
 impl SyntaxExtensionKind {
@@ -857,7 +880,8 @@ impl SyntaxExtension {
             | SyntaxExtensionKind::GlobDelegation(..) => MacroKinds::BANG,
             SyntaxExtensionKind::Attr(..)
             | SyntaxExtensionKind::LegacyAttr(..)
-            | SyntaxExtensionKind::NonMacroAttr => MacroKinds::ATTR,
+            | SyntaxExtensionKind::NonMacroAttr
+            | SyntaxExtensionKind::InertAttr(..) => MacroKinds::ATTR,
             SyntaxExtensionKind::Derive(..) | SyntaxExtensionKind::LegacyDerive(..) => {
                 MacroKinds::DERIVE
             }
@@ -1180,6 +1204,8 @@ pub trait ResolverExpand {
     /// Mark the scope as having a compile error so that error for lookup in this scope
     /// should be suppressed
     fn mark_scope_with_compile_error(&mut self, parent_node: NodeId);
+
+    fn insert_inert_attr(&mut self, path: &'static [Symbol], kind: SyntaxExtensionKind);
 }
 
 pub trait LintStoreExpand {

compiler/rustc_expand/src/expand.rs

@@ -897,6 +897,10 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
                     self.cx.expanded_inert_attrs.mark(&attr);
                     item.visit_attrs(|attrs| attrs.insert(pos, attr));
                     fragment_kind.expect_from_annotatables(iter::once(item))
+                } else if let SyntaxExtensionKind::InertAttr(expander) = ext {
+                    let mut item = item;
+                    expander.annotate(self.cx, &attr, &mut item);
+                    fragment_kind.expect_from_annotatables([item])
                 } else {
                     unreachable!();
                 }

compiler/rustc_parse/src/parser/item.rs

@@ -1178,6 +1178,7 @@ impl<'a> Parser<'a> {
                 generics,
                 bounds,
                 items,
+                on_unimplemented: None,
             })))
         }
     }