OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Auto merge of #60910 - nnethercote:avoid-some-unnecessary-interning, r=petrochenkov

Browse Source 
Avoid some unnecessary interning

r? @petrochenkov
This commit is contained in:
bors 2019-05-18 02:10:21 +00:00
commit 548add7f61
16 changed files with 67 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/librustc/hir/lowering.rs
View File

@ -2218,7 +2218,7 @@ impl<'a> LoweringContext<'a> {
bindings: hir_vec![
hir::TypeBinding {
hir_id: this.next_id(),
ident: Ident::from_str(FN_OUTPUT_NAME),
ident: Ident::with_empty_ctxt(FN_OUTPUT_NAME),
ty: output
.as_ref()
.map(|ty| this.lower_ty(&ty, ImplTraitContext::disallowed()))
@ -2543,7 +2543,7 @@ impl<'a> LoweringContext<'a> {
let future_params = P(hir::GenericArgs {
args: hir_vec![],
bindings: hir_vec![hir::TypeBinding {
ident: Ident::from_str(FN_OUTPUT_NAME),
ident: Ident::with_empty_ctxt(FN_OUTPUT_NAME),
ty: output_ty,
hir_id: self.next_id(),
span,
@ -4801,7 +4801,7 @@ impl<'a> LoweringContext<'a> {
let attr = {
// `allow(unreachable_code)`
let allow = {
let allow_ident = Ident::from_str("allow").with_span_pos(e.span);
let allow_ident = Ident::with_empty_ctxt(sym::allow).with_span_pos(e.span);
let uc_ident = Ident::from_str("unreachable_code").with_span_pos(e.span);
let uc_nested = attr::mk_nested_word_item(uc_ident);
attr::mk_list_item(e.span, allow_ident, vec![uc_nested])

18
src/librustc/hir/map/definitions.rs
View File

@ -17,7 +17,7 @@ use std::fmt::Write;
use std::hash::Hash;
use syntax::ast;
use syntax::ext::hygiene::Mark;
use syntax::symbol::{Symbol, InternedString};
use syntax::symbol::{Symbol, sym, InternedString};
use syntax_pos::{Span, DUMMY_SP};
use crate::util::nodemap::NodeMap;
@ -584,16 +584,16 @@ impl DefPathData {
return name
}
// note that this does not show up in user printouts
CrateRoot => "{{crate}}",
Impl => "{{impl}}",
Misc => "{{misc}}",
ClosureExpr => "{{closure}}",
Ctor => "{{constructor}}",
AnonConst => "{{constant}}",
ImplTrait => "{{opaque}}",
CrateRoot => sym::double_braced_crate,
Impl => sym::double_braced_impl,
Misc => sym::double_braced_misc,
ClosureExpr => sym::double_braced_closure,
Ctor => sym::double_braced_constructor,
AnonConst => sym::double_braced_constant,
ImplTrait => sym::double_braced_opaque,
};
Symbol::intern(s).as_interned_str()
s.as_interned_str()
}
pub fn to_string(&self) -> String {

2
src/librustc/traits/project.rs
View File

@ -1421,7 +1421,7 @@ fn confirm_callable_candidate<'cx, 'gcx, 'tcx>(
projection_ty: ty::ProjectionTy::from_ref_and_name(
tcx,
trait_ref,
Ident::from_str(FN_OUTPUT_NAME),
Ident::with_empty_ctxt(FN_OUTPUT_NAME),
),
ty: ret_type
}

3
src/librustc/util/common.rs
View File

@ -11,6 +11,7 @@ use std::time::{Duration, Instant};
use std::sync::mpsc::{Sender};
use syntax_pos::{SpanData};
use syntax::symbol::{Symbol, sym};
use rustc_macros::HashStable;
use crate::ty::TyCtxt;
use crate::dep_graph::{DepNode};
@ -18,7 +19,7 @@ use lazy_static;
use crate::session::Session;
// The name of the associated type for `Fn` return types
pub const FN_OUTPUT_NAME: &str = "Output";
pub const FN_OUTPUT_NAME: Symbol = sym::Output;
// Useful type to use with `Result<>` indicate that an error has already
// been reported to the user, so no need to continue checking.

13
src/librustc_allocator/expand.rs
View File

@ -19,7 +19,7 @@ use syntax::{
mut_visit::{self, MutVisitor},
parse::ParseSess,
ptr::P,
symbol::{Symbol, sym}
symbol::{keywords, Symbol, sym}
};
use syntax_pos::Span;
@ -110,13 +110,14 @@ impl MutVisitor for ExpandAllocatorDirectives<'_> {
span,
kind: AllocatorKind::Global,
global: item.ident,
core: Ident::from_str("core"),
core: Ident::with_empty_ctxt(sym::core),
cx: ExtCtxt::new(self.sess, ecfg, self.resolver),
};
// We will generate a new submodule. To `use` the static from that module, we need to get
// the `super::...` path.
let super_path = f.cx.path(f.span, vec![Ident::from_str("super"), f.global]);
let super_path =
f.cx.path(f.span, vec![Ident::with_empty_ctxt(keywords::Super.name()), f.global]);
// Generate the items in the submodule
let mut items = vec![
@ -236,7 +237,7 @@ impl AllocFnFactory<'_> {
) -> P<Expr> {
match *ty {
AllocatorTy::Layout => {
let usize = self.cx.path_ident(self.span, Ident::from_str("usize"));
let usize = self.cx.path_ident(self.span, Ident::with_empty_ctxt(sym::usize));
let ty_usize = self.cx.ty_path(usize);
let size = ident();
let align = ident();
@ -298,12 +299,12 @@ impl AllocFnFactory<'_> {
}
fn usize(&self) -> P<Ty> {
let usize = self.cx.path_ident(self.span, Ident::from_str("usize"));
let usize = self.cx.path_ident(self.span, Ident::with_empty_ctxt(sym::usize));
self.cx.ty_path(usize)
}
fn ptr_u8(&self) -> P<Ty> {
let u8 = self.cx.path_ident(self.span, Ident::from_str("u8"));
let u8 = self.cx.path_ident(self.span, Ident::with_empty_ctxt(sym::u8));
let ty_u8 = self.cx.ty_path(u8);
self.cx.ty_ptr(self.span, ty_u8, Mutability::Mutable)
}

8
src/librustc_resolve/lib.rs
View File

@ -1979,11 +1979,11 @@ impl<'a> Resolver<'a> {
.collect();
if !attr::contains_name(&krate.attrs, sym::no_core) {
extern_prelude.insert(Ident::from_str("core"), Default::default());
extern_prelude.insert(Ident::with_empty_ctxt(sym::core), Default::default());
if !attr::contains_name(&krate.attrs, sym::no_std) {
extern_prelude.insert(Ident::from_str("std"), Default::default());
extern_prelude.insert(Ident::with_empty_ctxt(sym::std), Default::default());
if session.rust_2018() {
extern_prelude.insert(Ident::from_str("meta"), Default::default());
extern_prelude.insert(Ident::with_empty_ctxt(sym::meta), Default::default());
}
}
}
@ -3374,7 +3374,7 @@ impl<'a> Resolver<'a> {
self.trait_map.insert(id, traits);
}
let mut std_path = vec![Segment::from_ident(Ident::from_str("std"))];
let mut std_path = vec![Segment::from_ident(Ident::with_empty_ctxt(sym::std))];
std_path.extend(path);
if self.primitive_type_table.primitive_types.contains_key(&path[0].ident.name) {
let cl = CrateLint::No;

5
src/librustdoc/clean/mod.rs
View File

@ -929,8 +929,9 @@ impl Attributes {
for attr in attrs.lists(sym::target_feature) {
if attr.check_name(sym::enable) {
if let Some(feat) = attr.value_str() {
let meta = attr::mk_name_value_item_str(Ident::from_str("target_feature"),
dummy_spanned(feat));
let meta = attr::mk_name_value_item_str(
Ident::with_empty_ctxt(sym::target_feature),
dummy_spanned(feat));
if let Ok(feat_cfg) = Cfg::parse(&meta) {
cfg &= feat_cfg;
}

6
src/libsyntax/attr/mod.rs
View File

@ -22,7 +22,7 @@ use crate::parse::parser::Parser;
use crate::parse::{self, ParseSess, PResult};
use crate::parse::token::{self, Token};
use crate::ptr::P;
use crate::symbol::{keywords, Symbol};
use crate::symbol::{keywords, Symbol, sym};
use crate::ThinVec;
use crate::tokenstream::{TokenStream, TokenTree, DelimSpan};
use crate::GLOBALS;
@ -323,7 +323,7 @@ impl Attribute {
if self.is_sugared_doc {
let comment = self.value_str().unwrap();
let meta = mk_name_value_item_str(
Ident::from_str("doc"),
Ident::with_empty_ctxt(sym::doc),
dummy_spanned(Symbol::intern(&strip_doc_comment_decoration(&comment.as_str()))));
let mut attr = if self.style == ast::AttrStyle::Outer {
mk_attr_outer(self.span, self.id, meta)
@ -414,7 +414,7 @@ pub fn mk_sugared_doc_attr(id: AttrId, text: Symbol, span: Span) -> Attribute {
Attribute {
id,
style,
path: Path::from_ident(Ident::from_str("doc").with_span_pos(span)),
path: Path::from_ident(Ident::with_empty_ctxt(sym::doc).with_span_pos(span)),
tokens: MetaItemKind::NameValue(lit).tokens(span),
is_sugared_doc: true,
span,

8
src/libsyntax/ext/expand.rs
View File

@ -1522,19 +1522,19 @@ impl<'a, 'b> MutVisitor for InvocationCollector<'a, 'b> {
let include_info = vec![
ast::NestedMetaItem::MetaItem(
attr::mk_name_value_item_str(
Ident::from_str("file"),
Ident::with_empty_ctxt(sym::file),
dummy_spanned(file),
),
),
ast::NestedMetaItem::MetaItem(
attr::mk_name_value_item_str(
Ident::from_str("contents"),
Ident::with_empty_ctxt(sym::contents),
dummy_spanned(src_interned),
),
),
];
let include_ident = Ident::from_str("include");
let include_ident = Ident::with_empty_ctxt(sym::include);
let item = attr::mk_list_item(DUMMY_SP, include_ident, include_info);
items.push(ast::NestedMetaItem::MetaItem(item));
}
@ -1600,7 +1600,7 @@ impl<'a, 'b> MutVisitor for InvocationCollector<'a, 'b> {
}
}
let meta = attr::mk_list_item(DUMMY_SP, Ident::from_str("doc"), items);
let meta = attr::mk_list_item(DUMMY_SP, Ident::with_empty_ctxt(sym::doc), items);
match at.style {
ast::AttrStyle::Inner => *at = attr::mk_spanned_attr_inner(at.span, at.id, meta),
ast::AttrStyle::Outer => *at = attr::mk_spanned_attr_outer(at.span, at.id, meta),

5
src/libsyntax/parse/parser.rs
View File

@ -352,7 +352,7 @@ impl TokenCursor {
let body = TokenTree::Delimited(
delim_span,
token::Bracket,
[TokenTree::Token(sp, token::Ident(ast::Ident::from_str("doc"), false)),
[TokenTree::Token(sp, token::Ident(ast::Ident::with_empty_ctxt(sym::doc), false)),
TokenTree::Token(sp, token::Eq),
TokenTree::Token(sp, token::Literal(
token::StrRaw(Symbol::intern(&stripped), num_of_hashes), None))
@ -7011,7 +7011,8 @@ impl<'a> Parser<'a> {
let attr = Attribute {
id: attr::mk_attr_id(),
style: ast::AttrStyle::Outer,
path: ast::Path::from_ident(Ident::from_str("warn_directory_ownership")),
path: ast::Path::from_ident(
Ident::with_empty_ctxt(sym::warn_directory_ownership)),
tokens: TokenStream::empty(),
is_sugared_doc: false,
span: syntax_pos::DUMMY_SP,

9
src/libsyntax/print/pprust.rs
View File

@ -13,7 +13,7 @@ use crate::print::pp::{self, Breaks};
use crate::print::pp::Breaks::{Consistent, Inconsistent};
use crate::ptr::P;
use crate::std_inject;
use crate::symbol::keywords;
use crate::symbol::{keywords, sym};
use crate::tokenstream::{self, TokenStream, TokenTree};
use rustc_target::spec::abi::{self, Abi};
@ -89,13 +89,14 @@ pub fn print_crate<'a>(cm: &'a SourceMap,
// of the feature gate, so we fake them up here.
// #![feature(prelude_import)]
let pi_nested = attr::mk_nested_word_item(ast::Ident::from_str("prelude_import"));
let list = attr::mk_list_item(DUMMY_SP, ast::Ident::from_str("feature"), vec![pi_nested]);
let pi_nested = attr::mk_nested_word_item(ast::Ident::with_empty_ctxt(sym::prelude_import));
let list = attr::mk_list_item(
DUMMY_SP, ast::Ident::with_empty_ctxt(sym::feature), vec![pi_nested]);
let fake_attr = attr::mk_attr_inner(DUMMY_SP, attr::mk_attr_id(), list);
s.print_attribute(&fake_attr)?;
// #![no_std]
let no_std_meta = attr::mk_word_item(ast::Ident::from_str("no_std"));
let no_std_meta = attr::mk_word_item(ast::Ident::with_empty_ctxt(sym::no_std));
let fake_attr = attr::mk_attr_inner(DUMMY_SP, attr::mk_attr_id(), no_std_meta);
s.print_attribute(&fake_attr)?;
}

8
src/libsyntax/std_inject.rs
View File

@ -77,9 +77,11 @@ pub fn maybe_inject_crates_ref(
None
};
krate.module.items.insert(0, P(ast::Item {
attrs: vec![attr::mk_attr_outer(DUMMY_SP,
attr::mk_attr_id(),
attr::mk_word_item(ast::Ident::from_str("macro_use")))],
attrs: vec![attr::mk_attr_outer(
DUMMY_SP,
attr::mk_attr_id(),
attr::mk_word_item(ast::Ident::with_empty_ctxt(sym::macro_use))
)],
vis: dummy_spanned(ast::VisibilityKind::Inherited),
node: ast::ItemKind::ExternCrate(alt_std_name.or(orig_name)),
ident: ast::Ident::with_empty_ctxt(rename),

4
src/libsyntax/test.rs
View File

@ -171,7 +171,7 @@ impl MutVisitor for EntryPointCleaner {
EntryPointType::MainAttr |
EntryPointType::Start =>
item.map(|ast::Item {id, ident, attrs, node, vis, span, tokens}| {
let allow_ident = Ident::from_str("allow");
let allow_ident = Ident::with_empty_ctxt(sym::allow);
let dc_nested = attr::mk_nested_word_item(Ident::from_str("dead_code"));
let allow_dead_code_item = attr::mk_list_item(DUMMY_SP, allow_ident,
vec![dc_nested]);
@ -215,7 +215,7 @@ fn mk_reexport_mod(cx: &mut TestCtxt<'_>,
tests: Vec<Ident>,
tested_submods: Vec<(Ident, Ident)>)
-> (P<ast::Item>, Ident) {
let super_ = Ident::from_str("super");
let super_ = Ident::with_empty_ctxt(keywords::Super.name());
let items = tests.into_iter().map(|r| {
cx.ext_cx.item_use_simple(DUMMY_SP, dummy_spanned(ast::VisibilityKind::Public),

5
src/libsyntax_ext/env.rs
View File

@ -6,7 +6,7 @@
use syntax::ast::{self, Ident, GenericArg};
use syntax::ext::base::{self, *};
use syntax::ext::build::AstBuilder;
use syntax::symbol::{keywords, Symbol};
use syntax::symbol::{keywords, Symbol, sym};
use syntax_pos::Span;
use syntax::tokenstream;
@ -29,7 +29,8 @@ pub fn expand_option_env<'cx>(cx: &'cx mut ExtCtxt<'_>,
true,
cx.std_path(&["option", "Option", "None"]),
vec![GenericArg::Type(cx.ty_rptr(sp,
cx.ty_ident(sp, Ident::from_str("str")),
cx.ty_ident(sp,
Ident::with_empty_ctxt(sym::str)),
Some(lt),
ast::Mutability::Immutable))],
vec![]))

6
src/libsyntax_ext/proc_macro_decls.rs
View File

@ -362,11 +362,11 @@ fn mk_decls(
});
let span = DUMMY_SP.apply_mark(mark);
let hidden = cx.meta_list_item_word(span, Symbol::intern("hidden"));
let doc = cx.meta_list(span, Symbol::intern("doc"), vec![hidden]);
let hidden = cx.meta_list_item_word(span, sym::hidden);
let doc = cx.meta_list(span, sym::doc, vec![hidden]);
let doc_hidden = cx.attribute(span, doc);
let proc_macro = Ident::from_str("proc_macro");
let proc_macro = Ident::with_empty_ctxt(sym::proc_macro);
let krate = cx.item(span,
proc_macro,
Vec::new(),

10
src/libsyntax_pos/symbol.rs
View File

@ -214,6 +214,13 @@ symbols! {
document_private_items,
dotdoteq_in_patterns,
dotdot_in_tuple_patterns,
double_braced_crate: "{{crate}}",
double_braced_impl: "{{impl}}",
double_braced_misc: "{{misc}}",
double_braced_closure: "{{closure}}",
double_braced_constructor: "{{constructor}}",
double_braced_constant: "{{constant}}",
double_braced_opaque: "{{opaque}}",
dropck_eyepatch,
dropck_parametricity,
drop_types_in_const,
@ -336,6 +343,7 @@ symbols! {
match_default_bindings,
may_dangle,
message,
meta,
min_const_fn,
min_const_unsafe_fn,
mips_target_feature,
@ -385,6 +393,7 @@ symbols! {
option,
Option,
opt_out_copy,
Output,
overlapping_marker_traits,
packed,
panic_handler,
@ -530,6 +539,7 @@ symbols! {
static_nobundle,
static_recursion,
std,
str,
stmt_expr_attributes,
stop_after_dataflow,
struct_field_attributes,