Skip to content

Commit 623e99e

Browse files
UrgauUrgau
committed
Remove deprecated --check-cfg names() and values() syntax
1 parent 347e382 commit 623e99e

35 files changed

+173
-397
lines changed

Diff for: ‎compiler/rustc_interface/src/interface.rs

+83-157
Original file line numberDiff line numberDiff line change
@@ -10,8 +10,8 @@ use rustc_data_structures::sync::Lrc;
1010
use rustc_errors::registry::Registry;
1111
use rustc_errors::{ErrorGuaranteed, Handler};
1212
use rustc_lint::LintStore;
13+
use rustc_middle::ty;
1314
use rustc_middle::util::Providers;
14-
use rustc_middle::{bug, ty};
1515
use rustc_parse::maybe_new_parser_from_source_str;
1616
use rustc_query_impl::QueryCtxt;
1717
use rustc_query_system::query::print_query_stack;
@@ -122,7 +122,6 @@ pub(crate) fn parse_check_cfg(handler: &EarlyErrorHandler, specs: Vec<String>) -
122122
let exhaustive_values = !specs.is_empty();
123123
let mut check_cfg = CheckCfg { exhaustive_names, exhaustive_values, ..CheckCfg::default() };
124124

125-
let mut old_syntax = None;
126125
for s in specs {
127126
let sess = ParseSess::with_silent_emitter(Some(format!(
128127
"this error occurred on the command line: `--check-cfg={s}`"
@@ -160,174 +159,101 @@ pub(crate) fn parse_check_cfg(handler: &EarlyErrorHandler, specs: Vec<String>) -
160159
expected_error();
161160
};
162161

163-
let mut set_old_syntax = || {
164-
// defaults are flipped for the old syntax
165-
if old_syntax == None {
166-
check_cfg.exhaustive_names = false;
167-
check_cfg.exhaustive_values = false;
168-
}
169-
old_syntax = Some(true);
170-
};
171-
172-
if meta_item.has_name(sym::names) {
173-
set_old_syntax();
174-
175-
check_cfg.exhaustive_names = true;
176-
for arg in args {
177-
if arg.is_word()
178-
&& let Some(ident) = arg.ident()
179-
{
180-
check_cfg.expecteds.entry(ident.name).or_insert(ExpectedValues::Any);
181-
} else {
182-
error!("`names()` arguments must be simple identifiers");
183-
}
184-
}
185-
} else if meta_item.has_name(sym::values) {
186-
set_old_syntax();
187-
188-
if let Some((name, values)) = args.split_first() {
189-
if name.is_word()
190-
&& let Some(ident) = name.ident()
191-
{
192-
let expected_values = check_cfg
193-
.expecteds
194-
.entry(ident.name)
195-
.and_modify(|expected_values| match expected_values {
196-
ExpectedValues::Some(_) => {}
197-
ExpectedValues::Any => {
198-
// handle the case where names(...) was done
199-
// before values by changing to a list
200-
*expected_values = ExpectedValues::Some(FxHashSet::default());
201-
}
202-
})
203-
.or_insert_with(|| ExpectedValues::Some(FxHashSet::default()));
162+
if !meta_item.has_name(sym::cfg) {
163+
expected_error();
164+
}
204165

205-
let ExpectedValues::Some(expected_values) = expected_values else {
206-
bug!("`expected_values` should be a list a values")
207-
};
166+
let mut names = Vec::new();
167+
let mut values: FxHashSet<_> = Default::default();
208168

209-
for val in values {
210-
if let Some(LitKind::Str(s, _)) = val.lit().map(|lit| &lit.kind) {
211-
expected_values.insert(Some(*s));
212-
} else {
213-
error!("`values()` arguments must be string literals");
214-
}
215-
}
169+
let mut any_specified = false;
170+
let mut values_specified = false;
171+
let mut values_any_specified = false;
216172

217-
if values.is_empty() {
218-
expected_values.insert(None);
219-
}
220-
} else {
221-
error!("`values()` first argument must be a simple identifier");
173+
for arg in args {
174+
if arg.is_word()
175+
&& let Some(ident) = arg.ident()
176+
{
177+
if values_specified {
178+
error!("`cfg()` names cannot be after values");
222179
}
223-
} else if args.is_empty() {
224-
check_cfg.exhaustive_values = true;
225-
} else {
226-
expected_error();
227-
}
228-
} else if meta_item.has_name(sym::cfg) {
229-
old_syntax = Some(false);
230-
231-
let mut names = Vec::new();
232-
let mut values: FxHashSet<_> = Default::default();
233-
234-
let mut any_specified = false;
235-
let mut values_specified = false;
236-
let mut values_any_specified = false;
237-
238-
for arg in args {
239-
if arg.is_word()
240-
&& let Some(ident) = arg.ident()
241-
{
242-
if values_specified {
243-
error!("`cfg()` names cannot be after values");
244-
}
245-
names.push(ident);
246-
} else if arg.has_name(sym::any)
247-
&& let Some(args) = arg.meta_item_list()
248-
{
249-
if any_specified {
250-
error!("`any()` cannot be specified multiple times");
251-
}
252-
any_specified = true;
253-
if !args.is_empty() {
254-
error!("`any()` must be empty");
255-
}
256-
} else if arg.has_name(sym::values)
257-
&& let Some(args) = arg.meta_item_list()
258-
{
259-
if names.is_empty() {
260-
error!("`values()` cannot be specified before the names");
261-
} else if values_specified {
262-
error!("`values()` cannot be specified multiple times");
263-
}
264-
values_specified = true;
265-
266-
for arg in args {
267-
if let Some(LitKind::Str(s, _)) = arg.lit().map(|lit| &lit.kind) {
268-
values.insert(Some(*s));
269-
} else if arg.has_name(sym::any)
270-
&& let Some(args) = arg.meta_item_list()
271-
{
272-
if values_any_specified {
273-
error!("`any()` in `values()` cannot be specified multiple times");
274-
}
275-
values_any_specified = true;
276-
if !args.is_empty() {
277-
error!("`any()` must be empty");
278-
}
279-
} else {
280-
error!("`values()` arguments must be string literals or `any()`");
180+
names.push(ident);
181+
} else if arg.has_name(sym::any)
182+
&& let Some(args) = arg.meta_item_list()
183+
{
184+
if any_specified {
185+
error!("`any()` cannot be specified multiple times");
186+
}
187+
any_specified = true;
188+
if !args.is_empty() {
189+
error!("`any()` must be empty");
190+
}
191+
} else if arg.has_name(sym::values)
192+
&& let Some(args) = arg.meta_item_list()
193+
{
194+
if names.is_empty() {
195+
error!("`values()` cannot be specified before the names");
196+
} else if values_specified {
197+
error!("`values()` cannot be specified multiple times");
198+
}
199+
values_specified = true;
200+
201+
for arg in args {
202+
if let Some(LitKind::Str(s, _)) = arg.lit().map(|lit| &lit.kind) {
203+
values.insert(Some(*s));
204+
} else if arg.has_name(sym::any)
205+
&& let Some(args) = arg.meta_item_list()
206+
{
207+
if values_any_specified {
208+
error!("`any()` in `values()` cannot be specified multiple times");
209+
}
210+
values_any_specified = true;
211+
if !args.is_empty() {
212+
error!("`any()` must be empty");
281213
}
214+
} else {
215+
error!("`values()` arguments must be string literals or `any()`");
282216
}
283-
} else {
284-
error!(
285-
"`cfg()` arguments must be simple identifiers, `any()` or `values(...)`"
286-
);
287217
}
218+
} else {
219+
error!("`cfg()` arguments must be simple identifiers, `any()` or `values(...)`");
288220
}
221+
}
289222

290-
if values.is_empty() && !values_any_specified && !any_specified {
291-
values.insert(None);
292-
} else if !values.is_empty() && values_any_specified {
293-
error!(
294-
"`values()` arguments cannot specify string literals and `any()` at the same time"
295-
);
296-
}
223+
if values.is_empty() && !values_any_specified && !any_specified {
224+
values.insert(None);
225+
} else if !values.is_empty() && values_any_specified {
226+
error!(
227+
"`values()` arguments cannot specify string literals and `any()` at the same time"
228+
);
229+
}
297230

298-
if any_specified {
299-
if names.is_empty()
300-
&& values.is_empty()
301-
&& !values_specified
302-
&& !values_any_specified
303-
{
304-
check_cfg.exhaustive_names = false;
305-
} else {
306-
error!("`cfg(any())` can only be provided in isolation");
307-
}
231+
if any_specified {
232+
if names.is_empty() && values.is_empty() && !values_specified && !values_any_specified {
233+
check_cfg.exhaustive_names = false;
308234
} else {
309-
for name in names {
310-
check_cfg
311-
.expecteds
312-
.entry(name.name)
313-
.and_modify(|v| match v {
314-
ExpectedValues::Some(v) if !values_any_specified => {
315-
v.extend(values.clone())
316-
}
317-
ExpectedValues::Some(_) => *v = ExpectedValues::Any,
318-
ExpectedValues::Any => {}
319-
})
320-
.or_insert_with(|| {
321-
if values_any_specified {
322-
ExpectedValues::Any
323-
} else {
324-
ExpectedValues::Some(values.clone())
325-
}
326-
});
327-
}
235+
error!("`cfg(any())` can only be provided in isolation");
328236
}
329237
} else {
330-
expected_error();
238+
for name in names {
239+
check_cfg
240+
.expecteds
241+
.entry(name.name)
242+
.and_modify(|v| match v {
243+
ExpectedValues::Some(v) if !values_any_specified => {
244+
v.extend(values.clone())
245+
}
246+
ExpectedValues::Some(_) => *v = ExpectedValues::Any,
247+
ExpectedValues::Any => {}
248+
})
249+
.or_insert_with(|| {
250+
if values_any_specified {
251+
ExpectedValues::Any
252+
} else {
253+
ExpectedValues::Some(values.clone())
254+
}
255+
});
256+
}
331257
}
332258
}
333259

Diff for: ‎src/doc/unstable-book/src/compiler-flags/check-cfg.md

-67
Original file line numberDiff line numberDiff line change
@@ -190,70 +190,3 @@ fn shoot_lasers() {}
190190
// the cfg(feature) list
191191
fn write_shakespeare() {}
192192
```
193-
194-
## The deprecated `names(...)` form
195-
196-
The `names(...)` form enables checking the names. This form uses a named list:
197-
198-
```bash
199-
rustc --check-cfg 'names(name1, name2, ... nameN)'
200-
```
201-
202-
where each `name` is a bare identifier (has no quotes). The order of the names is not significant.
203-
204-
If `--check-cfg names(...)` is specified at least once, then `rustc` will check all references to
205-
condition names. `rustc` will check every `#[cfg]` attribute, `#[cfg_attr]` attribute, `cfg` clause
206-
inside `#[link]` attribute and `cfg!(...)` call against the provided list of expected condition
207-
names. If a name is not present in this list, then `rustc` will report an `unexpected_cfgs` lint
208-
diagnostic. The default diagnostic level for this lint is `Warn`.
209-
210-
If `--check-cfg names(...)` is not specified, then `rustc` will not check references to condition
211-
names.
212-
213-
`--check-cfg names(...)` may be specified more than once. The result is that the list of valid
214-
condition names is merged across all options. It is legal for a condition name to be specified
215-
more than once; redundantly specifying a condition name has no effect.
216-
217-
To enable checking condition names with an empty set of valid condition names, use the following
218-
form. The parentheses are required.
219-
220-
```bash
221-
rustc --check-cfg 'names()'
222-
```
223-
224-
Note that `--check-cfg 'names()'` is _not_ equivalent to omitting the option entirely.
225-
The first form enables checking condition names, while specifying that there are no valid
226-
condition names (outside of the set of well-known names defined by `rustc`). Omitting the
227-
`--check-cfg 'names(...)'` option does not enable checking condition names.
228-
229-
## The deprecated `values(...)` form
230-
231-
The `values(...)` form enables checking the values within list-valued conditions. It has this
232-
form:
233-
234-
```bash
235-
rustc --check-cfg `values(name, "value1", "value2", ... "valueN")'
236-
```
237-
238-
where `name` is a bare identifier (has no quotes) and each `"value"` term is a quoted literal
239-
string. `name` specifies the name of the condition, such as `feature` or `target_os`.
240-
241-
When the `values(...)` option is specified, `rustc` will check every `#[cfg(name = "value")]`
242-
attribute, `#[cfg_attr(name = "value")]` attribute, `#[link(name = "a", cfg(name = "value"))]`
243-
and `cfg!(name = "value")` call. It will check that the `"value"` specified is present in the
244-
list of expected values. If `"value"` is not in it, then `rustc` will report an `unexpected_cfgs`
245-
lint diagnostic. The default diagnostic level for this lint is `Warn`.
246-
247-
To enable checking of values, but to provide an empty set of valid values, use this form:
248-
249-
```bash
250-
rustc --check-cfg `values(name)`
251-
```
252-
253-
The `--check-cfg values(...)` option can be repeated, both for the same condition name and for
254-
different names. If it is repeated for the same condition name, then the sets of values for that
255-
condition are merged together.
256-
257-
If `values()` is specified, then `rustc` will enable the checking of well-known values defined
258-
by itself. Note that it's necessary to specify the `values()` form to enable the checking of
259-
well known values, specifying the other forms doesn't implicitly enable it.

Diff for: ‎tests/ui/check-cfg/exhaustive-names-values.empty_cfg.stderr

+4-4
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
warning: unexpected `cfg` condition name: `unknown_key`
2-
--> $DIR/exhaustive-names-values.rs:11:7
2+
--> $DIR/exhaustive-names-values.rs:10:7
33
|
44
LL | #[cfg(unknown_key = "value")]
55
| ^^^^^^^^^^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL | #[cfg(unknown_key = "value")]
88
= note: `#[warn(unexpected_cfgs)]` on by default
99

1010
warning: unexpected `cfg` condition value: `value`
11-
--> $DIR/exhaustive-names-values.rs:15:7
11+
--> $DIR/exhaustive-names-values.rs:14:7
1212
|
1313
LL | #[cfg(test = "value")]
1414
| ^^^^----------
@@ -18,13 +18,13 @@ LL | #[cfg(test = "value")]
1818
= note: no expected value for `test`
1919

2020
warning: unexpected `cfg` condition name: `feature`
21-
--> $DIR/exhaustive-names-values.rs:19:7
21+
--> $DIR/exhaustive-names-values.rs:18:7
2222
|
2323
LL | #[cfg(feature = "unk")]
2424
| ^^^^^^^^^^^^^^^
2525

2626
warning: unexpected `cfg` condition name: `feature`
27-
--> $DIR/exhaustive-names-values.rs:26:7
27+
--> $DIR/exhaustive-names-values.rs:25:7
2828
|
2929
LL | #[cfg(feature = "std")]
3030
| ^^^^^^^^^^^^^^^

0 commit comments

Comments
 (0)