lower attr spans and inline some functions to hopefully mitigate perf regressions

jdonszelmann · jdonszelmann · commit 4daa35ce332f · 2025-02-24T14:37:58.000+01:00
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
@@ -870,7 +870,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         if attrs.is_empty() {
             &[]
         } else {
-            let lowered_attrs = self.lower_attrs_vec(attrs, target_span);
+            let lowered_attrs = self.lower_attrs_vec(attrs, self.lower_span(target_span));
 
             debug_assert_eq!(id.owner, self.current_hir_id_owner);
             let ret = self.arena.alloc_from_iter(lowered_attrs);
@@ -891,7 +891,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     }
 
     fn lower_attrs_vec(&self, attrs: &[Attribute], target_span: Span) -> Vec<hir::Attribute> {
-        self.attribute_parser.parse_attribute_list(attrs, target_span, OmitDoc::Lower)
+        self.attribute_parser
+            .parse_attribute_list(attrs, target_span, OmitDoc::Lower, |s| self.lower_span(s))
     }
 
     fn alias_attrs(&mut self, id: HirId, target_id: HirId) {
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
@@ -178,7 +178,7 @@ impl<'sess> AttributeParser<'sess> {
             parse_only: Some(sym),
             limit_diagnostics,
         }
-        .parse_attribute_list(attrs, target_span, OmitDoc::Skip);
+        .parse_attribute_list(attrs, target_span, OmitDoc::Skip, std::convert::identity);
 
         assert!(parsed.len() <= 1);
 
@@ -210,6 +210,8 @@ impl<'sess> AttributeParser<'sess> {
         attrs: &'a [ast::Attribute],
         target_span: Span,
         omit_doc: OmitDoc,
+
+        lower_span: impl Copy + Fn(Span) -> Span,
     ) -> Vec<Attribute> {
         let mut attributes = Vec::new();
 
@@ -242,7 +244,7 @@ impl<'sess> AttributeParser<'sess> {
                     attributes.push(Attribute::Parsed(AttributeKind::DocComment {
                         style: attr.style,
                         kind: *comment_kind,
-                        span: attr.span,
+                        span: lower_span(attr.span),
                         comment: *symbol,
                     }))
                 }
@@ -264,7 +266,10 @@ impl<'sess> AttributeParser<'sess> {
 
                     if let Some(accepts) = ATTRIBUTE_MAPPING.0.get(parts.as_slice()) {
                         for f in accepts {
-                            let cx = AcceptContext { group_cx: &group_cx, attr_span: attr.span };
+                            let cx = AcceptContext {
+                                group_cx: &group_cx,
+                                attr_span: lower_span(attr.span),
+                            };
 
                             f(&cx, &args)
                         }
@@ -286,10 +291,10 @@ impl<'sess> AttributeParser<'sess> {
 
                         attributes.push(Attribute::Unparsed(Box::new(AttrItem {
                             path: AttrPath::from_ast(&n.item.path),
-                            args: self.lower_attr_args(&n.item.args),
+                            args: self.lower_attr_args(&n.item.args, lower_span),
                             id: HashIgnoredAttrId { attr_id: attr.id },
                             style: attr.style,
-                            span: attr.span,
+                            span: lower_span(attr.span),
                         })));
                     }
                 }
@@ -308,7 +313,7 @@ impl<'sess> AttributeParser<'sess> {
         attributes
     }
 
-    fn lower_attr_args(&self, args: &ast::AttrArgs) -> AttrArgs {
+    fn lower_attr_args(&self, args: &ast::AttrArgs, lower_span: impl Fn(Span) -> Span) -> AttrArgs {
         match args {
             ast::AttrArgs::Empty => AttrArgs::Empty,
             ast::AttrArgs::Delimited(args) => AttrArgs::Delimited(DelimArgs {
@@ -323,7 +328,8 @@ impl<'sess> AttributeParser<'sess> {
                 // In valid code the value always ends up as a single literal. Otherwise, a dummy
                 // literal suffices because the error is handled elsewhere.
                 let lit = if let ast::ExprKind::Lit(token_lit) = expr.kind
-                    && let Ok(lit) = ast::MetaItemLit::from_token_lit(token_lit, expr.span)
+                    && let Ok(lit) =
+                        ast::MetaItemLit::from_token_lit(token_lit, lower_span(expr.span))
                 {
                     lit
                 } else {
@@ -335,7 +341,7 @@ impl<'sess> AttributeParser<'sess> {
                         span: DUMMY_SP,
                     }
                 };
-                AttrArgs::Eq { eq_span: *eq_span, expr: lit }
+                AttrArgs::Eq { eq_span: lower_span(*eq_span), expr: lit }
             }
         }
     }
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -1093,13 +1093,15 @@ impl Attribute {
 }
 
 impl AttributeExt for Attribute {
+    #[inline]
     fn id(&self) -> AttrId {
         match &self {
             Attribute::Unparsed(u) => u.id.attr_id,
             _ => panic!(),
         }
     }
 
+    #[inline]
     fn meta_item_list(&self) -> Option<ThinVec<ast::MetaItemInner>> {
         match &self {
             Attribute::Unparsed(n) => match n.as_ref() {
@@ -1112,15 +1114,18 @@ impl AttributeExt for Attribute {
         }
     }
 
+    #[inline]
     fn value_str(&self) -> Option<Symbol> {
         self.value_lit().and_then(|x| x.value_str())
     }
 
+    #[inline]
     fn value_span(&self) -> Option<Span> {
         self.value_lit().map(|i| i.span)
     }
 
     /// For a single-segment attribute, returns its name; otherwise, returns `None`.
+    #[inline]
     fn ident(&self) -> Option<Ident> {
         match &self {
             Attribute::Unparsed(n) => {
@@ -1134,6 +1139,7 @@ impl AttributeExt for Attribute {
         }
     }
 
+    #[inline]
     fn path_matches(&self, name: &[Symbol]) -> bool {
         match &self {
             Attribute::Unparsed(n) => {
@@ -1144,11 +1150,12 @@ impl AttributeExt for Attribute {
         }
     }
 
+    #[inline]
     fn is_doc_comment(&self) -> bool {
-        // FIXME(jdonszelmann): make the 2nd check unnecessary here
         matches!(self, Attribute::Parsed(AttributeKind::DocComment { .. }))
     }
 
+    #[inline]
     fn span(&self) -> Span {
         match &self {
             Attribute::Unparsed(u) => u.span,
@@ -1159,6 +1166,7 @@ impl AttributeExt for Attribute {
         }
     }
 
+    #[inline]
     fn is_word(&self) -> bool {
         match &self {
             Attribute::Unparsed(n) => {
@@ -1168,20 +1176,23 @@ impl AttributeExt for Attribute {
         }
     }
 
+    #[inline]
     fn ident_path(&self) -> Option<SmallVec<[Ident; 1]>> {
         match &self {
             Attribute::Unparsed(n) => Some(n.path.segments.iter().copied().collect()),
             _ => None,
         }
     }
 
+    #[inline]
     fn doc_str(&self) -> Option<Symbol> {
         match &self {
             Attribute::Parsed(AttributeKind::DocComment { comment, .. }) => Some(*comment),
             Attribute::Unparsed(_) if self.has_name(sym::doc) => self.value_str(),
             _ => None,
         }
     }
+    #[inline]
     fn doc_str_and_comment_kind(&self) -> Option<(Symbol, CommentKind)> {
         match &self {
             Attribute::Parsed(AttributeKind::DocComment { kind, comment, .. }) => {
@@ -1194,6 +1205,7 @@ impl AttributeExt for Attribute {
         }
     }
 
+    #[inline]
     fn style(&self) -> AttrStyle {
         match &self {
             Attribute::Unparsed(u) => u.style,
@@ -1205,34 +1217,42 @@ impl AttributeExt for Attribute {
 
 // FIXME(fn_delegation): use function delegation instead of manually forwarding
 impl Attribute {
+    #[inline]
     pub fn id(&self) -> AttrId {
         AttributeExt::id(self)
     }
 
+    #[inline]
     pub fn name_or_empty(&self) -> Symbol {
         AttributeExt::name_or_empty(self)
     }
 
+    #[inline]
     pub fn meta_item_list(&self) -> Option<ThinVec<MetaItemInner>> {
         AttributeExt::meta_item_list(self)
     }
 
+    #[inline]
     pub fn value_str(&self) -> Option<Symbol> {
         AttributeExt::value_str(self)
     }
 
+    #[inline]
     pub fn value_span(&self) -> Option<Span> {
         AttributeExt::value_span(self)
     }
 
+    #[inline]
     pub fn ident(&self) -> Option<Ident> {
         AttributeExt::ident(self)
     }
 
+    #[inline]
     pub fn path_matches(&self, name: &[Symbol]) -> bool {
         AttributeExt::path_matches(self, name)
     }
 
+    #[inline]
     pub fn is_doc_comment(&self) -> bool {
         AttributeExt::is_doc_comment(self)
     }
@@ -1242,34 +1262,42 @@ impl Attribute {
         AttributeExt::has_name(self, name)
     }
 
+    #[inline]
     pub fn span(&self) -> Span {
         AttributeExt::span(self)
     }
 
+    #[inline]
     pub fn is_word(&self) -> bool {
         AttributeExt::is_word(self)
     }
 
+    #[inline]
     pub fn path(&self) -> SmallVec<[Symbol; 1]> {
         AttributeExt::path(self)
     }
 
+    #[inline]
     pub fn ident_path(&self) -> Option<SmallVec<[Ident; 1]>> {
         AttributeExt::ident_path(self)
     }
 
+    #[inline]
     pub fn doc_str(&self) -> Option<Symbol> {
         AttributeExt::doc_str(self)
     }
 
+    #[inline]
     pub fn is_proc_macro_attr(&self) -> bool {
         AttributeExt::is_proc_macro_attr(self)
     }
 
+    #[inline]
     pub fn doc_str_and_comment_kind(&self) -> Option<(Symbol, CommentKind)> {
         AttributeExt::doc_str_and_comment_kind(self)
     }
 
+    #[inline]
     pub fn style(&self) -> AttrStyle {
         AttributeExt::style(self)
     }
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
@@ -2732,7 +2732,6 @@ fn check_invalid_crate_level_attr(tcx: TyCtxt<'_>, attrs: &[Attribute]) {
             continue;
         };
 
-
         let item = tcx
             .hir_free_items()
             .map(|id| tcx.hir_item(id))
diff --git a/compiler/rustc_resolve/src/def_collector.rs b/compiler/rustc_resolve/src/def_collector.rs
@@ -142,7 +142,12 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
                     self.resolver.tcx.features(),
                     Vec::new(),
                 );
-                let attrs = parser.parse_attribute_list(&i.attrs, i.span, OmitDoc::Skip);
+                let attrs = parser.parse_attribute_list(
+                    &i.attrs,
+                    i.span,
+                    OmitDoc::Skip,
+                    std::convert::identity,
+                );
 
                 let macro_data =
                     self.resolver.compile_macro(def, i.ident, &attrs, i.span, i.id, edition);

Original file line number	Diff line number	Diff line change
`@@ -1093,13 +1093,15 @@ impl Attribute {`
`1093`	`1093`	`}`
`1094`	`1094`
`1095`	`1095`	`impl AttributeExt for Attribute {`
	`1096`	`+ #[inline]`
`1096`	`1097`	`fn id(&self) -> AttrId {`
`1097`	`1098`	`match &self {`
`1098`	`1099`	`Attribute::Unparsed(u) => u.id.attr_id,`
`1099`	`1100`	`_ => panic!(),`
`1100`	`1101`	`}`
`1101`	`1102`	`}`
`1102`	`1103`
	`1104`	`+ #[inline]`
`1103`	`1105`	`fn meta_item_list(&self) -> Option<ThinVec<ast::MetaItemInner>> {`
`1104`	`1106`	`match &self {`
`1105`	`1107`	`Attribute::Unparsed(n) => match n.as_ref() {`
`@@ -1112,15 +1114,18 @@ impl AttributeExt for Attribute {`
`1112`	`1114`	`}`
`1113`	`1115`	`}`
`1114`	`1116`
	`1117`	`+ #[inline]`
`1115`	`1118`	`fn value_str(&self) -> Option<Symbol> {`
`1116`	`1119`	`self.value_lit().and_then(\|x\| x.value_str())`
`1117`	`1120`	`}`
`1118`	`1121`
	`1122`	`+ #[inline]`
`1119`	`1123`	`fn value_span(&self) -> Option<Span> {`
`1120`	`1124`	`self.value_lit().map(\|i\| i.span)`
`1121`	`1125`	`}`
`1122`	`1126`
`1123`	`1127`	/// For a single-segment attribute, returns its name; otherwise, returns `None`.
	`1128`	`+ #[inline]`
`1124`	`1129`	`fn ident(&self) -> Option<Ident> {`
`1125`	`1130`	`match &self {`
`1126`	`1131`	`Attribute::Unparsed(n) => {`
`@@ -1134,6 +1139,7 @@ impl AttributeExt for Attribute {`
`1134`	`1139`	`}`
`1135`	`1140`	`}`
`1136`	`1141`
	`1142`	`+ #[inline]`
`1137`	`1143`	`fn path_matches(&self, name: &[Symbol]) -> bool {`
`1138`	`1144`	`match &self {`
`1139`	`1145`	`Attribute::Unparsed(n) => {`
`@@ -1144,11 +1150,12 @@ impl AttributeExt for Attribute {`
`1144`	`1150`	`}`
`1145`	`1151`	`}`
`1146`	`1152`
	`1153`	`+ #[inline]`
`1147`	`1154`	`fn is_doc_comment(&self) -> bool {`
`1148`		`- // FIXME(jdonszelmann): make the 2nd check unnecessary here`
`1149`	`1155`	`matches!(self, Attribute::Parsed(AttributeKind::DocComment { .. }))`
`1150`	`1156`	`}`
`1151`	`1157`
	`1158`	`+ #[inline]`
`1152`	`1159`	`fn span(&self) -> Span {`
`1153`	`1160`	`match &self {`
`1154`	`1161`	`Attribute::Unparsed(u) => u.span,`
`@@ -1159,6 +1166,7 @@ impl AttributeExt for Attribute {`
`1159`	`1166`	`}`
`1160`	`1167`	`}`
`1161`	`1168`
	`1169`	`+ #[inline]`
`1162`	`1170`	`fn is_word(&self) -> bool {`
`1163`	`1171`	`match &self {`
`1164`	`1172`	`Attribute::Unparsed(n) => {`
`@@ -1168,20 +1176,23 @@ impl AttributeExt for Attribute {`
`1168`	`1176`	`}`
`1169`	`1177`	`}`
`1170`	`1178`
	`1179`	`+ #[inline]`
`1171`	`1180`	`fn ident_path(&self) -> Option<SmallVec<[Ident; 1]>> {`
`1172`	`1181`	`match &self {`
`1173`	`1182`	`Attribute::Unparsed(n) => Some(n.path.segments.iter().copied().collect()),`
`1174`	`1183`	`_ => None,`
`1175`	`1184`	`}`
`1176`	`1185`	`}`
`1177`	`1186`
	`1187`	`+ #[inline]`
`1178`	`1188`	`fn doc_str(&self) -> Option<Symbol> {`
`1179`	`1189`	`match &self {`
`1180`	`1190`	`Attribute::Parsed(AttributeKind::DocComment { comment, .. }) => Some(*comment),`
`1181`	`1191`	`Attribute::Unparsed(_) if self.has_name(sym::doc) => self.value_str(),`
`1182`	`1192`	`_ => None,`
`1183`	`1193`	`}`
`1184`	`1194`	`}`
	`1195`	`+ #[inline]`
`1185`	`1196`	`fn doc_str_and_comment_kind(&self) -> Option<(Symbol, CommentKind)> {`
`1186`	`1197`	`match &self {`
`1187`	`1198`	`Attribute::Parsed(AttributeKind::DocComment { kind, comment, .. }) => {`
`@@ -1194,6 +1205,7 @@ impl AttributeExt for Attribute {`
`1194`	`1205`	`}`
`1195`	`1206`	`}`
`1196`	`1207`
	`1208`	`+ #[inline]`
`1197`	`1209`	`fn style(&self) -> AttrStyle {`
`1198`	`1210`	`match &self {`
`1199`	`1211`	`Attribute::Unparsed(u) => u.style,`
`@@ -1205,34 +1217,42 @@ impl AttributeExt for Attribute {`
`1205`	`1217`
`1206`	`1218`	`// FIXME(fn_delegation): use function delegation instead of manually forwarding`
`1207`	`1219`	`impl Attribute {`
	`1220`	`+ #[inline]`
`1208`	`1221`	`pub fn id(&self) -> AttrId {`
`1209`	`1222`	`AttributeExt::id(self)`
`1210`	`1223`	`}`
`1211`	`1224`
	`1225`	`+ #[inline]`
`1212`	`1226`	`pub fn name_or_empty(&self) -> Symbol {`
`1213`	`1227`	`AttributeExt::name_or_empty(self)`
`1214`	`1228`	`}`
`1215`	`1229`
	`1230`	`+ #[inline]`
`1216`	`1231`	`pub fn meta_item_list(&self) -> Option<ThinVec<MetaItemInner>> {`
`1217`	`1232`	`AttributeExt::meta_item_list(self)`
`1218`	`1233`	`}`
`1219`	`1234`
	`1235`	`+ #[inline]`
`1220`	`1236`	`pub fn value_str(&self) -> Option<Symbol> {`
`1221`	`1237`	`AttributeExt::value_str(self)`
`1222`	`1238`	`}`
`1223`	`1239`
	`1240`	`+ #[inline]`
`1224`	`1241`	`pub fn value_span(&self) -> Option<Span> {`
`1225`	`1242`	`AttributeExt::value_span(self)`
`1226`	`1243`	`}`
`1227`	`1244`
	`1245`	`+ #[inline]`
`1228`	`1246`	`pub fn ident(&self) -> Option<Ident> {`
`1229`	`1247`	`AttributeExt::ident(self)`
`1230`	`1248`	`}`
`1231`	`1249`
	`1250`	`+ #[inline]`
`1232`	`1251`	`pub fn path_matches(&self, name: &[Symbol]) -> bool {`
`1233`	`1252`	`AttributeExt::path_matches(self, name)`
`1234`	`1253`	`}`
`1235`	`1254`
	`1255`	`+ #[inline]`
`1236`	`1256`	`pub fn is_doc_comment(&self) -> bool {`
`1237`	`1257`	`AttributeExt::is_doc_comment(self)`
`1238`	`1258`	`}`
`@@ -1242,34 +1262,42 @@ impl Attribute {`
`1242`	`1262`	`AttributeExt::has_name(self, name)`
`1243`	`1263`	`}`
`1244`	`1264`
	`1265`	`+ #[inline]`
`1245`	`1266`	`pub fn span(&self) -> Span {`
`1246`	`1267`	`AttributeExt::span(self)`
`1247`	`1268`	`}`
`1248`	`1269`
	`1270`	`+ #[inline]`
`1249`	`1271`	`pub fn is_word(&self) -> bool {`
`1250`	`1272`	`AttributeExt::is_word(self)`
`1251`	`1273`	`}`
`1252`	`1274`
	`1275`	`+ #[inline]`
`1253`	`1276`	`pub fn path(&self) -> SmallVec<[Symbol; 1]> {`
`1254`	`1277`	`AttributeExt::path(self)`
`1255`	`1278`	`}`
`1256`	`1279`
	`1280`	`+ #[inline]`
`1257`	`1281`	`pub fn ident_path(&self) -> Option<SmallVec<[Ident; 1]>> {`
`1258`	`1282`	`AttributeExt::ident_path(self)`
`1259`	`1283`	`}`
`1260`	`1284`
	`1285`	`+ #[inline]`
`1261`	`1286`	`pub fn doc_str(&self) -> Option<Symbol> {`
`1262`	`1287`	`AttributeExt::doc_str(self)`
`1263`	`1288`	`}`
`1264`	`1289`
	`1290`	`+ #[inline]`
`1265`	`1291`	`pub fn is_proc_macro_attr(&self) -> bool {`
`1266`	`1292`	`AttributeExt::is_proc_macro_attr(self)`
`1267`	`1293`	`}`
`1268`	`1294`
	`1295`	`+ #[inline]`
`1269`	`1296`	`pub fn doc_str_and_comment_kind(&self) -> Option<(Symbol, CommentKind)> {`
`1270`	`1297`	`AttributeExt::doc_str_and_comment_kind(self)`
`1271`	`1298`	`}`
`1272`	`1299`
	`1300`	`+ #[inline]`
`1273`	`1301`	`pub fn style(&self) -> AttrStyle {`
`1274`	`1302`	`AttributeExt::style(self)`
`1275`	`1303`	`}`