From 26451ef7b5e00887dc8f27717ff34262df23d655 Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Wed, 22 May 2019 12:42:23 +1000 Subject: [PATCH] Avoid unnecessary internings. Most involving `Symbol::intern` on string literals. --- src/librustc/hir/lowering.rs | 8 ++------ src/librustc/middle/lang_items.rs | 4 ++-- src/librustc/middle/stability.rs | 4 ++-- src/librustc/session/config.rs | 19 +++++++++---------- src/librustc_allocator/expand.rs | 6 ++---- src/librustc_interface/util.rs | 2 +- src/librustc_metadata/cstore_impl.rs | 4 +--- src/librustc_typeck/check/mod.rs | 2 +- src/libsyntax/ext/derive.rs | 7 ++----- src/libsyntax/ext/expand.rs | 2 +- src/libsyntax/ext/tt/macro_rules.rs | 2 +- src/libsyntax/parse/parser.rs | 2 +- src/libsyntax/std_inject.rs | 6 ++---- src/libsyntax/test.rs | 12 ++++-------- src/libsyntax_ext/asm.rs | 4 ++-- src/libsyntax_ext/assert.rs | 4 ++-- src/libsyntax_ext/deriving/clone.rs | 4 ++-- src/libsyntax_ext/deriving/cmp/eq.rs | 8 ++++---- src/libsyntax_ext/deriving/cmp/ord.rs | 4 ++-- src/libsyntax_ext/deriving/cmp/partial_eq.rs | 4 ++-- src/libsyntax_ext/deriving/cmp/partial_ord.rs | 6 +++--- src/libsyntax_ext/deriving/debug.rs | 5 +++-- src/libsyntax_ext/deriving/default.rs | 4 ++-- src/libsyntax_ext/deriving/generic/mod.rs | 5 ++--- src/libsyntax_ext/deriving/mod.rs | 2 +- src/libsyntax_ext/lib.rs | 18 +++++++----------- src/libsyntax_ext/proc_macro_decls.rs | 6 +++--- src/libsyntax_ext/proc_macro_server.rs | 4 ++-- src/libsyntax_ext/test.rs | 15 ++++++--------- src/libsyntax_ext/test_case.rs | 11 ++++------- src/libsyntax_pos/symbol.rs | 6 ++++++ 31 files changed, 84 insertions(+), 106 deletions(-) diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index 3d83918bd0a..daf47618164 100644 --- a/src/librustc/hir/lowering.rs +++ b/src/librustc/hir/lowering.rs @@ -1145,9 +1145,7 @@ impl<'a> LoweringContext<'a> { let unstable_span = self.sess.source_map().mark_span_with_reason( CompilerDesugaringKind::Async, span, - Some(vec![ - Symbol::intern("gen_future"), - ].into()), + Some(vec![sym::gen_future].into()), ); let gen_future = self.expr_std_path( unstable_span, &[sym::future, sym::from_generator], None, ThinVec::new()); @@ -4177,9 +4175,7 @@ impl<'a> LoweringContext<'a> { let unstable_span = this.sess.source_map().mark_span_with_reason( CompilerDesugaringKind::TryBlock, body.span, - Some(vec![ - Symbol::intern("try_trait"), - ].into()), + Some(vec![sym::try_trait].into()), ); let mut block = this.lower_block(body, true).into_inner(); let tail = block.expr.take().map_or_else( diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs index 103580a598f..034ef32aafe 100644 --- a/src/librustc/middle/lang_items.rs +++ b/src/librustc/middle/lang_items.rs @@ -210,8 +210,8 @@ impl<'a, 'tcx> LanguageItemCollector<'a, 'tcx> { pub fn extract(attrs: &[ast::Attribute]) -> Option<(Symbol, Span)> { attrs.iter().find_map(|attr| Some(match attr { _ if attr.check_name(sym::lang) => (attr.value_str()?, attr.span), - _ if attr.check_name(sym::panic_handler) => (Symbol::intern("panic_impl"), attr.span), - _ if attr.check_name(sym::alloc_error_handler) => (Symbol::intern("oom"), attr.span), + _ if attr.check_name(sym::panic_handler) => (sym::panic_impl, attr.span), + _ if attr.check_name(sym::alloc_error_handler) => (sym::oom, attr.span), _ => return None, })) } diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs index ac0e99137cb..66fa9a5c6f1 100644 --- a/src/librustc/middle/stability.rs +++ b/src/librustc/middle/stability.rs @@ -437,7 +437,7 @@ impl<'a, 'tcx> Index<'tcx> { reason: Some(Symbol::intern(reason)), issue: 27812, }, - feature: Symbol::intern("rustc_private"), + feature: sym::rustc_private, rustc_depr: None, const_stability: None, promotable: false, @@ -880,7 +880,7 @@ pub fn check_unused_or_stable_features<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) { // FIXME: only remove `libc` when `stdbuild` is active. // FIXME: remove special casing for `test`. remaining_lib_features.remove(&Symbol::intern("libc")); - remaining_lib_features.remove(&Symbol::intern("test")); + remaining_lib_features.remove(&sym::test); let check_features = |remaining_lib_features: &mut FxHashMap<_, _>, defined_features: &[_]| { diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index f16137bd2c2..49cd3eff21a 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -19,7 +19,7 @@ use syntax::source_map::{FileName, FilePathMapping}; use syntax::edition::{Edition, EDITION_NAME_LIST, DEFAULT_EDITION}; use syntax::parse::token; use syntax::parse; -use syntax::symbol::Symbol; +use syntax::symbol::{sym, Symbol}; use syntax::feature_gate::UnstableFeatures; use errors::emitter::HumanReadableErrorType; @@ -1503,31 +1503,31 @@ pub fn default_configuration(sess: &Session) -> ast::CrateConfig { Some(Symbol::intern(vendor)), )); if sess.target.target.options.has_elf_tls { - ret.insert((Symbol::intern("target_thread_local"), None)); + ret.insert((sym::target_thread_local, None)); } for &i in &[8, 16, 32, 64, 128] { if i >= min_atomic_width && i <= max_atomic_width { let s = i.to_string(); ret.insert(( - Symbol::intern("target_has_atomic"), + sym::target_has_atomic, Some(Symbol::intern(&s)), )); if &s == wordsz { ret.insert(( - Symbol::intern("target_has_atomic"), + sym::target_has_atomic, Some(Symbol::intern("ptr")), )); } } } if atomic_cas { - ret.insert((Symbol::intern("target_has_atomic"), Some(Symbol::intern("cas")))); + ret.insert((sym::target_has_atomic, Some(Symbol::intern("cas")))); } if sess.opts.debug_assertions { ret.insert((Symbol::intern("debug_assertions"), None)); } if sess.opts.crate_types.contains(&CrateType::ProcMacro) { - ret.insert((Symbol::intern("proc_macro"), None)); + ret.insert((sym::proc_macro, None)); } ret } @@ -1547,7 +1547,7 @@ pub fn build_configuration(sess: &Session, mut user_cfg: ast::CrateConfig) -> as let default_cfg = default_configuration(sess); // If the user wants a test runner, then add the test cfg if sess.opts.test { - user_cfg.insert((Symbol::intern("test"), None)); + user_cfg.insert((sym::test, None)); } user_cfg.extend(default_cfg.iter().cloned()); user_cfg @@ -2702,7 +2702,7 @@ mod tests { use std::path::PathBuf; use super::{Externs, OutputType, OutputTypes}; use rustc_target::spec::{MergeFunctions, PanicStrategy, RelroLevel}; - use syntax::symbol::Symbol; + use syntax::symbol::sym; use syntax::edition::{Edition, DEFAULT_EDITION}; use syntax; use super::Options; @@ -2744,7 +2744,7 @@ mod tests { let (sessopts, cfg) = build_session_options_and_crate_config(matches); let sess = build_session(sessopts, None, registry); let cfg = build_configuration(&sess, to_crate_config(cfg)); - assert!(cfg.contains(&(Symbol::intern("test"), None))); + assert!(cfg.contains(&(sym::test, None))); }); } @@ -2752,7 +2752,6 @@ mod tests { // another --cfg test #[test] fn test_switch_implies_cfg_test_unless_cfg_test() { - use syntax::symbol::sym; syntax::with_default_globals(|| { let matches = &match optgroups().parse(&["--test".to_string(), "--cfg=test".to_string()]) { diff --git a/src/librustc_allocator/expand.rs b/src/librustc_allocator/expand.rs index b9cd30694f6..3ec06b17aff 100644 --- a/src/librustc_allocator/expand.rs +++ b/src/librustc_allocator/expand.rs @@ -91,9 +91,7 @@ impl MutVisitor for ExpandAllocatorDirectives<'_> { call_site: item.span, // use the call site of the static def_site: None, format: MacroAttribute(Symbol::intern(name)), - allow_internal_unstable: Some(vec![ - Symbol::intern("rustc_attrs"), - ].into()), + allow_internal_unstable: Some(vec![sym::rustc_attrs].into()), allow_internal_unsafe: false, local_inner_macros: false, edition: self.sess.edition, @@ -223,7 +221,7 @@ impl AllocFnFactory<'_> { } fn attrs(&self) -> Vec { - let special = Symbol::intern("rustc_std_internal_symbol"); + let special = sym::rustc_std_internal_symbol; let special = self.cx.meta_word(self.span, special); vec![self.cx.attribute(self.span, special)] } diff --git a/src/librustc_interface/util.rs b/src/librustc_interface/util.rs index 09bb547191f..4ff996d1f57 100644 --- a/src/librustc_interface/util.rs +++ b/src/librustc_interface/util.rs @@ -68,7 +68,7 @@ pub fn add_configuration( sess: &Session, codegen_backend: &dyn CodegenBackend, ) { - let tf = Symbol::intern("target_feature"); + let tf = sym::target_feature; cfg.extend( codegen_backend diff --git a/src/librustc_metadata/cstore_impl.rs b/src/librustc_metadata/cstore_impl.rs index fae4c244d6e..c2c40ea79e8 100644 --- a/src/librustc_metadata/cstore_impl.rs +++ b/src/librustc_metadata/cstore_impl.rs @@ -431,9 +431,7 @@ impl cstore::CStore { let client = proc_macro::bridge::client::Client::expand1(proc_macro::quote); let ext = SyntaxExtension::ProcMacro { expander: Box::new(BangProcMacro { client }), - allow_internal_unstable: Some(vec![ - Symbol::intern("proc_macro_def_site"), - ].into()), + allow_internal_unstable: Some(vec![sym::proc_macro_def_site].into()), edition: data.root.edition, }; return LoadedMacro::ProcMacro(Lrc::new(ext)); diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 61fc856764c..bfe30488f9c 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -4944,7 +4944,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { // This is less than ideal, it will not suggest a return type span on any // method called `main`, regardless of whether it is actually the entry point, // but it will still present it as the reason for the expected type. - Some((decl, ident, ident.name != Symbol::intern("main"))) + Some((decl, ident, ident.name != sym::main)) }), Node::TraitItem(&hir::TraitItem { ident, node: hir::TraitItemKind::Method(hir::MethodSig { diff --git a/src/libsyntax/ext/derive.rs b/src/libsyntax/ext/derive.rs index 6e789c4c708..c47224ca0ce 100644 --- a/src/libsyntax/ext/derive.rs +++ b/src/libsyntax/ext/derive.rs @@ -58,10 +58,7 @@ pub fn add_derived_markers(cx: &mut ExtCtxt<'_>, span: Span, traits: &[ast::P call_site: span, def_site: None, format: ExpnFormat::MacroAttribute(Symbol::intern(&pretty_name)), - allow_internal_unstable: Some(vec![ - Symbol::intern("rustc_attrs"), - Symbol::intern("structural_match"), - ].into()), + allow_internal_unstable: Some(vec![sym::rustc_attrs, sym::structural_match].into()), allow_internal_unsafe: false, local_inner_macros: false, edition: cx.parse_sess.edition, @@ -74,7 +71,7 @@ pub fn add_derived_markers(cx: &mut ExtCtxt<'_>, span: Span, traits: &[ast::P attrs.push(cx.attribute(span, meta)); } if names.contains(&Symbol::intern("Copy")) { - let meta = cx.meta_word(span, Symbol::intern("rustc_copy_clone_marker")); + let meta = cx.meta_word(span, sym::rustc_copy_clone_marker); attrs.push(cx.attribute(span, meta)); } }); diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index fbe052252a1..c2a73b662c6 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -938,7 +938,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> { } BuiltinDerive(func) => { expn_info.allow_internal_unstable = Some(vec![ - Symbol::intern("rustc_attrs"), + sym::rustc_attrs, Symbol::intern("derive_clone_copy"), Symbol::intern("derive_eq"), Symbol::intern("libstd_sys_internals"), // RustcDeserialize and RustcSerialize diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs index 2debd8f048b..285c88357a6 100644 --- a/src/libsyntax/ext/tt/macro_rules.rs +++ b/src/libsyntax/ext/tt/macro_rules.rs @@ -396,7 +396,7 @@ pub fn compile( future this will become a hard error. Please use `allow_internal_unstable(\ foo, bar)` to only allow the `foo` and `bar` features", ); - vec![Symbol::intern("allow_internal_unstable_backcompat_hack")].into() + vec![sym::allow_internal_unstable_backcompat_hack].into() }) ); let allow_internal_unsafe = attr::contains_name(&def.attrs, sym::allow_internal_unsafe); diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 6c29437362c..e0430ac5563 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -5787,7 +5787,7 @@ impl<'a> Parser<'a> { VisibilityKind::Inherited => {} _ => { let is_macro_rules: bool = match self.token { - token::Ident(sid, _) => sid.name == Symbol::intern("macro_rules"), + token::Ident(sid, _) => sid.name == sym::macro_rules, _ => false, }; let mut err = if is_macro_rules { diff --git a/src/libsyntax/std_inject.rs b/src/libsyntax/std_inject.rs index 398705857bb..eea94f0d194 100644 --- a/src/libsyntax/std_inject.rs +++ b/src/libsyntax/std_inject.rs @@ -20,9 +20,7 @@ fn ignored_span(sp: Span, edition: Edition) -> Span { call_site: DUMMY_SP, def_site: None, format: MacroAttribute(Symbol::intern("std_inject")), - allow_internal_unstable: Some(vec![ - Symbol::intern("prelude_import"), - ].into()), + allow_internal_unstable: Some(vec![sym::prelude_import].into()), allow_internal_unsafe: false, local_inner_macros: false, edition, @@ -98,7 +96,7 @@ pub fn maybe_inject_crates_ref( krate.module.items.insert(0, P(ast::Item { attrs: vec![ast::Attribute { style: ast::AttrStyle::Outer, - path: ast::Path::from_ident(ast::Ident::new(Symbol::intern("prelude_import"), span)), + path: ast::Path::from_ident(ast::Ident::new(sym::prelude_import, span)), tokens: TokenStream::empty(), id: attr::mk_attr_id(), is_sugared_doc: false, diff --git a/src/libsyntax/test.rs b/src/libsyntax/test.rs index d1e11da4e7c..1998ec19f13 100644 --- a/src/libsyntax/test.rs +++ b/src/libsyntax/test.rs @@ -283,12 +283,8 @@ fn generate_test_harness(sess: &ParseSess, mark.set_expn_info(ExpnInfo { call_site: DUMMY_SP, def_site: None, - format: MacroAttribute(Symbol::intern("test_case")), - allow_internal_unstable: Some(vec![ - Symbol::intern("main"), - Symbol::intern("test"), - Symbol::intern("rustc_attrs"), - ].into()), + format: MacroAttribute(sym::test_case), + allow_internal_unstable: Some(vec![sym::main, sym::test, sym::rustc_attrs].into()), allow_internal_unsafe: false, local_inner_macros: false, edition: sess.edition, @@ -347,14 +343,14 @@ fn mk_main(cx: &mut TestCtxt<'_>) -> P { let call_test_main = ecx.stmt_expr(call_test_main); // #![main] - let main_meta = ecx.meta_word(sp, Symbol::intern("main")); + let main_meta = ecx.meta_word(sp, sym::main); let main_attr = ecx.attribute(sp, main_meta); // extern crate test as test_gensym let test_extern_stmt = ecx.stmt_item(sp, ecx.item(sp, test_id, vec![], - ast::ItemKind::ExternCrate(Some(Symbol::intern("test"))) + ast::ItemKind::ExternCrate(Some(sym::test)) )); // pub fn main() { ... } diff --git a/src/libsyntax_ext/asm.rs b/src/libsyntax_ext/asm.rs index 704665e0a84..4d7083c1a79 100644 --- a/src/libsyntax_ext/asm.rs +++ b/src/libsyntax_ext/asm.rs @@ -11,7 +11,7 @@ use syntax::ext::base::{self, *}; use syntax::feature_gate; use syntax::parse::{self, token}; use syntax::ptr::P; -use syntax::symbol::{Symbol, sym}; +use syntax::symbol::{kw, sym, Symbol}; use syntax::ast::AsmDialect; use syntax_pos::Span; use syntax::tokenstream; @@ -93,7 +93,7 @@ fn parse_inline_asm<'a>( }) .unwrap_or(tts.len()); let mut p = cx.new_parser_from_tts(&tts[first_colon..]); - let mut asm = Symbol::intern(""); + let mut asm = kw::Invalid; let mut asm_str_style = None; let mut outputs = Vec::new(); let mut inputs = Vec::new(); diff --git a/src/libsyntax_ext/assert.rs b/src/libsyntax_ext/assert.rs index a11cd9c6f76..13342c8e28e 100644 --- a/src/libsyntax_ext/assert.rs +++ b/src/libsyntax_ext/assert.rs @@ -8,7 +8,7 @@ use syntax::parse::token::{self, Token}; use syntax::parse::parser::Parser; use syntax::print::pprust; use syntax::ptr::P; -use syntax::symbol::Symbol; +use syntax::symbol::{sym, Symbol}; use syntax::tokenstream::{TokenStream, TokenTree}; use syntax_pos::{Span, DUMMY_SP}; @@ -27,7 +27,7 @@ pub fn expand_assert<'cx>( let sp = sp.apply_mark(cx.current_expansion.mark); let panic_call = Mac_ { - path: Path::from_ident(Ident::new(Symbol::intern("panic"), sp)), + path: Path::from_ident(Ident::new(sym::panic, sp)), tts: custom_message.unwrap_or_else(|| { TokenStream::from(TokenTree::Token( DUMMY_SP, diff --git a/src/libsyntax_ext/deriving/clone.rs b/src/libsyntax_ext/deriving/clone.rs index a39e0a6e973..417dd2525d6 100644 --- a/src/libsyntax_ext/deriving/clone.rs +++ b/src/libsyntax_ext/deriving/clone.rs @@ -7,7 +7,7 @@ use syntax::attr; use syntax::ext::base::{Annotatable, ExtCtxt}; use syntax::ext::build::AstBuilder; use syntax::ptr::P; -use syntax::symbol::{Symbol, kw, sym}; +use syntax::symbol::{kw, sym}; use syntax_pos::Span; pub fn expand_deriving_clone(cx: &mut ExtCtxt<'_>, @@ -76,7 +76,7 @@ pub fn expand_deriving_clone(cx: &mut ExtCtxt<'_>, _ => cx.span_bug(span, "#[derive(Clone)] on trait item or impl item"), } - let inline = cx.meta_word(span, Symbol::intern("inline")); + let inline = cx.meta_word(span, sym::inline); let attrs = vec![cx.attribute(span, inline)]; let trait_def = TraitDef { span, diff --git a/src/libsyntax_ext/deriving/cmp/eq.rs b/src/libsyntax_ext/deriving/cmp/eq.rs index a1035ff641f..e7d7f136e18 100644 --- a/src/libsyntax_ext/deriving/cmp/eq.rs +++ b/src/libsyntax_ext/deriving/cmp/eq.rs @@ -6,7 +6,7 @@ use syntax::ast::{self, Expr, MetaItem, GenericArg}; use syntax::ext::base::{Annotatable, ExtCtxt}; use syntax::ext::build::AstBuilder; use syntax::ptr::P; -use syntax::symbol::Symbol; +use syntax::symbol::sym; use syntax_pos::Span; pub fn expand_deriving_eq(cx: &mut ExtCtxt<'_>, @@ -14,9 +14,9 @@ pub fn expand_deriving_eq(cx: &mut ExtCtxt<'_>, mitem: &MetaItem, item: &Annotatable, push: &mut dyn FnMut(Annotatable)) { - let inline = cx.meta_word(span, Symbol::intern("inline")); - let hidden = cx.meta_list_item_word(span, Symbol::intern("hidden")); - let doc = cx.meta_list(span, Symbol::intern("doc"), vec![hidden]); + let inline = cx.meta_word(span, sym::inline); + let hidden = cx.meta_list_item_word(span, sym::hidden); + let doc = cx.meta_list(span, sym::doc, vec![hidden]); let attrs = vec![cx.attribute(span, inline), cx.attribute(span, doc)]; let trait_def = TraitDef { span, diff --git a/src/libsyntax_ext/deriving/cmp/ord.rs b/src/libsyntax_ext/deriving/cmp/ord.rs index e4f939c151f..282cfa5a4bf 100644 --- a/src/libsyntax_ext/deriving/cmp/ord.rs +++ b/src/libsyntax_ext/deriving/cmp/ord.rs @@ -6,7 +6,7 @@ use syntax::ast::{self, Expr, MetaItem}; use syntax::ext::base::{Annotatable, ExtCtxt}; use syntax::ext::build::AstBuilder; use syntax::ptr::P; -use syntax::symbol::Symbol; +use syntax::symbol::sym; use syntax_pos::Span; pub fn expand_deriving_ord(cx: &mut ExtCtxt<'_>, @@ -14,7 +14,7 @@ pub fn expand_deriving_ord(cx: &mut ExtCtxt<'_>, mitem: &MetaItem, item: &Annotatable, push: &mut dyn FnMut(Annotatable)) { - let inline = cx.meta_word(span, Symbol::intern("inline")); + let inline = cx.meta_word(span, sym::inline); let attrs = vec![cx.attribute(span, inline)]; let trait_def = TraitDef { span, diff --git a/src/libsyntax_ext/deriving/cmp/partial_eq.rs b/src/libsyntax_ext/deriving/cmp/partial_eq.rs index 07026ae3739..6172f27261e 100644 --- a/src/libsyntax_ext/deriving/cmp/partial_eq.rs +++ b/src/libsyntax_ext/deriving/cmp/partial_eq.rs @@ -6,7 +6,7 @@ use syntax::ast::{BinOpKind, Expr, MetaItem}; use syntax::ext::base::{Annotatable, ExtCtxt}; use syntax::ext::build::AstBuilder; use syntax::ptr::P; -use syntax::symbol::Symbol; +use syntax::symbol::sym; use syntax_pos::Span; pub fn expand_deriving_partial_eq(cx: &mut ExtCtxt<'_>, @@ -62,7 +62,7 @@ pub fn expand_deriving_partial_eq(cx: &mut ExtCtxt<'_>, macro_rules! md { ($name:expr, $f:ident) => { { - let inline = cx.meta_word(span, Symbol::intern("inline")); + let inline = cx.meta_word(span, sym::inline); let attrs = vec![cx.attribute(span, inline)]; MethodDef { name: $name, diff --git a/src/libsyntax_ext/deriving/cmp/partial_ord.rs b/src/libsyntax_ext/deriving/cmp/partial_ord.rs index e99abeb118e..abfa79c2b4d 100644 --- a/src/libsyntax_ext/deriving/cmp/partial_ord.rs +++ b/src/libsyntax_ext/deriving/cmp/partial_ord.rs @@ -8,7 +8,7 @@ use syntax::ast::{self, BinOpKind, Expr, MetaItem}; use syntax::ext::base::{Annotatable, ExtCtxt}; use syntax::ext::build::AstBuilder; use syntax::ptr::P; -use syntax::symbol::Symbol; +use syntax::symbol::sym; use syntax_pos::Span; pub fn expand_deriving_partial_ord(cx: &mut ExtCtxt<'_>, @@ -18,7 +18,7 @@ pub fn expand_deriving_partial_ord(cx: &mut ExtCtxt<'_>, push: &mut dyn FnMut(Annotatable)) { macro_rules! md { ($name:expr, $op:expr, $equal:expr) => { { - let inline = cx.meta_word(span, Symbol::intern("inline")); + let inline = cx.meta_word(span, sym::inline); let attrs = vec![cx.attribute(span, inline)]; MethodDef { name: $name, @@ -42,7 +42,7 @@ pub fn expand_deriving_partial_ord(cx: &mut ExtCtxt<'_>, vec![Box::new(ordering_ty)], PathKind::Std)); - let inline = cx.meta_word(span, Symbol::intern("inline")); + let inline = cx.meta_word(span, sym::inline); let attrs = vec![cx.attribute(span, inline)]; let partial_cmp_def = MethodDef { diff --git a/src/libsyntax_ext/deriving/debug.rs b/src/libsyntax_ext/deriving/debug.rs index 2fc1fc9140d..dec4c2dfc3b 100644 --- a/src/libsyntax_ext/deriving/debug.rs +++ b/src/libsyntax_ext/deriving/debug.rs @@ -9,6 +9,7 @@ use syntax::ast::{Expr, MetaItem}; use syntax::ext::base::{Annotatable, ExtCtxt}; use syntax::ext::build::AstBuilder; use syntax::ptr::P; +use syntax::symbol::sym; use syntax_pos::{DUMMY_SP, Span}; pub fn expand_deriving_debug(cx: &mut ExtCtxt<'_>, @@ -82,7 +83,7 @@ fn show_substructure(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_> let expr = cx.expr_method_call(span, builder_expr.clone(), - Ident::from_str("field"), + Ident::with_empty_ctxt(sym::field), vec![field]); // Use `let _ = expr;` to avoid triggering the @@ -106,7 +107,7 @@ fn show_substructure(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_> let field = cx.expr_addr_of(field.span, field); let expr = cx.expr_method_call(span, builder_expr.clone(), - Ident::from_str("field"), + Ident::with_empty_ctxt(sym::field), vec![name, field]); stmts.push(stmt_let_undescore(cx, span, expr)); } diff --git a/src/libsyntax_ext/deriving/default.rs b/src/libsyntax_ext/deriving/default.rs index 6db0a29165a..b42dde16420 100644 --- a/src/libsyntax_ext/deriving/default.rs +++ b/src/libsyntax_ext/deriving/default.rs @@ -6,7 +6,7 @@ use syntax::ast::{Expr, MetaItem}; use syntax::ext::base::{Annotatable, DummyResult, ExtCtxt}; use syntax::ext::build::AstBuilder; use syntax::ptr::P; -use syntax::symbol::Symbol; +use syntax::symbol::sym; use syntax::span_err; use syntax_pos::Span; @@ -15,7 +15,7 @@ pub fn expand_deriving_default(cx: &mut ExtCtxt<'_>, mitem: &MetaItem, item: &Annotatable, push: &mut dyn FnMut(Annotatable)) { - let inline = cx.meta_word(span, Symbol::intern("inline")); + let inline = cx.meta_word(span, sym::inline); let attrs = vec![cx.attribute(span, inline)]; let trait_def = TraitDef { span, diff --git a/src/libsyntax_ext/deriving/generic/mod.rs b/src/libsyntax_ext/deriving/generic/mod.rs index 0689eb50f9c..7e3082a87d9 100644 --- a/src/libsyntax_ext/deriving/generic/mod.rs +++ b/src/libsyntax_ext/deriving/generic/mod.rs @@ -666,14 +666,13 @@ impl<'a> TraitDef<'a> { let self_type = cx.ty_path(path); let attr = cx.attribute(self.span, - cx.meta_word(self.span, - Symbol::intern("automatically_derived"))); + cx.meta_word(self.span, sym::automatically_derived)); // Just mark it now since we know that it'll end up used downstream attr::mark_used(&attr); let opt_trait_ref = Some(trait_ref); let unused_qual = { let word = cx.meta_list_item_word(self.span, Symbol::intern("unused_qualifications")); - cx.attribute(self.span, cx.meta_list(self.span, Symbol::intern("allow"), vec![word])) + cx.attribute(self.span, cx.meta_list(self.span, sym::allow, vec![word])) }; let mut a = vec![attr, unused_qual]; diff --git a/src/libsyntax_ext/deriving/mod.rs b/src/libsyntax_ext/deriving/mod.rs index c27de692d88..eff71bc969e 100644 --- a/src/libsyntax_ext/deriving/mod.rs +++ b/src/libsyntax_ext/deriving/mod.rs @@ -145,7 +145,7 @@ fn call_intrinsic(cx: &ExtCtxt<'_>, span = span.with_ctxt(cx.backtrace()); } else { // Avoid instability errors with user defined curstom derives, cc #36316 let mut info = cx.current_expansion.mark.expn_info().unwrap(); - info.allow_internal_unstable = Some(vec![Symbol::intern("core_intrinsics")].into()); + info.allow_internal_unstable = Some(vec![sym::core_intrinsics].into()); let mark = Mark::fresh(Mark::root()); mark.set_expn_info(info); span = span.with_ctxt(SyntaxContext::empty().apply_mark(mark)); diff --git a/src/libsyntax_ext/lib.rs b/src/libsyntax_ext/lib.rs index e5fc7aab61d..fc001544275 100644 --- a/src/libsyntax_ext/lib.rs +++ b/src/libsyntax_ext/lib.rs @@ -42,8 +42,8 @@ pub mod proc_macro_impl; use rustc_data_structures::sync::Lrc; use syntax::ast; use syntax::ext::base::{MacroExpanderFn, NormalTT, NamedSyntaxExtension, MultiModifier}; -use syntax::symbol::Symbol; use syntax::edition::Edition; +use syntax::symbol::{sym, Symbol}; pub fn register_builtins(resolver: &mut dyn syntax::ext::base::Resolver, user_exts: Vec, @@ -93,30 +93,26 @@ pub fn register_builtins(resolver: &mut dyn syntax::ext::base::Resolver, assert: assert::expand_assert, } - register(Symbol::intern("test_case"), MultiModifier(Box::new(test_case::expand))); - register(Symbol::intern("test"), MultiModifier(Box::new(test::expand_test))); - register(Symbol::intern("bench"), MultiModifier(Box::new(test::expand_bench))); + register(sym::test_case, MultiModifier(Box::new(test_case::expand))); + register(sym::test, MultiModifier(Box::new(test::expand_test))); + register(sym::bench, MultiModifier(Box::new(test::expand_bench))); // format_args uses `unstable` things internally. register(Symbol::intern("format_args"), NormalTT { expander: Box::new(format::expand_format_args), def_info: None, - allow_internal_unstable: Some(vec![ - Symbol::intern("fmt_internals"), - ].into()), + allow_internal_unstable: Some(vec![sym::fmt_internals].into()), allow_internal_unsafe: false, local_inner_macros: false, unstable_feature: None, edition, }); - register(Symbol::intern("format_args_nl"), + register(sym::format_args_nl, NormalTT { expander: Box::new(format::expand_format_args_nl), def_info: None, - allow_internal_unstable: Some(vec![ - Symbol::intern("fmt_internals"), - ].into()), + allow_internal_unstable: Some(vec![sym::fmt_internals].into()), allow_internal_unsafe: false, local_inner_macros: false, unstable_feature: None, diff --git a/src/libsyntax_ext/proc_macro_decls.rs b/src/libsyntax_ext/proc_macro_decls.rs index a485bb19808..5b8f4f35f2d 100644 --- a/src/libsyntax_ext/proc_macro_decls.rs +++ b/src/libsyntax_ext/proc_macro_decls.rs @@ -351,9 +351,9 @@ fn mk_decls( mark.set_expn_info(ExpnInfo { call_site: DUMMY_SP, def_site: None, - format: MacroAttribute(Symbol::intern("proc_macro")), + format: MacroAttribute(sym::proc_macro), allow_internal_unstable: Some(vec![ - Symbol::intern("rustc_attrs"), + sym::rustc_attrs, Symbol::intern("proc_macro_internals"), ].into()), allow_internal_unsafe: false, @@ -420,7 +420,7 @@ fn mk_decls( ast::Mutability::Immutable, cx.expr_vec_slice(span, decls), ).map(|mut i| { - let attr = cx.meta_word(span, Symbol::intern("rustc_proc_macro_decls")); + let attr = cx.meta_word(span, sym::rustc_proc_macro_decls); i.attrs.push(cx.attribute(span, attr)); i.vis = respan(span, ast::VisibilityKind::Public); i diff --git a/src/libsyntax_ext/proc_macro_server.rs b/src/libsyntax_ext/proc_macro_server.rs index beac92894b7..53730d2d080 100644 --- a/src/libsyntax_ext/proc_macro_server.rs +++ b/src/libsyntax_ext/proc_macro_server.rs @@ -14,7 +14,7 @@ use syntax::parse::lexer::comments; use syntax::parse::{self, token, ParseSess}; use syntax::tokenstream::{self, DelimSpan, IsJoint::*, TokenStream, TreeAndJoint}; use syntax_pos::hygiene::{SyntaxContext, Transparency}; -use syntax_pos::symbol::{kw, Symbol}; +use syntax_pos::symbol::{kw, sym, Symbol}; use syntax_pos::{BytePos, FileName, MultiSpan, Pos, SourceFile, Span}; trait FromInternal { @@ -159,7 +159,7 @@ impl FromInternal<(TreeAndJoint, &'_ ParseSess, &'_ mut Vec)> escaped.extend(ch.escape_debug()); } let stream = vec![ - Ident(ast::Ident::new(Symbol::intern("doc"), span), false), + Ident(ast::Ident::new(sym::doc, span), false), Eq, Token::lit(token::Str, Symbol::intern(&escaped), None), ] diff --git a/src/libsyntax_ext/test.rs b/src/libsyntax_ext/test.rs index 8ee61a3f67f..c20dc6cb2d7 100644 --- a/src/libsyntax_ext/test.rs +++ b/src/libsyntax_ext/test.rs @@ -65,11 +65,8 @@ pub fn expand_test_or_bench( mark.set_expn_info(ExpnInfo { call_site: DUMMY_SP, def_site: None, - format: MacroAttribute(Symbol::intern("test")), - allow_internal_unstable: Some(vec![ - Symbol::intern("rustc_attrs"), - Symbol::intern("test"), - ].into()), + format: MacroAttribute(sym::test), + allow_internal_unstable: Some(vec![sym::rustc_attrs, sym::test].into()), allow_internal_unsafe: false, local_inner_macros: false, edition: cx.parse_sess.edition, @@ -130,11 +127,11 @@ pub fn expand_test_or_bench( let mut test_const = cx.item(sp, ast::Ident::new(item.ident.name, sp).gensym(), vec![ // #[cfg(test)] - cx.attribute(attr_sp, cx.meta_list(attr_sp, Symbol::intern("cfg"), vec![ - cx.meta_list_item_word(attr_sp, Symbol::intern("test")) + cx.attribute(attr_sp, cx.meta_list(attr_sp, sym::cfg, vec![ + cx.meta_list_item_word(attr_sp, sym::test) ])), // #[rustc_test_marker] - cx.attribute(attr_sp, cx.meta_word(attr_sp, Symbol::intern("rustc_test_marker"))), + cx.attribute(attr_sp, cx.meta_word(attr_sp, sym::rustc_test_marker)), ], // const $ident: test::TestDescAndFn = ast::ItemKind::Const(cx.ty(sp, ast::TyKind::Path(None, test_path("TestDescAndFn"))), @@ -180,7 +177,7 @@ pub fn expand_test_or_bench( let test_extern = cx.item(sp, test_id, vec![], - ast::ItemKind::ExternCrate(Some(Symbol::intern("test"))) + ast::ItemKind::ExternCrate(Some(sym::test)) ); log::debug!("Synthetic test item:\n{}\n", pprust::item_to_string(&test_const)); diff --git a/src/libsyntax_ext/test_case.rs b/src/libsyntax_ext/test_case.rs index 5b1ae167ce3..cffecdd0f18 100644 --- a/src/libsyntax_ext/test_case.rs +++ b/src/libsyntax_ext/test_case.rs @@ -14,7 +14,7 @@ use syntax::ext::build::AstBuilder; use syntax::ext::hygiene::{Mark, SyntaxContext}; use syntax::ast; use syntax::source_map::respan; -use syntax::symbol::{Symbol, sym}; +use syntax::symbol::sym; use syntax_pos::{DUMMY_SP, Span}; use syntax::source_map::{ExpnInfo, MacroAttribute}; use syntax::feature_gate; @@ -40,11 +40,8 @@ pub fn expand( mark.set_expn_info(ExpnInfo { call_site: DUMMY_SP, def_site: None, - format: MacroAttribute(Symbol::intern("test_case")), - allow_internal_unstable: Some(vec![ - Symbol::intern("test"), - Symbol::intern("rustc_attrs"), - ].into()), + format: MacroAttribute(sym::test_case), + allow_internal_unstable: Some(vec![sym::test, sym::rustc_attrs].into()), allow_internal_unsafe: false, local_inner_macros: false, edition: ecx.parse_sess.edition, @@ -59,7 +56,7 @@ pub fn expand( item.ident = item.ident.gensym(); item.attrs.push( ecx.attribute(sp, - ecx.meta_word(sp, Symbol::intern("rustc_test_marker"))) + ecx.meta_word(sp, sym::rustc_test_marker)) ); item }); diff --git a/src/libsyntax_pos/symbol.rs b/src/libsyntax_pos/symbol.rs index 3296de7b927..30b342a11d8 100644 --- a/src/libsyntax_pos/symbol.rs +++ b/src/libsyntax_pos/symbol.rs @@ -145,6 +145,7 @@ symbols! { automatically_derived, avx512_target_feature, await_macro, + bench, bin, bind_by_move_pattern_guards, block, @@ -252,8 +253,10 @@ symbols! { f64, feature, ffi_returns_twice, + field, field_init_shorthand, file, + fmt_internals, fn_must_use, forbid, format_args_nl, @@ -405,6 +408,7 @@ symbols! { Output, overlapping_marker_traits, packed, + panic, panic_handler, panic_impl, panic_implementation, @@ -430,6 +434,7 @@ symbols! { proc_dash_macro: "proc-macro", proc_macro, proc_macro_attribute, + proc_macro_def_site, proc_macro_derive, proc_macro_expr, proc_macro_gen, @@ -568,6 +573,7 @@ symbols! { test, test_2018_feature, test_accepted_feature, + test_case, test_removed_feature, test_runner, thread_local,