Skip to content

Commit 8cc254b

Browse files
scrabshascrabsha
committed
Add AcceptContext::expect_key_value 
1 parent c7fe5e9 commit 8cc254b

34 files changed

Lines changed: 383 additions & 406 deletions

‎compiler/rustc_attr_parsing/src/attributes/allow_unstable.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -91,7 +91,7 @@ fn parse_unstable<S: Stage>(
9191

9292
for param in list.mixed() {
9393
let param_span = param.span();
94-
if let Some(ident) = param.meta_item().and_then(|i| i.path().word()) {
94+
if let Some(ident) = param.as_meta_item().and_then(|i| i.path().word()) {
9595
res.push(ident.name);
9696
} else {
9797
cx.emit_err(session_diagnostics::ExpectsFeatures {

‎compiler/rustc_attr_parsing/src/attributes/autodiff.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -48,7 +48,7 @@ impl<S: Stage> SingleAttributeParser<S> for RustcAutodiffParser {
4848
cx.adcx().expected_at_least_one_argument(list.span);
4949
return None;
5050
};
51-
let Some(mode) = mode.meta_item() else {
51+
let Some(mode) = mode.as_meta_item() else {
5252
cx.adcx().expected_identifier(mode.span());
5353
return None;
5454
};

‎compiler/rustc_attr_parsing/src/attributes/cfg.rs‎

Lines changed: 6 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -116,7 +116,7 @@ pub fn parse_cfg_entry<S: Stage>(
116116
else {
117117
return Err(cx.adcx().expected_identifier(meta.path().span()));
118118
};
119-
parse_name_value(name, meta.path().span(), a.name_value(), meta.span(), cx)?
119+
parse_name_value(name, meta.path().span(), a.as_name_value(), meta.span(), cx)?
120120
}
121121
},
122122
MetaItemOrLitParser::Lit(lit) => match lit.kind {
@@ -178,23 +178,16 @@ fn parse_cfg_entry_target<S: Stage>(
178178
let mut result = ThinVec::new();
179179
for sub_item in list.mixed() {
180180
// First, validate that this is a NameValue item
181-
let Some(sub_item) = sub_item.meta_item() else {
182-
cx.adcx().expected_name_value(sub_item.span(), None);
183-
continue;
184-
};
185-
let Some(nv) = sub_item.args().name_value() else {
186-
cx.adcx().expected_name_value(sub_item.span(), None);
181+
let Some((name, value)) = cx.expect_name_value(sub_item, sub_item.span(), None) else {
187182
continue;
188183
};
189184

190185
// Then, parse it as a name-value item
191-
let Some(name) = sub_item.path().word_sym().filter(|s| !s.is_path_segment_keyword()) else {
192-
return Err(cx.adcx().expected_identifier(sub_item.path().span()));
193-
};
186+
if name.is_path_segment_keyword() {
187+
return Err(cx.adcx().expected_identifier(name.span));
188+
}
194189
let name = Symbol::intern(&format!("target_{name}"));
195-
if let Ok(cfg) =
196-
parse_name_value(name, sub_item.path().span(), Some(nv), sub_item.span(), cx)
197-
{
190+
if let Ok(cfg) = parse_name_value(name, sub_item.span(), Some(value), sub_item.span(), cx) {
198191
result.push(cfg);
199192
}
200193
}

‎compiler/rustc_attr_parsing/src/attributes/cfi_encoding.rs‎

Lines changed: 1 addition & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -11,11 +11,7 @@ impl<S: Stage> SingleAttributeParser<S> for CfiEncodingParser {
1111
const TEMPLATE: AttributeTemplate = template!(NameValueStr: "encoding");
1212

1313
fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
14-
let Some(name_value) = args.name_value() else {
15-
let attr_span = cx.attr_span;
16-
cx.adcx().expected_name_value(attr_span, Some(sym::cfi_encoding));
17-
return None;
18-
};
14+
let name_value = cx.expect_name_value(args, cx.attr_span, Some(sym::cfi_encoding))?;
1915

2016
let Some(value_str) = name_value.value_as_str() else {
2117
cx.adcx().expected_string_literal(name_value.value_span, None);

‎compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs‎

Lines changed: 34 additions & 70 deletions
Original file line numberDiff line numberDiff line change
@@ -26,7 +26,7 @@ impl<S: Stage> SingleAttributeParser<S> for OptimizeParser {
2626
fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
2727
let single = cx.expect_single_element_list(args, cx.attr_span)?;
2828

29-
let res = match single.meta_item().and_then(|i| i.path().word().map(|i| i.name)) {
29+
let res = match single.as_meta_item().and_then(|i| i.path().word().map(|i| i.name)) {
3030
Some(sym::size) => OptimizeAttr::Size,
3131
Some(sym::speed) => OptimizeAttr::Speed,
3232
Some(sym::none) => OptimizeAttr::DoNotOptimize,
@@ -80,7 +80,7 @@ impl<S: Stage> SingleAttributeParser<S> for CoverageParser {
8080
let mut fail_incorrect_argument =
8181
|span| cx.adcx().expected_specific_argument(span, &[sym::on, sym::off]);
8282

83-
let Some(arg) = arg.meta_item() else {
83+
let Some(arg) = arg.as_meta_item() else {
8484
fail_incorrect_argument(arg.span());
8585
return None;
8686
};
@@ -118,11 +118,7 @@ impl<S: Stage> SingleAttributeParser<S> for ExportNameParser {
118118
const TEMPLATE: AttributeTemplate = template!(NameValueStr: "name");
119119

120120
fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
121-
let Some(nv) = args.name_value() else {
122-
let attr_span = cx.attr_span;
123-
cx.adcx().expected_name_value(attr_span, None);
124-
return None;
125-
};
121+
let nv = cx.expect_name_value(args, cx.attr_span, None)?;
126122
let Some(name) = nv.value_as_str() else {
127123
cx.adcx().expected_string_literal(nv.value_span, Some(nv.value_as_lit()));
128124
return None;
@@ -146,11 +142,7 @@ impl<S: Stage> SingleAttributeParser<S> for RustcObjcClassParser {
146142
const TEMPLATE: AttributeTemplate = template!(NameValueStr: "ClassName");
147143

148144
fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
149-
let Some(nv) = args.name_value() else {
150-
let attr_span = cx.attr_span;
151-
cx.adcx().expected_name_value(attr_span, None);
152-
return None;
153-
};
145+
let nv = cx.expect_name_value(args, cx.attr_span, None)?;
154146
let Some(classname) = nv.value_as_str() else {
155147
// `#[rustc_objc_class = ...]` is expected to be used as an implementation detail
156148
// inside a standard library macro, but `cx.expected_string_literal` exposes too much.
@@ -177,11 +169,7 @@ impl<S: Stage> SingleAttributeParser<S> for RustcObjcSelectorParser {
177169
const TEMPLATE: AttributeTemplate = template!(NameValueStr: "methodName");
178170

179171
fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
180-
let Some(nv) = args.name_value() else {
181-
let attr_span = cx.attr_span;
182-
cx.adcx().expected_name_value(attr_span, None);
183-
return None;
184-
};
172+
let nv = cx.expect_name_value(args, cx.attr_span, None)?;
185173
let Some(methname) = nv.value_as_str() else {
186174
// `#[rustc_objc_selector = ...]` is expected to be used as an implementation detail
187175
// inside a standard library macro, but `cx.expected_string_literal` exposes too much.
@@ -375,7 +363,7 @@ impl<S: Stage> AttributeParser<S> for UsedParser {
375363
return;
376364
};
377365

378-
match l.meta_item().and_then(|i| i.path().word_sym()) {
366+
match l.as_meta_item().and_then(|i| i.path().word_sym()) {
379367
Some(sym::compiler) => {
380368
if !cx.features().used_with_arg() {
381369
feature_err(
@@ -471,29 +459,20 @@ fn parse_tf_attribute<S: Stage>(
471459
return features;
472460
}
473461
for item in list.mixed() {
474-
let Some(name_value) = item.meta_item() else {
475-
cx.adcx().expected_name_value(item.span(), Some(sym::enable));
462+
let Some((ident, value)) = cx.expect_name_value(item, item.span(), Some(sym::enable))
463+
else {
476464
return features;
477465
};
478466

479467
// Validate name
480-
let Some(name) = name_value.path().word_sym() else {
481-
cx.adcx().expected_name_value(name_value.path().span(), Some(sym::enable));
482-
return features;
483-
};
484-
if name != sym::enable {
485-
cx.adcx().expected_name_value(name_value.path().span(), Some(sym::enable));
468+
if ident.name != sym::enable {
469+
cx.adcx().expected_specific_argument(ident.span, &[sym::enable]);
486470
return features;
487471
}
488472

489473
// Use value
490-
let Some(name_value) = name_value.args().name_value() else {
491-
cx.adcx().expected_name_value(item.span(), Some(sym::enable));
492-
return features;
493-
};
494-
let Some(value_str) = name_value.value_as_str() else {
495-
cx.adcx()
496-
.expected_string_literal(name_value.value_span, Some(name_value.value_as_lit()));
474+
let Some(value_str) = value.value_as_str() else {
475+
cx.adcx().expected_string_literal(value.value_span, Some(value.value_as_lit()));
497476
return features;
498477
};
499478
for feature in value_str.as_str().split(",") {
@@ -592,14 +571,7 @@ impl<S: Stage> SingleAttributeParser<S> for SanitizeParser {
592571
let mut rtsan = None;
593572

594573
for item in list.mixed() {
595-
let Some(item) = item.meta_item() else {
596-
cx.adcx().expected_name_value(item.span(), None);
597-
continue;
598-
};
599-
600-
let path = item.path().word_sym();
601-
let Some(value) = item.args().name_value() else {
602-
cx.adcx().expected_name_value(item.span(), path);
574+
let Some((ident, value)) = cx.expect_name_value(item, item.span(), None) else {
603575
continue;
604576
};
605577

@@ -628,20 +600,20 @@ impl<S: Stage> SingleAttributeParser<S> for SanitizeParser {
628600
}
629601
};
630602

631-
match path {
632-
Some(sym::address) | Some(sym::kernel_address) => {
603+
match ident.name {
604+
sym::address | sym::kernel_address => {
633605
apply(SanitizerSet::ADDRESS | SanitizerSet::KERNELADDRESS)
634606
}
635-
Some(sym::cfi) => apply(SanitizerSet::CFI),
636-
Some(sym::kcfi) => apply(SanitizerSet::KCFI),
637-
Some(sym::memory) => apply(SanitizerSet::MEMORY),
638-
Some(sym::memtag) => apply(SanitizerSet::MEMTAG),
639-
Some(sym::shadow_call_stack) => apply(SanitizerSet::SHADOWCALLSTACK),
640-
Some(sym::thread) => apply(SanitizerSet::THREAD),
641-
Some(sym::hwaddress) | Some(sym::kernel_hwaddress) => {
607+
sym::cfi => apply(SanitizerSet::CFI),
608+
sym::kcfi => apply(SanitizerSet::KCFI),
609+
sym::memory => apply(SanitizerSet::MEMORY),
610+
sym::memtag => apply(SanitizerSet::MEMTAG),
611+
sym::shadow_call_stack => apply(SanitizerSet::SHADOWCALLSTACK),
612+
sym::thread => apply(SanitizerSet::THREAD),
613+
sym::hwaddress | sym::kernel_hwaddress => {
642614
apply(SanitizerSet::HWADDRESS | SanitizerSet::KERNELHWADDRESS)
643615
}
644-
Some(sym::realtime) => match value.value_as_str() {
616+
sym::realtime => match value.value_as_str() {
645617
Some(sym::nonblocking) => rtsan = Some(RtsanSetting::Nonblocking),
646618
Some(sym::blocking) => rtsan = Some(RtsanSetting::Blocking),
647619
Some(sym::caller) => rtsan = Some(RtsanSetting::Caller),
@@ -654,7 +626,7 @@ impl<S: Stage> SingleAttributeParser<S> for SanitizeParser {
654626
},
655627
_ => {
656628
cx.adcx().expected_specific_argument_strings(
657-
item.path().span(),
629+
ident.span,
658630
&[
659631
sym::address,
660632
sym::kernel_address,
@@ -725,57 +697,49 @@ impl<S: Stage> SingleAttributeParser<S> for PatchableFunctionEntryParser {
725697
let mut errored = false;
726698

727699
for item in meta_item_list.mixed() {
728-
let Some(meta_item) = item.meta_item() else {
729-
errored = true;
730-
cx.adcx().expected_name_value(item.span(), None);
731-
continue;
732-
};
733-
734-
let Some(name_value_lit) = meta_item.args().name_value() else {
735-
errored = true;
736-
cx.adcx().expected_name_value(item.span(), None);
700+
let Some((ident, value)) = cx.expect_name_value(item, item.span(), None) else {
737701
continue;
738702
};
739703

740-
let attrib_to_write = match meta_item.ident().map(|ident| ident.name) {
741-
Some(sym::prefix_nops) => {
704+
let attrib_to_write = match ident.name {
705+
sym::prefix_nops => {
742706
// Duplicate prefixes are not allowed
743707
if prefix.is_some() {
744708
errored = true;
745-
cx.adcx().duplicate_key(meta_item.path().span(), sym::prefix_nops);
709+
cx.adcx().duplicate_key(ident.span, sym::prefix_nops);
746710
continue;
747711
}
748712
&mut prefix
749713
}
750-
Some(sym::entry_nops) => {
714+
sym::entry_nops => {
751715
// Duplicate entries are not allowed
752716
if entry.is_some() {
753717
errored = true;
754-
cx.adcx().duplicate_key(meta_item.path().span(), sym::entry_nops);
718+
cx.adcx().duplicate_key(ident.span, sym::entry_nops);
755719
continue;
756720
}
757721
&mut entry
758722
}
759723
_ => {
760724
errored = true;
761725
cx.adcx().expected_specific_argument(
762-
meta_item.path().span(),
726+
ident.span,
763727
&[sym::prefix_nops, sym::entry_nops],
764728
);
765729
continue;
766730
}
767731
};
768732

769-
let rustc_ast::LitKind::Int(val, _) = name_value_lit.value_as_lit().kind else {
733+
let rustc_ast::LitKind::Int(val, _) = value.value_as_lit().kind else {
770734
errored = true;
771-
cx.adcx().expected_integer_literal(name_value_lit.value_span);
735+
cx.adcx().expected_integer_literal(value.value_span);
772736
continue;
773737
};
774738

775739
let Ok(val) = val.get().try_into() else {
776740
errored = true;
777741
cx.adcx().expected_integer_literal_in_range(
778-
name_value_lit.value_span,
742+
value.value_span,
779743
u8::MIN as isize,
780744
u8::MAX as isize,
781745
);

0 commit comments

Comments
 (0)