implement rustc_force_inline parser

Author: jdonszelmann

compiler/rustc_attr_data_structures/src/attributes.rs

@@ -192,6 +192,7 @@ pub enum AttributeKind {
     Inline(InlineAttr, Span),
     MacroTransparency(Transparency),
     Repr(ThinVec<(ReprAttr, Span)>),
+    RustcForceInline(Span, Option<Symbol>),
     Stability {
         stability: Stability,
         /// Span of the `#[stable(...)]` or `#[unstable(...)]` attribute

compiler/rustc_attr_parsing/src/attributes/inline.rs

@@ -1,3 +1,7 @@
+// FIXME(jdonszelmann): merge these two parsers and error when both attributes are present here.
+//                      note: need to model better how duplicate attr errors work when not using
+//                      SingleAttributeParser which is what we have two of here.
+
 use rustc_attr_data_structures::{AttributeKind, InlineAttr};
 use rustc_errors::{E0534, E0535, struct_span_code_err};
 use rustc_span::sym;
@@ -6,6 +10,7 @@ use super::{AcceptContext, AttributeOrder, OnDuplicate};
 use crate::attributes::SingleAttributeParser;
 use crate::context::Stage;
 use crate::parser::ArgParser;
+use crate::session_diagnostics::IncorrectMetaItem;
 
 pub(crate) struct InlineParser;
 
@@ -47,3 +52,37 @@ impl<S: Stage> SingleAttributeParser<S> for InlineParser {
         }
     }
 }
+
+pub(crate) struct RustcForceInlineParser;
+
+impl<S: Stage> SingleAttributeParser<S> for RustcForceInlineParser {
+    const PATH: &'static [rustc_span::Symbol] = &[sym::rustc_force_inline];
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepLast;
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
+
+    fn convert(cx: &AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
+        let reason = match args {
+            ArgParser::NoArgs => None,
+            ArgParser::List(list) => {
+                cx.emit_err(IncorrectMetaItem {
+                    span: list.span,
+                    suggestion: None,
+                });
+                return None
+            }
+            ArgParser::NameValue(v) => {
+                let Some(str) = v.value_as_str() else {
+                    cx.emit_err(IncorrectMetaItem {
+                        span: v.value_span,
+                        suggestion: None,
+                    });
+                    return None;
+                };
+
+                Some(str)
+            }
+        };
+
+        Some(AttributeKind::Inline(InlineAttr::Force { attr_span: cx.attr_span, reason }, cx.attr_span))
+    }
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -19,7 +19,7 @@ use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span, Symbol, sym};
 use crate::attributes::allow_unstable::{AllowConstFnUnstableParser, AllowInternalUnstableParser};
 use crate::attributes::confusables::ConfusablesParser;
 use crate::attributes::deprecation::DeprecationParser;
-use crate::attributes::inline::InlineParser;
+use crate::attributes::inline::{InlineParser, RustcForceInlineParser};
 use crate::attributes::repr::ReprParser;
 use crate::attributes::stability::{
     BodyStabilityParser, ConstStabilityIndirectParser, ConstStabilityParser, StabilityParser,
@@ -106,6 +106,7 @@ attribute_groups!(
         Single<ConstStabilityIndirectParser>,
         Single<DeprecationParser>,
         Single<InlineParser>,
+        Single<RustcForceInlineParser>,
         Single<TransparencyParser>,
         // tidy-alphabetical-end
     ];