From 173dcb211a08352900b29968cded2024aee6166d Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Wed, 25 Oct 2023 11:10:21 -0700 Subject: [PATCH 01/10] Touch up syn parsing in symbols macro --- compiler/rustc_macros/src/symbols.rs | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/compiler/rustc_macros/src/symbols.rs b/compiler/rustc_macros/src/symbols.rs index 04facbf657d22..46ae1779bbe45 100644 --- a/compiler/rustc_macros/src/symbols.rs +++ b/compiler/rustc_macros/src/symbols.rs @@ -59,10 +59,8 @@ struct Symbol { impl Parse for Symbol { fn parse(input: ParseStream<'_>) -> Result { let name = input.parse()?; - let value = match input.parse::() { - Ok(_) => Some(input.parse()?), - Err(_) => None, - }; + let colon_token: Option = input.parse()?; + let value = if colon_token.is_some() { Some(input.parse()?) } else { None }; Ok(Symbol { name, value }) } From ba17934bc1f6fce2e4f9e5494efdb90508eafecd Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Wed, 25 Oct 2023 11:12:32 -0700 Subject: [PATCH 02/10] Represent symbol value as enum to prepare for supporting env vars --- compiler/rustc_macros/src/symbols.rs | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/compiler/rustc_macros/src/symbols.rs b/compiler/rustc_macros/src/symbols.rs index 46ae1779bbe45..4df7eb6310493 100644 --- a/compiler/rustc_macros/src/symbols.rs +++ b/compiler/rustc_macros/src/symbols.rs @@ -53,14 +53,20 @@ impl Parse for Keyword { struct Symbol { name: Ident, - value: Option, + value: Value, +} + +enum Value { + SameAsName, + String(LitStr), } impl Parse for Symbol { fn parse(input: ParseStream<'_>) -> Result { let name = input.parse()?; let colon_token: Option = input.parse()?; - let value = if colon_token.is_some() { Some(input.parse()?) } else { None }; + let value = + if colon_token.is_some() { Value::String(input.parse()?) } else { Value::SameAsName }; Ok(Symbol { name, value }) } @@ -168,8 +174,8 @@ fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec) { for symbol in input.symbols.iter() { let name = &symbol.name; let value = match &symbol.value { - Some(value) => value.value(), - None => name.to_string(), + Value::SameAsName => name.to_string(), + Value::String(lit) => lit.value(), }; check_dup(symbol.name.span(), &value, &mut errors); check_order(symbol.name.span(), &name.to_string(), &mut errors); From 95742ff23cf2283da796f483386367f7fdc06bc6 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Wed, 25 Oct 2023 11:15:18 -0700 Subject: [PATCH 03/10] Add a Parse impl for symbol Value --- compiler/rustc_macros/src/symbols.rs | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/compiler/rustc_macros/src/symbols.rs b/compiler/rustc_macros/src/symbols.rs index 4df7eb6310493..c48df8313b23c 100644 --- a/compiler/rustc_macros/src/symbols.rs +++ b/compiler/rustc_macros/src/symbols.rs @@ -65,13 +65,19 @@ impl Parse for Symbol { fn parse(input: ParseStream<'_>) -> Result { let name = input.parse()?; let colon_token: Option = input.parse()?; - let value = - if colon_token.is_some() { Value::String(input.parse()?) } else { Value::SameAsName }; + let value = if colon_token.is_some() { input.parse()? } else { Value::SameAsName }; Ok(Symbol { name, value }) } } +impl Parse for Value { + fn parse(input: ParseStream<'_>) -> Result { + let lit: LitStr = input.parse()?; + Ok(Value::String(lit)) + } +} + struct Input { keywords: Punctuated, symbols: Punctuated, From 8dea49ad7baa4fbb8b2394a6682d601065350134 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Wed, 25 Oct 2023 13:20:47 -0700 Subject: [PATCH 04/10] Delete counter from symbols proc macro in favor of hashmap as source of truth --- compiler/rustc_macros/src/symbols.rs | 42 ++++++++++++++++------------ 1 file changed, 24 insertions(+), 18 deletions(-) diff --git a/compiler/rustc_macros/src/symbols.rs b/compiler/rustc_macros/src/symbols.rs index c48df8313b23c..d06f1d0821411 100644 --- a/compiler/rustc_macros/src/symbols.rs +++ b/compiler/rustc_macros/src/symbols.rs @@ -121,6 +121,11 @@ pub fn symbols(input: TokenStream) -> TokenStream { output } +struct Preinterned { + idx: u32, + span_of_name: Span, +} + fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec) { let mut errors = Errors::default(); @@ -137,17 +142,20 @@ fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec) { let mut keyword_stream = quote! {}; let mut symbols_stream = quote! {}; let mut prefill_stream = quote! {}; - let mut counter = 0u32; - let mut keys = - HashMap::::with_capacity(input.keywords.len() + input.symbols.len() + 10); + let mut entries = HashMap::::with_capacity( + input.keywords.len() + input.symbols.len() + 10, + ); let mut prev_key: Option<(Span, String)> = None; - let mut check_dup = |span: Span, str: &str, errors: &mut Errors| { - if let Some(prev_span) = keys.get(str) { + let mut insert = |span: Span, str: &str, errors: &mut Errors| -> u32 { + if let Some(prev) = entries.get(str) { errors.error(span, format!("Symbol `{str}` is duplicated")); - errors.error(*prev_span, "location of previous definition".to_string()); + errors.error(prev.span_of_name, "location of previous definition".to_string()); + prev.idx } else { - keys.insert(str.to_string(), span); + let idx = u32::try_from(entries.len()).expect("way too many symbols"); + entries.insert(str.to_string(), Preinterned { idx, span_of_name: span }); + idx } }; @@ -166,14 +174,13 @@ fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec) { let name = &keyword.name; let value = &keyword.value; let value_string = value.value(); - check_dup(keyword.name.span(), &value_string, &mut errors); + let idx = insert(keyword.name.span(), &value_string, &mut errors); prefill_stream.extend(quote! { #value, }); keyword_stream.extend(quote! { - pub const #name: Symbol = Symbol::new(#counter); + pub const #name: Symbol = Symbol::new(#idx); }); - counter += 1; } // Generate the listed symbols. @@ -183,32 +190,31 @@ fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec) { Value::SameAsName => name.to_string(), Value::String(lit) => lit.value(), }; - check_dup(symbol.name.span(), &value, &mut errors); + let idx = insert(symbol.name.span(), &value, &mut errors); check_order(symbol.name.span(), &name.to_string(), &mut errors); prefill_stream.extend(quote! { #value, }); symbols_stream.extend(quote! { - pub const #name: Symbol = Symbol::new(#counter); + pub const #name: Symbol = Symbol::new(#idx); }); - counter += 1; } // Generate symbols for the strings "0", "1", ..., "9". - let digits_base = counter; - counter += 10; for n in 0..10 { let n = n.to_string(); - check_dup(Span::call_site(), &n, &mut errors); + insert(Span::call_site(), &n, &mut errors); prefill_stream.extend(quote! { #n, }); } + let symbol_digits_base = entries["0"].idx; + let preinterned_symbols_count = u32::try_from(entries.len()).expect("way too many symbols"); let output = quote! { - const SYMBOL_DIGITS_BASE: u32 = #digits_base; - const PREINTERNED_SYMBOLS_COUNT: u32 = #counter; + const SYMBOL_DIGITS_BASE: u32 = #symbol_digits_base; + const PREINTERNED_SYMBOLS_COUNT: u32 = #preinterned_symbols_count; #[doc(hidden)] #[allow(non_upper_case_globals)] From 726a43c1de78eb21a483896c052b353939531cdb Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Wed, 25 Oct 2023 13:42:58 -0700 Subject: [PATCH 05/10] Move symbols macro map into a struct --- compiler/rustc_macros/src/symbols.rs | 52 +++++++++++++++++----------- 1 file changed, 32 insertions(+), 20 deletions(-) diff --git a/compiler/rustc_macros/src/symbols.rs b/compiler/rustc_macros/src/symbols.rs index d06f1d0821411..76f77e6efeca0 100644 --- a/compiler/rustc_macros/src/symbols.rs +++ b/compiler/rustc_macros/src/symbols.rs @@ -126,6 +126,32 @@ struct Preinterned { span_of_name: Span, } +struct Entries { + map: HashMap, +} + +impl Entries { + fn with_capacity(capacity: usize) -> Self { + Entries { map: HashMap::with_capacity(capacity) } + } + + fn insert(&mut self, span: Span, str: &str, errors: &mut Errors) -> u32 { + if let Some(prev) = self.map.get(str) { + errors.error(span, format!("Symbol `{str}` is duplicated")); + errors.error(prev.span_of_name, "location of previous definition".to_string()); + prev.idx + } else { + let idx = self.len(); + self.map.insert(str.to_string(), Preinterned { idx, span_of_name: span }); + idx + } + } + + fn len(&self) -> u32 { + u32::try_from(self.map.len()).expect("way too many symbols") + } +} + fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec) { let mut errors = Errors::default(); @@ -142,23 +168,9 @@ fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec) { let mut keyword_stream = quote! {}; let mut symbols_stream = quote! {}; let mut prefill_stream = quote! {}; - let mut entries = HashMap::::with_capacity( - input.keywords.len() + input.symbols.len() + 10, - ); + let mut entries = Entries::with_capacity(input.keywords.len() + input.symbols.len() + 10); let mut prev_key: Option<(Span, String)> = None; - let mut insert = |span: Span, str: &str, errors: &mut Errors| -> u32 { - if let Some(prev) = entries.get(str) { - errors.error(span, format!("Symbol `{str}` is duplicated")); - errors.error(prev.span_of_name, "location of previous definition".to_string()); - prev.idx - } else { - let idx = u32::try_from(entries.len()).expect("way too many symbols"); - entries.insert(str.to_string(), Preinterned { idx, span_of_name: span }); - idx - } - }; - let mut check_order = |span: Span, str: &str, errors: &mut Errors| { if let Some((prev_span, ref prev_str)) = prev_key { if str < prev_str { @@ -174,7 +186,7 @@ fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec) { let name = &keyword.name; let value = &keyword.value; let value_string = value.value(); - let idx = insert(keyword.name.span(), &value_string, &mut errors); + let idx = entries.insert(keyword.name.span(), &value_string, &mut errors); prefill_stream.extend(quote! { #value, }); @@ -190,7 +202,7 @@ fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec) { Value::SameAsName => name.to_string(), Value::String(lit) => lit.value(), }; - let idx = insert(symbol.name.span(), &value, &mut errors); + let idx = entries.insert(symbol.name.span(), &value, &mut errors); check_order(symbol.name.span(), &name.to_string(), &mut errors); prefill_stream.extend(quote! { @@ -204,14 +216,14 @@ fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec) { // Generate symbols for the strings "0", "1", ..., "9". for n in 0..10 { let n = n.to_string(); - insert(Span::call_site(), &n, &mut errors); + entries.insert(Span::call_site(), &n, &mut errors); prefill_stream.extend(quote! { #n, }); } - let symbol_digits_base = entries["0"].idx; - let preinterned_symbols_count = u32::try_from(entries.len()).expect("way too many symbols"); + let symbol_digits_base = entries.map["0"].idx; + let preinterned_symbols_count = entries.len(); let output = quote! { const SYMBOL_DIGITS_BASE: u32 = #symbol_digits_base; const PREINTERNED_SYMBOLS_COUNT: u32 = #preinterned_symbols_count; From 65f025333427a881a3fa651a6fefcfa7f6a79354 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Wed, 25 Oct 2023 11:20:07 -0700 Subject: [PATCH 06/10] Support environment variable for interned Symbol value --- compiler/rustc_macros/src/lib.rs | 1 + compiler/rustc_macros/src/symbols.rs | 61 ++++++++++++++++++++++++++-- 2 files changed, 58 insertions(+), 4 deletions(-) diff --git a/compiler/rustc_macros/src/lib.rs b/compiler/rustc_macros/src/lib.rs index 85829906f4ef5..776ba8f9ca11a 100644 --- a/compiler/rustc_macros/src/lib.rs +++ b/compiler/rustc_macros/src/lib.rs @@ -4,6 +4,7 @@ #![feature(never_type)] #![feature(proc_macro_diagnostic)] #![feature(proc_macro_span)] +#![feature(proc_macro_tracked_env)] #![allow(rustc::default_hash_types)] #![deny(rustc::untranslatable_diagnostic)] #![deny(rustc::diagnostic_outside_of_impl)] diff --git a/compiler/rustc_macros/src/symbols.rs b/compiler/rustc_macros/src/symbols.rs index 76f77e6efeca0..fd2d56eb29c67 100644 --- a/compiler/rustc_macros/src/symbols.rs +++ b/compiler/rustc_macros/src/symbols.rs @@ -26,7 +26,7 @@ use proc_macro2::{Span, TokenStream}; use quote::quote; use std::collections::HashMap; use syn::parse::{Parse, ParseStream, Result}; -use syn::{braced, punctuated::Punctuated, Ident, LitStr, Token}; +use syn::{braced, punctuated::Punctuated, Expr, Ident, Lit, LitStr, Token}; #[cfg(test)] mod tests; @@ -59,6 +59,7 @@ struct Symbol { enum Value { SameAsName, String(LitStr), + Env(LitStr), } impl Parse for Symbol { @@ -73,8 +74,27 @@ impl Parse for Symbol { impl Parse for Value { fn parse(input: ParseStream<'_>) -> Result { - let lit: LitStr = input.parse()?; - Ok(Value::String(lit)) + let expr: Expr = input.parse()?; + match &expr { + Expr::Lit(expr) => { + if let Lit::Str(lit) = &expr.lit { + return Ok(Value::String(lit.clone())); + } + } + Expr::Macro(expr) => { + if expr.mac.path.is_ident("env") && let Ok(lit) = expr.mac.parse_body() { + return Ok(Value::Env(lit)); + } + } + _ => {} + } + Err(syn::Error::new_spanned( + expr, + concat!( + "unsupported expression for symbol value; implement support for this in ", + file!(), + ), + )) } } @@ -198,12 +218,14 @@ fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec) { // Generate the listed symbols. for symbol in input.symbols.iter() { let name = &symbol.name; + check_order(symbol.name.span(), &name.to_string(), &mut errors); + let value = match &symbol.value { Value::SameAsName => name.to_string(), Value::String(lit) => lit.value(), + Value::Env(_) => continue, }; let idx = entries.insert(symbol.name.span(), &value, &mut errors); - check_order(symbol.name.span(), &name.to_string(), &mut errors); prefill_stream.extend(quote! { #value, @@ -222,6 +244,37 @@ fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec) { }); } + // Symbols whose value comes from an environment variable. It's allowed for + // these to have the same value as another symbol. + for symbol in &input.symbols { + let env_var = match &symbol.value { + Value::Env(lit) => lit, + _ => continue, + }; + + let value = match proc_macro::tracked_env::var(env_var.value()) { + Ok(value) => value, + Err(err) => { + errors.error(symbol.name.span(), err.to_string()); + continue; + } + }; + + let idx = if let Some(prev) = entries.map.get(&value) { + prev.idx + } else { + prefill_stream.extend(quote! { + #value, + }); + entries.insert(symbol.name.span(), &value, &mut errors) + }; + + let name = &symbol.name; + symbols_stream.extend(quote! { + pub const #name: Symbol = Symbol::new(#idx); + }); + } + let symbol_digits_base = entries.map["0"].idx; let preinterned_symbols_count = entries.len(); let output = quote! { From 1078250f483ded63e4526ff379813ab367e2a6c7 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Wed, 25 Oct 2023 13:46:59 -0700 Subject: [PATCH 07/10] Continue generating other symbols if an expr is not supported --- compiler/rustc_macros/src/symbols.rs | 23 ++++++++++++++--------- 1 file changed, 14 insertions(+), 9 deletions(-) diff --git a/compiler/rustc_macros/src/symbols.rs b/compiler/rustc_macros/src/symbols.rs index fd2d56eb29c67..b808b858357fa 100644 --- a/compiler/rustc_macros/src/symbols.rs +++ b/compiler/rustc_macros/src/symbols.rs @@ -60,6 +60,7 @@ enum Value { SameAsName, String(LitStr), Env(LitStr), + Unsupported(Expr), } impl Parse for Symbol { @@ -88,13 +89,7 @@ impl Parse for Value { } _ => {} } - Err(syn::Error::new_spanned( - expr, - concat!( - "unsupported expression for symbol value; implement support for this in ", - file!(), - ), - )) + Ok(Value::Unsupported(expr)) } } @@ -223,7 +218,17 @@ fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec) { let value = match &symbol.value { Value::SameAsName => name.to_string(), Value::String(lit) => lit.value(), - Value::Env(_) => continue, + Value::Env(_) => continue, // in another loop below + Value::Unsupported(expr) => { + errors.list.push(syn::Error::new_spanned( + expr, + concat!( + "unsupported expression for symbol value; implement support for this in ", + file!(), + ), + )); + continue; + } }; let idx = entries.insert(symbol.name.span(), &value, &mut errors); @@ -249,7 +254,7 @@ fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec) { for symbol in &input.symbols { let env_var = match &symbol.value { Value::Env(lit) => lit, - _ => continue, + Value::SameAsName | Value::String(_) | Value::Unsupported(_) => continue, }; let value = match proc_macro::tracked_env::var(env_var.value()) { From 5563a9ba3d0e7759772c553481896cb803624e79 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Wed, 25 Oct 2023 13:52:38 -0700 Subject: [PATCH 08/10] Improve span of env-related errors --- compiler/rustc_macros/src/symbols.rs | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/compiler/rustc_macros/src/symbols.rs b/compiler/rustc_macros/src/symbols.rs index b808b858357fa..e63bb06eb3f4e 100644 --- a/compiler/rustc_macros/src/symbols.rs +++ b/compiler/rustc_macros/src/symbols.rs @@ -26,7 +26,7 @@ use proc_macro2::{Span, TokenStream}; use quote::quote; use std::collections::HashMap; use syn::parse::{Parse, ParseStream, Result}; -use syn::{braced, punctuated::Punctuated, Expr, Ident, Lit, LitStr, Token}; +use syn::{braced, punctuated::Punctuated, Expr, Ident, Lit, LitStr, Macro, Token}; #[cfg(test)] mod tests; @@ -59,7 +59,7 @@ struct Symbol { enum Value { SameAsName, String(LitStr), - Env(LitStr), + Env(LitStr, Macro), Unsupported(Expr), } @@ -84,7 +84,7 @@ impl Parse for Value { } Expr::Macro(expr) => { if expr.mac.path.is_ident("env") && let Ok(lit) = expr.mac.parse_body() { - return Ok(Value::Env(lit)); + return Ok(Value::Env(lit, expr.mac.clone())); } } _ => {} @@ -218,7 +218,7 @@ fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec) { let value = match &symbol.value { Value::SameAsName => name.to_string(), Value::String(lit) => lit.value(), - Value::Env(_) => continue, // in another loop below + Value::Env(..) => continue, // in another loop below Value::Unsupported(expr) => { errors.list.push(syn::Error::new_spanned( expr, @@ -252,15 +252,15 @@ fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec) { // Symbols whose value comes from an environment variable. It's allowed for // these to have the same value as another symbol. for symbol in &input.symbols { - let env_var = match &symbol.value { - Value::Env(lit) => lit, + let (env_var, expr) = match &symbol.value { + Value::Env(lit, expr) => (lit, expr), Value::SameAsName | Value::String(_) | Value::Unsupported(_) => continue, }; let value = match proc_macro::tracked_env::var(env_var.value()) { Ok(value) => value, Err(err) => { - errors.error(symbol.name.span(), err.to_string()); + errors.list.push(syn::Error::new_spanned(expr, err)); continue; } }; From ac4fa3f2456c0f131982c871d2dffcb7b33daf92 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Wed, 25 Oct 2023 14:05:42 -0700 Subject: [PATCH 09/10] Pre-intern a symbol for env!("CFG_RELEASE") --- compiler/rustc_attr/src/builtin.rs | 4 ---- compiler/rustc_passes/src/lib_features.rs | 4 ++-- compiler/rustc_passes/src/stability.rs | 6 +++--- compiler/rustc_span/src/symbol.rs | 1 + 4 files changed, 6 insertions(+), 9 deletions(-) diff --git a/compiler/rustc_attr/src/builtin.rs b/compiler/rustc_attr/src/builtin.rs index bd85483885e36..363ba0d4a815b 100644 --- a/compiler/rustc_attr/src/builtin.rs +++ b/compiler/rustc_attr/src/builtin.rs @@ -26,10 +26,6 @@ pub const VERSION_PLACEHOLDER: &str = "CURRENT_RUSTC_VERSION"; pub const CURRENT_RUSTC_VERSION: &str = env!("CFG_RELEASE"); -pub fn rust_version_symbol() -> Symbol { - Symbol::intern(CURRENT_RUSTC_VERSION) -} - pub fn is_builtin_attr(attr: &Attribute) -> bool { attr.is_doc_comment() || attr.ident().is_some_and(|ident| is_builtin_attr_name(ident.name)) } diff --git a/compiler/rustc_passes/src/lib_features.rs b/compiler/rustc_passes/src/lib_features.rs index ceb8f58cac0c2..0daa273db6761 100644 --- a/compiler/rustc_passes/src/lib_features.rs +++ b/compiler/rustc_passes/src/lib_features.rs @@ -5,7 +5,7 @@ //! collect them instead. use rustc_ast::Attribute; -use rustc_attr::{rust_version_symbol, VERSION_PLACEHOLDER}; +use rustc_attr::VERSION_PLACEHOLDER; use rustc_hir::intravisit::Visitor; use rustc_middle::hir::nested_filter; use rustc_middle::middle::lib_features::LibFeatures; @@ -59,7 +59,7 @@ impl<'tcx> LibFeatureCollector<'tcx> { if let Some(s) = since && s.as_str() == VERSION_PLACEHOLDER { - since = Some(rust_version_symbol()); + since = Some(sym::env_CFG_RELEASE); } if let Some(feature) = feature { diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs index 41a240fa880d3..7bfb0742b8be9 100644 --- a/compiler/rustc_passes/src/stability.rs +++ b/compiler/rustc_passes/src/stability.rs @@ -3,8 +3,8 @@ use crate::errors; use rustc_attr::{ - self as attr, rust_version_symbol, ConstStability, Since, Stability, StabilityLevel, Unstable, - UnstableReason, VERSION_PLACEHOLDER, + self as attr, ConstStability, Since, Stability, StabilityLevel, Unstable, UnstableReason, + VERSION_PLACEHOLDER, }; use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap}; use rustc_hir as hir; @@ -1115,7 +1115,7 @@ fn unnecessary_stable_feature_lint( mut since: Symbol, ) { if since.as_str() == VERSION_PLACEHOLDER { - since = rust_version_symbol(); + since = sym::env_CFG_RELEASE; } tcx.emit_spanned_lint( lint::builtin::STABLE_FEATURES, diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs index ff61143a12ba2..88d9dab2ba560 100644 --- a/compiler/rustc_span/src/symbol.rs +++ b/compiler/rustc_span/src/symbol.rs @@ -713,6 +713,7 @@ symbols! { encode, end, env, + env_CFG_RELEASE: env!("CFG_RELEASE"), eprint_macro, eprintln_macro, eq, From c1552dfddd7a98f37e3269002a5624409d8f3481 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Wed, 25 Oct 2023 14:45:31 -0700 Subject: [PATCH 10/10] Fix symbols::tests::test_symbols ---- symbols::tests::test_symbols stdout ---- thread 'symbols::tests::test_symbols' panicked at library/proc_macro/src/bridge/client.rs:311:17: procedural macro API is used outside of a procedural macro --- compiler/rustc_macros/src/symbols.rs | 8 ++++++++ compiler/rustc_macros/src/symbols/tests.rs | 2 +- 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/compiler/rustc_macros/src/symbols.rs b/compiler/rustc_macros/src/symbols.rs index e63bb06eb3f4e..4129712a6b218 100644 --- a/compiler/rustc_macros/src/symbols.rs +++ b/compiler/rustc_macros/src/symbols.rs @@ -257,6 +257,14 @@ fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec) { Value::SameAsName | Value::String(_) | Value::Unsupported(_) => continue, }; + if !proc_macro::is_available() { + errors.error( + Span::call_site(), + "proc_macro::tracked_env is not available in unit test".to_owned(), + ); + break; + } + let value = match proc_macro::tracked_env::var(env_var.value()) { Ok(value) => value, Err(err) => { diff --git a/compiler/rustc_macros/src/symbols/tests.rs b/compiler/rustc_macros/src/symbols/tests.rs index bd0c08a53c4f2..9c53453df5b54 100644 --- a/compiler/rustc_macros/src/symbols/tests.rs +++ b/compiler/rustc_macros/src/symbols/tests.rs @@ -27,7 +27,7 @@ fn test_symbols() { let body_tokens = m.mac.tokens.clone(); - test_symbols_macro(body_tokens, &[]); + test_symbols_macro(body_tokens, &["proc_macro::tracked_env is not available in unit test"]); } fn test_symbols_macro(input: TokenStream, expected_errors: &[&str]) {