bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Auto merge of #60630 - nnethercote:use-Symbol-more, r=petrochenkov

Browse source 
Use `Symbol` more

A `Symbol` can be equated with a string (e.g. `&str`). This involves a
TLS lookup to get the chars (and a Mutex lock in a parallel compiler)
and then a char-by-char comparison. This functionality is convenient but
avoids one of the main benefits of `Symbol`s, which is fast equality
comparisons.

This PR removes the `Symbol`/string equality operations, forcing a lot
of existing string occurrences to become `Symbol`s. Fortunately, these
are almost all static strings (many are attribute names) and we can add
static `Symbol`s as necessary, and very little extra interning occurs.
The benefits are (a) a slight speedup (possibly greater in a parallel
compiler), and (b) the code is a lot more principled about `Symbol` use.
The main downside is verbosity, particularly with more `use
syntax::symbol::symbols` items.

r? @Zoxc
This commit is contained in:
bors 2019-05-13 00:28:38 +00:00
commit fe5f42cdb8
135 changed files with 1507 additions and 1041 deletions
Download patch file Download diff file Expand all files Collapse all files

39
src/librustc/hir/check_attr.rs
View file

@ -12,6 +12,7 @@ use crate::hir;
use crate::hir::def_id::DefId; use crate::hir::def_id::DefId;
use crate::hir::intravisit::{self, Visitor, NestedVisitorMap}; use crate::hir::intravisit::{self, Visitor, NestedVisitorMap};
use std::fmt::{self, Display}; use std::fmt::{self, Display};
use syntax::symbol::sym;
use syntax_pos::Span; use syntax_pos::Span;
#[derive(Copy, Clone, PartialEq)] #[derive(Copy, Clone, PartialEq)]
@ -95,18 +96,18 @@ impl<'a, 'tcx> CheckAttrVisitor<'a, 'tcx> {
fn check_attributes(&self, item: &hir::Item, target: Target) { fn check_attributes(&self, item: &hir::Item, target: Target) {
if target == Target::Fn || target == Target::Const { if target == Target::Fn || target == Target::Const {
self.tcx.codegen_fn_attrs(self.tcx.hir().local_def_id_from_hir_id(item.hir_id)); self.tcx.codegen_fn_attrs(self.tcx.hir().local_def_id_from_hir_id(item.hir_id));
} else if let Some(a) = item.attrs.iter().find(|a| a.check_name("target_feature")) { } else if let Some(a) = item.attrs.iter().find(|a| a.check_name(sym::target_feature)) {
self.tcx.sess.struct_span_err(a.span, "attribute should be applied to a function") self.tcx.sess.struct_span_err(a.span, "attribute should be applied to a function")
.span_label(item.span, "not a function") .span_label(item.span, "not a function")
.emit(); .emit();
} }
for attr in &item.attrs { for attr in &item.attrs {
if attr.check_name("inline") { if attr.check_name(sym::inline) {
self.check_inline(attr, &item.span, target) self.check_inline(attr, &item.span, target)
} else if attr.check_name("non_exhaustive") { } else if attr.check_name(sym::non_exhaustive) {
self.check_non_exhaustive(attr, item, target) self.check_non_exhaustive(attr, item, target)
} else if attr.check_name("marker") { } else if attr.check_name(sym::marker) {
self.check_marker(attr, item, target) self.check_marker(attr, item, target)
} }
} }
@ -166,7 +167,7 @@ impl<'a, 'tcx> CheckAttrVisitor<'a, 'tcx> {
// ``` // ```
let hints: Vec<_> = item.attrs let hints: Vec<_> = item.attrs
.iter() .iter()
.filter(|attr| attr.check_name("repr")) .filter(|attr| attr.check_name(sym::repr))
.filter_map(|attr| attr.meta_item_list()) .filter_map(|attr| attr.meta_item_list())
.flatten() .flatten()
.collect(); .collect();
@ -177,9 +178,9 @@ impl<'a, 'tcx> CheckAttrVisitor<'a, 'tcx> {
let mut is_transparent = false; let mut is_transparent = false;
for hint in &hints { for hint in &hints {
let (article, allowed_targets) = match hint.name_or_empty().get() { let (article, allowed_targets) = match hint.name_or_empty() {
name @ "C" | name @ "align" => { name @ sym::C | name @ sym::align => {
is_c |= name == "C"; is_c |= name == sym::C;
if target != Target::Struct && if target != Target::Struct &&
target != Target::Union && target != Target::Union &&
target != Target::Enum { target != Target::Enum {
@ -188,7 +189,7 @@ impl<'a, 'tcx> CheckAttrVisitor<'a, 'tcx> {
continue continue
} }
} }
"packed" => { sym::packed => {
if target != Target::Struct && if target != Target::Struct &&
target != Target::Union { target != Target::Union {
("a", "struct or union") ("a", "struct or union")
@ -196,7 +197,7 @@ impl<'a, 'tcx> CheckAttrVisitor<'a, 'tcx> {
continue continue
} }
} }
"simd" => { sym::simd => {
is_simd = true; is_simd = true;
if target != Target::Struct { if target != Target::Struct {
("a", "struct") ("a", "struct")
@ -204,7 +205,7 @@ impl<'a, 'tcx> CheckAttrVisitor<'a, 'tcx> {
continue continue
} }
} }
"transparent" => { sym::transparent => {
is_transparent = true; is_transparent = true;
if target != Target::Struct { if target != Target::Struct {
("a", "struct") ("a", "struct")
@ -212,9 +213,9 @@ impl<'a, 'tcx> CheckAttrVisitor<'a, 'tcx> {
continue continue
} }
} }
"i8" | "u8" | "i16" | "u16" | sym::i8 | sym::u8 | sym::i16 | sym::u16 |
"i32" | "u32" | "i64" | "u64" | sym::i32 | sym::u32 | sym::i64 | sym::u64 |
"isize" | "usize" => { sym::isize | sym::usize => {
int_reprs += 1; int_reprs += 1;
if target != Target::Enum { if target != Target::Enum {
("an", "enum") ("an", "enum")
@ -268,10 +269,10 @@ impl<'a, 'tcx> CheckAttrVisitor<'a, 'tcx> {
// When checking statements ignore expressions, they will be checked later // When checking statements ignore expressions, they will be checked later
if let hir::StmtKind::Local(ref l) = stmt.node { if let hir::StmtKind::Local(ref l) = stmt.node {
for attr in l.attrs.iter() { for attr in l.attrs.iter() {
if attr.check_name("inline") { if attr.check_name(sym::inline) {
self.check_inline(attr, &stmt.span, Target::Statement); self.check_inline(attr, &stmt.span, Target::Statement);
} }
if attr.check_name("repr") { if attr.check_name(sym::repr) {
self.emit_repr_error( self.emit_repr_error(
attr.span, attr.span,
stmt.span, stmt.span,
@ -289,10 +290,10 @@ impl<'a, 'tcx> CheckAttrVisitor<'a, 'tcx> {
_ => Target::Expression, _ => Target::Expression,
}; };
for attr in expr.attrs.iter() { for attr in expr.attrs.iter() {
if attr.check_name("inline") { if attr.check_name(sym::inline) {
self.check_inline(attr, &expr.span, target); self.check_inline(attr, &expr.span, target);
} }
if attr.check_name("repr") { if attr.check_name(sym::repr) {
self.emit_repr_error( self.emit_repr_error(
attr.span, attr.span,
expr.span, expr.span,
@ -305,7 +306,7 @@ impl<'a, 'tcx> CheckAttrVisitor<'a, 'tcx> {
fn check_used(&self, item: &hir::Item, target: Target) { fn check_used(&self, item: &hir::Item, target: Target) {
for attr in &item.attrs { for attr in &item.attrs {
if attr.check_name("used") && target != Target::Static { if attr.check_name(sym::used) && target != Target::Static {
self.tcx.sess self.tcx.sess
.span_err(attr.span, "attribute must be applied to a `static` variable"); .span_err(attr.span, "attribute must be applied to a `static` variable");
} }

79
src/librustc/hir/lowering.rs
View file

@ -64,7 +64,7 @@ use syntax::ptr::P;
use syntax::source_map::{respan, CompilerDesugaringKind, Spanned}; use syntax::source_map::{respan, CompilerDesugaringKind, Spanned};
use syntax::source_map::CompilerDesugaringKind::IfTemporary; use syntax::source_map::CompilerDesugaringKind::IfTemporary;
use syntax::std_inject; use syntax::std_inject;
use syntax::symbol::{keywords, Symbol}; use syntax::symbol::{keywords, Symbol, sym};
use syntax::tokenstream::{TokenStream, TokenTree}; use syntax::tokenstream::{TokenStream, TokenTree};
use syntax::parse::token::Token; use syntax::parse::token::Token;
use syntax::visit::{self, Visitor}; use syntax::visit::{self, Visitor};
@ -73,7 +73,7 @@ use syntax_pos::Span;
const HIR_ID_COUNTER_LOCKED: u32 = 0xFFFFFFFF; const HIR_ID_COUNTER_LOCKED: u32 = 0xFFFFFFFF;
pub struct LoweringContext<'a> { pub struct LoweringContext<'a> {
crate_root: Option<&'static str>, crate_root: Option<Symbol>,
/// Used to assign ids to HIR nodes that do not directly correspond to an AST node. /// Used to assign ids to HIR nodes that do not directly correspond to an AST node.
sess: &'a Session, sess: &'a Session,
@ -164,8 +164,8 @@ pub trait Resolver {
fn resolve_str_path( fn resolve_str_path(
&mut self, &mut self,
span: Span, span: Span,
crate_root: Option<&str>, crate_root: Option<Symbol>,
components: &[&str], components: &[Symbol],
is_value: bool, is_value: bool,
) -> hir::Path; ) -> hir::Path;
} }
@ -228,7 +228,7 @@ pub fn lower_crate(
dep_graph.assert_ignored(); dep_graph.assert_ignored();
LoweringContext { LoweringContext {
crate_root: std_inject::injected_crate_name(), crate_root: std_inject::injected_crate_name().map(Symbol::intern),
sess, sess,
cstore, cstore,
resolver, resolver,
@ -1149,7 +1149,7 @@ impl<'a> LoweringContext<'a> {
].into()), ].into()),
); );
let gen_future = self.expr_std_path( let gen_future = self.expr_std_path(
unstable_span, &["future", "from_generator"], None, ThinVec::new()); unstable_span, &[sym::future, sym::from_generator], None, ThinVec::new());
hir::ExprKind::Call(P(gen_future), hir_vec![generator]) hir::ExprKind::Call(P(gen_future), hir_vec![generator])
} }
@ -2548,7 +2548,7 @@ impl<'a> LoweringContext<'a> {
// ::std::future::Future<future_params> // ::std::future::Future<future_params>
let future_path = let future_path =
self.std_path(span, &["future", "Future"], Some(future_params), false); self.std_path(span, &[sym::future, sym::Future], Some(future_params), false);
hir::GenericBound::Trait( hir::GenericBound::Trait(
hir::PolyTraitRef { hir::PolyTraitRef {
@ -2727,7 +2727,7 @@ impl<'a> LoweringContext<'a> {
self.lower_ty(x, ImplTraitContext::disallowed()) self.lower_ty(x, ImplTraitContext::disallowed())
}), }),
synthetic: param.attrs.iter() synthetic: param.attrs.iter()
.filter(|attr| attr.check_name("rustc_synthetic")) .filter(|attr| attr.check_name(sym::rustc_synthetic))
.map(|_| hir::SyntheticTyParamKind::ImplTrait) .map(|_| hir::SyntheticTyParamKind::ImplTrait)
.next(), .next(),
}; };
@ -2745,7 +2745,7 @@ impl<'a> LoweringContext<'a> {
hir_id: self.lower_node_id(param.id), hir_id: self.lower_node_id(param.id),
name, name,
span: param.ident.span, span: param.ident.span,
pure_wrt_drop: attr::contains_name(&param.attrs, "may_dangle"), pure_wrt_drop: attr::contains_name(&param.attrs, sym::may_dangle),
attrs: self.lower_attrs(&param.attrs), attrs: self.lower_attrs(&param.attrs),
bounds, bounds,
kind, kind,
@ -3773,8 +3773,8 @@ impl<'a> LoweringContext<'a> {
let mut vis = self.lower_visibility(&i.vis, None); let mut vis = self.lower_visibility(&i.vis, None);
let attrs = self.lower_attrs(&i.attrs); let attrs = self.lower_attrs(&i.attrs);
if let ItemKind::MacroDef(ref def) = i.node { if let ItemKind::MacroDef(ref def) = i.node {
if !def.legacy || attr::contains_name(&i.attrs, "macro_export") || if !def.legacy || attr::contains_name(&i.attrs, sym::macro_export) ||
attr::contains_name(&i.attrs, "rustc_doc_only_macro") { attr::contains_name(&i.attrs, sym::rustc_doc_only_macro) {
let body = self.lower_token_stream(def.stream()); let body = self.lower_token_stream(def.stream());
let hir_id = self.lower_node_id(i.id); let hir_id = self.lower_node_id(i.id);
self.exported_macros.push(hir::MacroDef { self.exported_macros.push(hir::MacroDef {
@ -4194,7 +4194,7 @@ impl<'a> LoweringContext<'a> {
|x: P<hir::Expr>| x.into_inner(), |x: P<hir::Expr>| x.into_inner(),
); );
block.expr = Some(this.wrap_in_try_constructor( block.expr = Some(this.wrap_in_try_constructor(
"from_ok", tail, unstable_span)); sym::from_ok, tail, unstable_span));
hir::ExprKind::Block(P(block), None) hir::ExprKind::Block(P(block), None)
}) })
} }
@ -4336,7 +4336,7 @@ impl<'a> LoweringContext<'a> {
self.expr_call_std_assoc_fn( self.expr_call_std_assoc_fn(
id, id,
e.span, e.span,
&["ops", "RangeInclusive"], &[sym::ops, sym::RangeInclusive],
"new", "new",
hir_vec![e1, e2], hir_vec![e1, e2],
) )
@ -4345,11 +4345,11 @@ impl<'a> LoweringContext<'a> {
use syntax::ast::RangeLimits::*; use syntax::ast::RangeLimits::*;
let path = match (e1, e2, lims) { let path = match (e1, e2, lims) {
(&None, &None, HalfOpen) => "RangeFull", (&None, &None, HalfOpen) => sym::RangeFull,
(&Some(..), &None, HalfOpen) => "RangeFrom", (&Some(..), &None, HalfOpen) => sym::RangeFrom,
(&None, &Some(..), HalfOpen) => "RangeTo", (&None, &Some(..), HalfOpen) => sym::RangeTo,
(&Some(..), &Some(..), HalfOpen) => "Range", (&Some(..), &Some(..), HalfOpen) => sym::Range,
(&None, &Some(..), Closed) => "RangeToInclusive", (&None, &Some(..), Closed) => sym::RangeToInclusive,
(&Some(..), &Some(..), Closed) => unreachable!(), (&Some(..), &Some(..), Closed) => unreachable!(),
(_, &None, Closed) => self.diagnostic() (_, &None, Closed) => self.diagnostic()
.span_fatal(e.span, "inclusive range with no end") .span_fatal(e.span, "inclusive range with no end")
@ -4367,7 +4367,7 @@ impl<'a> LoweringContext<'a> {
.collect::<P<[hir::Field]>>(); .collect::<P<[hir::Field]>>();
let is_unit = fields.is_empty(); let is_unit = fields.is_empty();
let struct_path = ["ops", path]; let struct_path = [sym::ops, path];
let struct_path = self.std_path(e.span, &struct_path, None, is_unit); let struct_path = self.std_path(e.span, &struct_path, None, is_unit);
let struct_path = hir::QPath::Resolved(None, P(struct_path)); let struct_path = hir::QPath::Resolved(None, P(struct_path));
@ -4656,7 +4656,7 @@ impl<'a> LoweringContext<'a> {
let match_expr = { let match_expr = {
let iter = P(self.expr_ident(head_sp, iter, iter_pat_nid)); let iter = P(self.expr_ident(head_sp, iter, iter_pat_nid));
let ref_mut_iter = self.expr_mut_addr_of(head_sp, iter); let ref_mut_iter = self.expr_mut_addr_of(head_sp, iter);
let next_path = &["iter", "Iterator", "next"]; let next_path = &[sym::iter, sym::Iterator, sym::next];
let next_expr = P(self.expr_call_std_path( let next_expr = P(self.expr_call_std_path(
head_sp, head_sp,
next_path, next_path,
@ -4723,7 +4723,8 @@ impl<'a> LoweringContext<'a> {
// `match ::std::iter::IntoIterator::into_iter(<head>) { ... }` // `match ::std::iter::IntoIterator::into_iter(<head>) { ... }`
let into_iter_expr = { let into_iter_expr = {
let into_iter_path = &["iter", "IntoIterator", "into_iter"]; let into_iter_path =
&[sym::iter, sym::IntoIterator, sym::into_iter];
P(self.expr_call_std_path( P(self.expr_call_std_path(
head_sp, head_sp,
into_iter_path, into_iter_path,
@ -4780,7 +4781,7 @@ impl<'a> LoweringContext<'a> {
// expand <expr> // expand <expr>
let sub_expr = self.lower_expr(sub_expr); let sub_expr = self.lower_expr(sub_expr);
let path = &["ops", "Try", "into_result"]; let path = &[sym::ops, sym::Try, sym::into_result];
P(self.expr_call_std_path( P(self.expr_call_std_path(
unstable_span, unstable_span,
path, path,
@ -4822,12 +4823,12 @@ impl<'a> LoweringContext<'a> {
let err_ident = self.str_to_ident("err"); let err_ident = self.str_to_ident("err");
let (err_local, err_local_nid) = self.pat_ident(try_span, err_ident); let (err_local, err_local_nid) = self.pat_ident(try_span, err_ident);
let from_expr = { let from_expr = {
let from_path = &["convert", "From", "from"]; let from_path = &[sym::convert, sym::From, sym::from];
let err_expr = self.expr_ident(try_span, err_ident, err_local_nid); let err_expr = self.expr_ident(try_span, err_ident, err_local_nid);
self.expr_call_std_path(try_span, from_path, hir_vec![err_expr]) self.expr_call_std_path(try_span, from_path, hir_vec![err_expr])
}; };
let from_err_expr = let from_err_expr =
self.wrap_in_try_constructor("from_error", from_expr, unstable_span); self.wrap_in_try_constructor(sym::from_error, from_expr, unstable_span);
let thin_attrs = ThinVec::from(attrs); let thin_attrs = ThinVec::from(attrs);
let catch_scope = self.catch_scopes.last().map(|x| *x); let catch_scope = self.catch_scopes.last().map(|x| *x);
let ret_expr = if let Some(catch_node) = catch_scope { let ret_expr = if let Some(catch_node) = catch_scope {
@ -5057,7 +5058,7 @@ impl<'a> LoweringContext<'a> {
fn expr_call_std_path( fn expr_call_std_path(
&mut self, &mut self,
span: Span, span: Span,
path_components: &[&str], path_components: &[Symbol],
args: hir::HirVec<hir::Expr>, args: hir::HirVec<hir::Expr>,
) -> hir::Expr { ) -> hir::Expr {
let path = P(self.expr_std_path(span, path_components, None, ThinVec::new())); let path = P(self.expr_std_path(span, path_components, None, ThinVec::new()));
@ -5077,7 +5078,7 @@ impl<'a> LoweringContext<'a> {
&mut self, &mut self,
ty_path_id: hir::HirId, ty_path_id: hir::HirId,
span: Span, span: Span,
ty_path_components: &[&str], ty_path_components: &[Symbol],
assoc_fn_name: &str, assoc_fn_name: &str,
args: hir::HirVec<hir::Expr>, args: hir::HirVec<hir::Expr>,
) -> hir::ExprKind { ) -> hir::ExprKind {
@ -5119,7 +5120,7 @@ impl<'a> LoweringContext<'a> {
fn expr_std_path( fn expr_std_path(
&mut self, &mut self,
span: Span, span: Span,
components: &[&str], components: &[Symbol],
params: Option<P<hir::GenericArgs>>, params: Option<P<hir::GenericArgs>>,
attrs: ThinVec<Attribute>, attrs: ThinVec<Attribute>,
) -> hir::Expr { ) -> hir::Expr {
@ -5250,25 +5251,25 @@ impl<'a> LoweringContext<'a> {
} }
fn pat_ok(&mut self, span: Span, pat: P<hir::Pat>) -> P<hir::Pat> { fn pat_ok(&mut self, span: Span, pat: P<hir::Pat>) -> P<hir::Pat> {
self.pat_std_enum(span, &["result", "Result", "Ok"], hir_vec![pat]) self.pat_std_enum(span, &[sym::result, sym::Result, sym::Ok], hir_vec![pat])
} }
fn pat_err(&mut self, span: Span, pat: P<hir::Pat>) -> P<hir::Pat> { fn pat_err(&mut self, span: Span, pat: P<hir::Pat>) -> P<hir::Pat> {
self.pat_std_enum(span, &["result", "Result", "Err"], hir_vec![pat]) self.pat_std_enum(span, &[sym::result, sym::Result, sym::Err], hir_vec![pat])
} }
fn pat_some(&mut self, span: Span, pat: P<hir::Pat>) -> P<hir::Pat> { fn pat_some(&mut self, span: Span, pat: P<hir::Pat>) -> P<hir::Pat> {
self.pat_std_enum(span, &["option", "Option", "Some"], hir_vec![pat]) self.pat_std_enum(span, &[sym::option, sym::Option, sym::Some], hir_vec![pat])
} }
fn pat_none(&mut self, span: Span) -> P<hir::Pat> { fn pat_none(&mut self, span: Span) -> P<hir::Pat> {
self.pat_std_enum(span, &["option", "Option", "None"], hir_vec![]) self.pat_std_enum(span, &[sym::option, sym::Option, sym::None], hir_vec![])
} }
fn pat_std_enum( fn pat_std_enum(
&mut self, &mut self,
span: Span, span: Span,
components: &[&str], components: &[Symbol],
subpats: hir::HirVec<P<hir::Pat>>, subpats: hir::HirVec<P<hir::Pat>>,
) -> P<hir::Pat> { ) -> P<hir::Pat> {
let path = self.std_path(span, components, None, true); let path = self.std_path(span, components, None, true);
@ -5321,7 +5322,7 @@ impl<'a> LoweringContext<'a> {
fn std_path( fn std_path(
&mut self, &mut self,
span: Span, span: Span,
components: &[&str], components: &[Symbol],
params: Option<P<hir::GenericArgs>>, params: Option<P<hir::GenericArgs>>,
is_value: bool, is_value: bool,
) -> hir::Path { ) -> hir::Path {
@ -5520,11 +5521,11 @@ impl<'a> LoweringContext<'a> {
fn wrap_in_try_constructor( fn wrap_in_try_constructor(
&mut self, &mut self,
method: &'static str, method: Symbol,
e: hir::Expr, e: hir::Expr,
unstable_span: Span, unstable_span: Span,
) -> P<hir::Expr> { ) -> P<hir::Expr> {
let path = &["ops", "Try", method]; let path = &[sym::ops, sym::Try, method];
let from_err = P(self.expr_std_path(unstable_span, path, None, let from_err = P(self.expr_std_path(unstable_span, path, None,
ThinVec::new())); ThinVec::new()));
P(self.expr_call(e.span, from_err, hir_vec![e])) P(self.expr_call(e.span, from_err, hir_vec![e]))
@ -5594,7 +5595,7 @@ impl<'a> LoweringContext<'a> {
let new_unchecked_expr_kind = self.expr_call_std_assoc_fn( let new_unchecked_expr_kind = self.expr_call_std_assoc_fn(
pin_ty_id, pin_ty_id,
span, span,
&["pin", "Pin"], &[sym::pin, sym::Pin],
"new_unchecked", "new_unchecked",
hir_vec![ref_mut_pinned], hir_vec![ref_mut_pinned],
); );
@ -5602,7 +5603,7 @@ impl<'a> LoweringContext<'a> {
let unsafe_expr = self.expr_unsafe(new_unchecked); let unsafe_expr = self.expr_unsafe(new_unchecked);
P(self.expr_call_std_path( P(self.expr_call_std_path(
gen_future_span, gen_future_span,
&["future", "poll_with_tls_context"], &[sym::future, sym::poll_with_tls_context],
hir_vec![unsafe_expr], hir_vec![unsafe_expr],
)) ))
}; };
@ -5616,7 +5617,7 @@ impl<'a> LoweringContext<'a> {
let x_expr = P(self.expr_ident(span, x_ident, x_pat_hid)); let x_expr = P(self.expr_ident(span, x_ident, x_pat_hid));
let ready_pat = self.pat_std_enum( let ready_pat = self.pat_std_enum(
span, span,
&["task", "Poll", "Ready"], &[sym::task, sym::Poll, sym::Ready],
hir_vec![x_pat], hir_vec![x_pat],
); );
let break_x = self.with_loop_scope(loop_node_id, |this| { let break_x = self.with_loop_scope(loop_node_id, |this| {
@ -5633,7 +5634,7 @@ impl<'a> LoweringContext<'a> {
let pending_arm = { let pending_arm = {
let pending_pat = self.pat_std_enum( let pending_pat = self.pat_std_enum(
span, span,
&["task", "Poll", "Pending"], &[sym::task, sym::Poll, sym::Pending],
hir_vec![], hir_vec![],
); );
let empty_block = P(self.expr_block_empty(span)); let empty_block = P(self.expr_block_empty(span));

4
src/librustc/hir/map/mod.rs
View file

@ -1146,7 +1146,7 @@ impl<'a> NodesMatchingSuffix<'a> {
None => return false, None => return false,
Some((node_id, name)) => (node_id, name), Some((node_id, name)) => (node_id, name),
}; };
if mod_name != &**part { if mod_name.as_str() != *part {
return false; return false;
} }
cursor = self.map.get_parent_item(mod_id); cursor = self.map.get_parent_item(mod_id);
@ -1183,7 +1183,7 @@ impl<'a> NodesMatchingSuffix<'a> {
// We are looking at some node `n` with a given name and parent // We are looking at some node `n` with a given name and parent
// id; do their names match what I am seeking? // id; do their names match what I am seeking?
fn matches_names(&self, parent_of_n: HirId, name: Name) -> bool { fn matches_names(&self, parent_of_n: HirId, name: Name) -> bool {
name == &**self.item_name && self.suffix_matches(parent_of_n) name.as_str() == *self.item_name && self.suffix_matches(parent_of_n)
} }
fn matches_suffix(&self, hir: HirId) -> bool { fn matches_suffix(&self, hir: HirId) -> bool {

2
src/librustc/ich/hcx.rs
View file

@ -28,7 +28,7 @@ use smallvec::SmallVec;
fn compute_ignored_attr_names() -> FxHashSet<Symbol> { fn compute_ignored_attr_names() -> FxHashSet<Symbol> {
debug_assert!(ich::IGNORED_ATTRIBUTES.len() > 0); debug_assert!(ich::IGNORED_ATTRIBUTES.len() > 0);
ich::IGNORED_ATTRIBUTES.iter().map(|&s| Symbol::intern(s)).collect() ich::IGNORED_ATTRIBUTES.iter().map(|&s| s).collect()
} }
/// This is the context state available during incr. comp. hashing. It contains /// This is the context state available during incr. comp. hashing. It contains

20
src/librustc/ich/mod.rs
View file

@ -4,6 +4,8 @@ crate use rustc_data_structures::fingerprint::Fingerprint;
pub use self::caching_source_map_view::CachingSourceMapView; pub use self::caching_source_map_view::CachingSourceMapView;
pub use self::hcx::{StableHashingContextProvider, StableHashingContext, NodeIdHashingMode, pub use self::hcx::{StableHashingContextProvider, StableHashingContext, NodeIdHashingMode,
hash_stable_trait_impls}; hash_stable_trait_impls};
use syntax::symbol::{Symbol, sym};
mod caching_source_map_view; mod caching_source_map_view;
mod hcx; mod hcx;
@ -12,16 +14,16 @@ mod impls_misc;
mod impls_ty; mod impls_ty;
mod impls_syntax; mod impls_syntax;
pub const ATTR_DIRTY: &str = "rustc_dirty"; pub const ATTR_DIRTY: Symbol = sym::rustc_dirty;
pub const ATTR_CLEAN: &str = "rustc_clean"; pub const ATTR_CLEAN: Symbol = sym::rustc_clean;
pub const ATTR_IF_THIS_CHANGED: &str = "rustc_if_this_changed"; pub const ATTR_IF_THIS_CHANGED: Symbol = sym::rustc_if_this_changed;
pub const ATTR_THEN_THIS_WOULD_NEED: &str = "rustc_then_this_would_need"; pub const ATTR_THEN_THIS_WOULD_NEED: Symbol = sym::rustc_then_this_would_need;
pub const ATTR_PARTITION_REUSED: &str = "rustc_partition_reused"; pub const ATTR_PARTITION_REUSED: Symbol = sym::rustc_partition_reused;
pub const ATTR_PARTITION_CODEGENED: &str = "rustc_partition_codegened"; pub const ATTR_PARTITION_CODEGENED: Symbol = sym::rustc_partition_codegened;
pub const ATTR_EXPECTED_CGU_REUSE: &str = "rustc_expected_cgu_reuse"; pub const ATTR_EXPECTED_CGU_REUSE: Symbol = sym::rustc_expected_cgu_reuse;
pub const IGNORED_ATTRIBUTES: &[&str] = &[ pub const IGNORED_ATTRIBUTES: &[Symbol] = &[
"cfg", sym::cfg,
ATTR_IF_THIS_CHANGED, ATTR_IF_THIS_CHANGED,
ATTR_THEN_THIS_WOULD_NEED, ATTR_THEN_THIS_WOULD_NEED,
ATTR_DIRTY, ATTR_DIRTY,

10
src/librustc/lint/levels.rs
View file

@ -14,7 +14,7 @@ use syntax::ast;
use syntax::attr; use syntax::attr;
use syntax::feature_gate; use syntax::feature_gate;
use syntax::source_map::MultiSpan; use syntax::source_map::MultiSpan;
use syntax::symbol::Symbol; use syntax::symbol::{Symbol, sym};
pub struct LintLevelSets { pub struct LintLevelSets {
list: Vec<LintSet>, list: Vec<LintSet>,
@ -194,7 +194,7 @@ impl<'a> LintLevelsBuilder<'a> {
struct_span_err!(sess, span, E0452, "malformed lint attribute") struct_span_err!(sess, span, E0452, "malformed lint attribute")
}; };
for attr in attrs { for attr in attrs {
let level = match Level::from_str(&attr.name_or_empty()) { let level = match Level::from_symbol(attr.name_or_empty()) {
None => continue, None => continue,
Some(lvl) => lvl, Some(lvl) => lvl,
}; };
@ -221,7 +221,7 @@ impl<'a> LintLevelsBuilder<'a> {
match item.node { match item.node {
ast::MetaItemKind::Word => {} // actual lint names handled later ast::MetaItemKind::Word => {} // actual lint names handled later
ast::MetaItemKind::NameValue(ref name_value) => { ast::MetaItemKind::NameValue(ref name_value) => {
if item.path == "reason" { if item.path == sym::reason {
// found reason, reslice meta list to exclude it // found reason, reslice meta list to exclude it
metas = &metas[0..metas.len()-1]; metas = &metas[0..metas.len()-1];
// FIXME (#55112): issue unused-attributes lint if we thereby // FIXME (#55112): issue unused-attributes lint if we thereby
@ -230,7 +230,7 @@ impl<'a> LintLevelsBuilder<'a> {
if !self.sess.features_untracked().lint_reasons { if !self.sess.features_untracked().lint_reasons {
feature_gate::emit_feature_err( feature_gate::emit_feature_err(
&self.sess.parse_sess, &self.sess.parse_sess,
"lint_reasons", sym::lint_reasons,
item.span, item.span,
feature_gate::GateIssue::Language, feature_gate::GateIssue::Language,
"lint reasons are experimental" "lint reasons are experimental"
@ -261,7 +261,7 @@ impl<'a> LintLevelsBuilder<'a> {
let mut err = bad_attr(li.span()); let mut err = bad_attr(li.span());
if let Some(item) = li.meta_item() { if let Some(item) = li.meta_item() {
if let ast::MetaItemKind::NameValue(_) = item.node { if let ast::MetaItemKind::NameValue(_) = item.node {
if item.path == "reason" { if item.path == sym::reason {
err.help("reason in lint attribute must come last"); err.help("reason in lint attribute must come last");
} }
} }

15
src/librustc/lint/mod.rs
View file

@ -38,7 +38,7 @@ use syntax::ast;
use syntax::source_map::{MultiSpan, ExpnFormat}; use syntax::source_map::{MultiSpan, ExpnFormat};
use syntax::early_buffered_lints::BufferedEarlyLintId; use syntax::early_buffered_lints::BufferedEarlyLintId;
use syntax::edition::Edition; use syntax::edition::Edition;
use syntax::symbol::Symbol; use syntax::symbol::{Symbol, sym};
use syntax_pos::Span; use syntax_pos::Span;
pub use crate::lint::context::{LateContext, EarlyContext, LintContext, LintStore, pub use crate::lint::context::{LateContext, EarlyContext, LintContext, LintStore,
@ -570,6 +570,17 @@ impl Level {
_ => None, _ => None,
} }
} }
/// Converts a symbol to a level.
pub fn from_symbol(x: Symbol) -> Option<Level> {
match x {
sym::allow => Some(Allow),
sym::warn => Some(Warn),
sym::deny => Some(Deny),
sym::forbid => Some(Forbid),
_ => None,
}
}
} }
/// How a lint level was set. /// How a lint level was set.
@ -752,7 +763,7 @@ pub fn struct_lint_level<'a>(sess: &'a Session,
pub fn maybe_lint_level_root(tcx: TyCtxt<'_, '_, '_>, id: hir::HirId) -> bool { pub fn maybe_lint_level_root(tcx: TyCtxt<'_, '_, '_>, id: hir::HirId) -> bool {
let attrs = tcx.hir().attrs_by_hir_id(id); let attrs = tcx.hir().attrs_by_hir_id(id);
attrs.iter().any(|attr| Level::from_str(&attr.name_or_empty()).is_some()) attrs.iter().any(|attr| Level::from_symbol(attr.name_or_empty()).is_some())
} }
fn lint_levels<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, cnum: CrateNum) fn lint_levels<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, cnum: CrateNum)

9
src/librustc/middle/dead.rs
View file

@ -19,6 +19,7 @@ use rustc_data_structures::fx::FxHashMap;
use syntax::{ast, source_map}; use syntax::{ast, source_map};
use syntax::attr; use syntax::attr;
use syntax::symbol::sym;
use syntax_pos; use syntax_pos;
// Any local node that may call something in its body block should be // Any local node that may call something in its body block should be
@ -304,22 +305,22 @@ impl<'a, 'tcx> Visitor<'tcx> for MarkSymbolVisitor<'a, 'tcx> {
fn has_allow_dead_code_or_lang_attr(tcx: TyCtxt<'_, '_, '_>, fn has_allow_dead_code_or_lang_attr(tcx: TyCtxt<'_, '_, '_>,
id: hir::HirId, id: hir::HirId,
attrs: &[ast::Attribute]) -> bool { attrs: &[ast::Attribute]) -> bool {
if attr::contains_name(attrs, "lang") { if attr::contains_name(attrs, sym::lang) {
return true; return true;
} }
// Stable attribute for #[lang = "panic_impl"] // Stable attribute for #[lang = "panic_impl"]
if attr::contains_name(attrs, "panic_handler") { if attr::contains_name(attrs, sym::panic_handler) {
return true; return true;
} }
// (To be) stable attribute for #[lang = "oom"] // (To be) stable attribute for #[lang = "oom"]
if attr::contains_name(attrs, "alloc_error_handler") { if attr::contains_name(attrs, sym::alloc_error_handler) {
return true; return true;
} }
// Don't lint about global allocators // Don't lint about global allocators
if attr::contains_name(attrs, "global_allocator") { if attr::contains_name(attrs, sym::global_allocator) {
return true; return true;
} }

9
src/librustc/middle/entry.rs
View file

@ -4,6 +4,7 @@ use crate::session::{config, Session};
use crate::session::config::EntryFnType; use crate::session::config::EntryFnType;
use syntax::attr; use syntax::attr;
use syntax::entry::EntryPointType; use syntax::entry::EntryPointType;
use syntax::symbol::sym;
use syntax_pos::Span; use syntax_pos::Span;
use crate::hir::{HirId, Item, ItemKind, ImplItem, TraitItem}; use crate::hir::{HirId, Item, ItemKind, ImplItem, TraitItem};
use crate::hir::itemlikevisit::ItemLikeVisitor; use crate::hir::itemlikevisit::ItemLikeVisitor;
@ -58,7 +59,7 @@ fn entry_fn(tcx: TyCtxt<'_, '_, '_>, cnum: CrateNum) -> Option<(DefId, EntryFnTy
} }
// If the user wants no main function at all, then stop here. // If the user wants no main function at all, then stop here.
if attr::contains_name(&tcx.hir().krate().attrs, "no_main") { if attr::contains_name(&tcx.hir().krate().attrs, sym::no_main) {
return None; return None;
} }
@ -81,11 +82,11 @@ fn entry_fn(tcx: TyCtxt<'_, '_, '_>, cnum: CrateNum) -> Option<(DefId, EntryFnTy
fn entry_point_type(item: &Item, at_root: bool) -> EntryPointType { fn entry_point_type(item: &Item, at_root: bool) -> EntryPointType {
match item.node { match item.node {
ItemKind::Fn(..) => { ItemKind::Fn(..) => {
if attr::contains_name(&item.attrs, "start") { if attr::contains_name(&item.attrs, sym::start) {
EntryPointType::Start EntryPointType::Start
} else if attr::contains_name(&item.attrs, "main") { } else if attr::contains_name(&item.attrs, sym::main) {
EntryPointType::MainAttr EntryPointType::MainAttr
} else if item.ident.name == "main" { } else if item.ident.name == sym::main {
if at_root { if at_root {
// This is a top-level function so can be 'main'. // This is a top-level function so can be 'main'.
EntryPointType::MainNamed EntryPointType::MainNamed

8
src/librustc/middle/lang_items.rs
View file

@ -18,7 +18,7 @@ use crate::middle::weak_lang_items;
use crate::util::nodemap::FxHashMap; use crate::util::nodemap::FxHashMap;
use syntax::ast; use syntax::ast;
use syntax::symbol::Symbol; use syntax::symbol::{Symbol, sym};
use syntax_pos::Span; use syntax_pos::Span;
use rustc_macros::HashStable; use rustc_macros::HashStable;
use crate::hir::itemlikevisit::ItemLikeVisitor; use crate::hir::itemlikevisit::ItemLikeVisitor;
@ -209,9 +209,9 @@ impl<'a, 'tcx> LanguageItemCollector<'a, 'tcx> {
/// are also extracted out when found. /// are also extracted out when found.
pub fn extract(attrs: &[ast::Attribute]) -> Option<(Symbol, Span)> { pub fn extract(attrs: &[ast::Attribute]) -> Option<(Symbol, Span)> {
attrs.iter().find_map(|attr| Some(match attr { attrs.iter().find_map(|attr| Some(match attr {
_ if attr.check_name("lang") => (attr.value_str()?, attr.span), _ if attr.check_name(sym::lang) => (attr.value_str()?, attr.span),
_ if attr.check_name("panic_handler") => (Symbol::intern("panic_impl"), attr.span), _ if attr.check_name(sym::panic_handler) => (Symbol::intern("panic_impl"), attr.span),
_ if attr.check_name("alloc_error_handler") => (Symbol::intern("oom"), attr.span), _ if attr.check_name(sym::alloc_error_handler) => (Symbol::intern("oom"), attr.span),
_ => return None, _ => return None,
})) }))
} }

12
src/librustc/middle/lib_features.rs
View file

@ -8,7 +8,7 @@ use crate::ty::TyCtxt;
use crate::hir::intravisit::{self, NestedVisitorMap, Visitor}; use crate::hir::intravisit::{self, NestedVisitorMap, Visitor};
use syntax::symbol::Symbol; use syntax::symbol::Symbol;
use syntax::ast::{Attribute, MetaItem, MetaItemKind}; use syntax::ast::{Attribute, MetaItem, MetaItemKind};
use syntax_pos::{Span, symbols}; use syntax_pos::{Span, sym};
use rustc_data_structures::fx::{FxHashSet, FxHashMap}; use rustc_data_structures::fx::{FxHashSet, FxHashMap};
use rustc_macros::HashStable; use rustc_macros::HashStable;
use errors::DiagnosticId; use errors::DiagnosticId;
@ -51,7 +51,7 @@ impl<'a, 'tcx> LibFeatureCollector<'a, 'tcx> {
} }
fn extract(&self, attr: &Attribute) -> Option<(Symbol, Option<Symbol>, Span)> { fn extract(&self, attr: &Attribute) -> Option<(Symbol, Option<Symbol>, Span)> {
let stab_attrs = [symbols::stable, symbols::unstable, symbols::rustc_const_unstable]; let stab_attrs = [sym::stable, sym::unstable, sym::rustc_const_unstable];
// Find a stability attribute (i.e., `#[stable (..)]`, `#[unstable (..)]`, // Find a stability attribute (i.e., `#[stable (..)]`, `#[unstable (..)]`,
// `#[rustc_const_unstable (..)]`). // `#[rustc_const_unstable (..)]`).
@ -65,9 +65,9 @@ impl<'a, 'tcx> LibFeatureCollector<'a, 'tcx> {
for meta in metas { for meta in metas {
if let Some(mi) = meta.meta_item() { if let Some(mi) = meta.meta_item() {
// Find the `feature = ".."` meta-item. // Find the `feature = ".."` meta-item.
match (mi.name_or_empty().get(), mi.value_str()) { match (mi.name_or_empty(), mi.value_str()) {
("feature", val) => feature = val, (sym::feature, val) => feature = val,
("since", val) => since = val, (sym::since, val) => since = val,
_ => {} _ => {}
} }
} }
@ -76,7 +76,7 @@ impl<'a, 'tcx> LibFeatureCollector<'a, 'tcx> {
// This additional check for stability is to make sure we // This additional check for stability is to make sure we
// don't emit additional, irrelevant errors for malformed // don't emit additional, irrelevant errors for malformed
// attributes. // attributes.
if *stab_attr != "stable" || since.is_some() { if *stab_attr != sym::stable || since.is_some() {
return Some((feature, since, attr.span)); return Some((feature, since, attr.span));
} }
} }

4
src/librustc/middle/liveness.rs
View file

@ -112,7 +112,7 @@ use std::io;
use std::rc::Rc; use std::rc::Rc;
use syntax::ast::{self, NodeId}; use syntax::ast::{self, NodeId};
use syntax::ptr::P; use syntax::ptr::P;
use syntax::symbol::keywords; use syntax::symbol::{keywords, sym};
use syntax_pos::Span; use syntax_pos::Span;
use crate::hir; use crate::hir;
@ -362,7 +362,7 @@ fn visit_fn<'a, 'tcx: 'a>(ir: &mut IrMaps<'a, 'tcx>,
if let FnKind::Method(..) = fk { if let FnKind::Method(..) = fk {
let parent = ir.tcx.hir().get_parent_item(id); let parent = ir.tcx.hir().get_parent_item(id);
if let Some(Node::Item(i)) = ir.tcx.hir().find_by_hir_id(parent) { if let Some(Node::Item(i)) = ir.tcx.hir().find_by_hir_id(parent) {
if i.attrs.iter().any(|a| a.check_name("automatically_derived")) { if i.attrs.iter().any(|a| a.check_name(sym::automatically_derived)) {
return; return;
} }
} }

3
src/librustc/middle/mem_categorization.rs
View file

@ -72,6 +72,7 @@ use crate::hir::{MutImmutable, MutMutable, PatKind};
use crate::hir::pat_util::EnumerateAndAdjustIterator; use crate::hir::pat_util::EnumerateAndAdjustIterator;
use crate::hir; use crate::hir;
use syntax::ast::{self, Name}; use syntax::ast::{self, Name};
use syntax::symbol::sym;
use syntax_pos::Span; use syntax_pos::Span;
use std::borrow::Cow; use std::borrow::Cow;
@ -714,7 +715,7 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
// they also cannot be moved out of. // they also cannot be moved out of.
let is_thread_local = self.tcx.get_attrs(def_id)[..] let is_thread_local = self.tcx.get_attrs(def_id)[..]
.iter() .iter()
.any(|attr| attr.check_name("thread_local")); .any(|attr| attr.check_name(sym::thread_local));
let cat = if is_thread_local { let cat = if is_thread_local {
let re = self.temporary_scope(hir_id.local_id); let re = self.temporary_scope(hir_id.local_id);

7
src/librustc/middle/recursion_limit.rs
View file

@ -7,15 +7,16 @@
use crate::session::Session; use crate::session::Session;
use syntax::ast; use syntax::ast;
use syntax::symbol::{Symbol, sym};
use rustc_data_structures::sync::Once; use rustc_data_structures::sync::Once;
pub fn update_limits(sess: &Session, krate: &ast::Crate) { pub fn update_limits(sess: &Session, krate: &ast::Crate) {
update_limit(krate, &sess.recursion_limit, "recursion_limit", 64); update_limit(krate, &sess.recursion_limit, sym::recursion_limit, 64);
update_limit(krate, &sess.type_length_limit, "type_length_limit", 1048576); update_limit(krate, &sess.type_length_limit, sym::type_length_limit, 1048576);
} }
fn update_limit(krate: &ast::Crate, limit: &Once<usize>, name: &str, default: usize) { fn update_limit(krate: &ast::Crate, limit: &Once<usize>, name: Symbol, default: usize) {
for attr in &krate.attrs { for attr in &krate.attrs {
if !attr.check_name(name) { if !attr.check_name(name) {
continue; continue;

4
src/librustc/middle/resolve_lifetime.rs
View file

@ -23,7 +23,7 @@ use std::mem::replace;
use syntax::ast; use syntax::ast;
use syntax::attr; use syntax::attr;
use syntax::ptr::P; use syntax::ptr::P;
use syntax::symbol::keywords; use syntax::symbol::{keywords, sym};
use syntax_pos::Span; use syntax_pos::Span;
use crate::hir::intravisit::{self, NestedVisitorMap, Visitor}; use crate::hir::intravisit::{self, NestedVisitorMap, Visitor};
@ -1285,7 +1285,7 @@ fn compute_object_lifetime_defaults(
let result = object_lifetime_defaults_for_item(tcx, generics); let result = object_lifetime_defaults_for_item(tcx, generics);
// Debugging aid. // Debugging aid.
if attr::contains_name(&item.attrs, "rustc_object_lifetime_default") { if attr::contains_name(&item.attrs, sym::rustc_object_lifetime_default) {
let object_lifetime_default_reprs: String = result let object_lifetime_default_reprs: String = result
.iter() .iter()
.map(|set| match *set { .map(|set| match *set {

14
src/librustc/middle/stability.rs
View file

@ -11,7 +11,7 @@ use crate::hir::intravisit::{self, Visitor, NestedVisitorMap};
use crate::ty::query::Providers; use crate::ty::query::Providers;
use crate::middle::privacy::AccessLevels; use crate::middle::privacy::AccessLevels;
use crate::session::{DiagnosticMessageId, Session}; use crate::session::{DiagnosticMessageId, Session};
use syntax::symbol::Symbol; use syntax::symbol::{Symbol, sym};
use syntax_pos::{Span, MultiSpan}; use syntax_pos::{Span, MultiSpan};
use syntax::ast::Attribute; use syntax::ast::Attribute;
use syntax::errors::Applicability; use syntax::errors::Applicability;
@ -195,7 +195,7 @@ impl<'a, 'tcx: 'a> Annotator<'a, 'tcx> {
// Emit errors for non-staged-api crates. // Emit errors for non-staged-api crates.
for attr in attrs { for attr in attrs {
let name = attr.name_or_empty(); let name = attr.name_or_empty();
if ["unstable", "stable", "rustc_deprecated"].contains(&name.get()) { if [sym::unstable, sym::stable, sym::rustc_deprecated].contains(&name) {
attr::mark_used(attr); attr::mark_used(attr);
self.tcx.sess.span_err(attr.span, "stability attributes may not be used \ self.tcx.sess.span_err(attr.span, "stability attributes may not be used \
outside of the standard library"); outside of the standard library");
@ -669,7 +669,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
match stability { match stability {
Some(&Stability { level: attr::Unstable { reason, issue }, feature, .. }) => { Some(&Stability { level: attr::Unstable { reason, issue }, feature, .. }) => {
if span.allows_unstable(&feature.as_str()) { if span.allows_unstable(feature) {
debug!("stability: skipping span={:?} since it is internal", span); debug!("stability: skipping span={:?} since it is internal", span);
return EvalResult::Allow; return EvalResult::Allow;
} }
@ -686,7 +686,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
// the `-Z force-unstable-if-unmarked` flag present (we're // the `-Z force-unstable-if-unmarked` flag present (we're
// compiling a compiler crate), then let this missing feature // compiling a compiler crate), then let this missing feature
// annotation slide. // annotation slide.
if feature == "rustc_private" && issue == 27812 { if feature == sym::rustc_private && issue == 27812 {
if self.sess.opts.debugging_opts.force_unstable_if_unmarked { if self.sess.opts.debugging_opts.force_unstable_if_unmarked {
return EvalResult::Allow; return EvalResult::Allow;
} }
@ -739,7 +739,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
let error_id = (DiagnosticMessageId::StabilityId(issue), span_key, msg.clone()); let error_id = (DiagnosticMessageId::StabilityId(issue), span_key, msg.clone());
let fresh = self.sess.one_time_diagnostics.borrow_mut().insert(error_id); let fresh = self.sess.one_time_diagnostics.borrow_mut().insert(error_id);
if fresh { if fresh {
emit_feature_err(&self.sess.parse_sess, &feature.as_str(), span, emit_feature_err(&self.sess.parse_sess, feature, span,
GateIssue::Library(Some(issue)), &msg); GateIssue::Library(Some(issue)), &msg);
} }
} }
@ -802,13 +802,13 @@ impl<'a, 'tcx> Visitor<'tcx> for Checker<'a, 'tcx> {
if adt_def.has_dtor(self.tcx) { if adt_def.has_dtor(self.tcx) {
emit_feature_err(&self.tcx.sess.parse_sess, emit_feature_err(&self.tcx.sess.parse_sess,
"untagged_unions", item.span, GateIssue::Language, sym::untagged_unions, item.span, GateIssue::Language,
"unions with `Drop` implementations are unstable"); "unions with `Drop` implementations are unstable");
} else { } else {
let param_env = self.tcx.param_env(def_id); let param_env = self.tcx.param_env(def_id);
if !param_env.can_type_implement_copy(self.tcx, ty).is_ok() { if !param_env.can_type_implement_copy(self.tcx, ty).is_ok() {
emit_feature_err(&self.tcx.sess.parse_sess, emit_feature_err(&self.tcx.sess.parse_sess,
"untagged_unions", item.span, GateIssue::Language, sym::untagged_unions, item.span, GateIssue::Language,
"unions with non-`Copy` fields are unstable"); "unions with non-`Copy` fields are unstable");
} }
} }

6
src/librustc/middle/weak_lang_items.rs
View file

@ -6,7 +6,7 @@ use crate::middle::lang_items;
use rustc_data_structures::fx::FxHashSet; use rustc_data_structures::fx::FxHashSet;
use rustc_target::spec::PanicStrategy; use rustc_target::spec::PanicStrategy;
use syntax::ast; use syntax::ast;
use syntax::symbol::Symbol; use syntax::symbol::{Symbol, sym};
use syntax_pos::Span; use syntax_pos::Span;
use crate::hir::def_id::DefId; use crate::hir::def_id::DefId;
use crate::hir::intravisit::{Visitor, NestedVisitorMap}; use crate::hir::intravisit::{Visitor, NestedVisitorMap};
@ -46,8 +46,8 @@ pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
pub fn link_name(attrs: &[ast::Attribute]) -> Option<Symbol> { pub fn link_name(attrs: &[ast::Attribute]) -> Option<Symbol> {
lang_items::extract(attrs).and_then(|(name, _)| { lang_items::extract(attrs).and_then(|(name, _)| {
$(if name == stringify!($name) { $(if name == sym::$name {
Some(Symbol::intern(stringify!($sym))) Some(sym::$sym)
} else)* { } else)* {
None None
} }

2
src/librustc/query/mod.rs
View file

@ -1052,7 +1052,7 @@ rustc_queries! {
} }
Other { Other {
query target_features_whitelist(_: CrateNum) -> Lrc<FxHashMap<String, Option<String>>> { query target_features_whitelist(_: CrateNum) -> Lrc<FxHashMap<String, Option<Symbol>>> {
eval_always eval_always
desc { "looking up the whitelist of target features" } desc { "looking up the whitelist of target features" }
} }

3
src/librustc/session/config.rs
View file

@ -2753,6 +2753,7 @@ mod tests {
// another --cfg test // another --cfg test
#[test] #[test]
fn test_switch_implies_cfg_test_unless_cfg_test() { fn test_switch_implies_cfg_test_unless_cfg_test() {
use syntax::symbol::sym;
syntax::with_globals(|| { syntax::with_globals(|| {
let matches = &match optgroups().parse(&["--test".to_string(), let matches = &match optgroups().parse(&["--test".to_string(),
"--cfg=test".to_string()]) { "--cfg=test".to_string()]) {
@ -2763,7 +2764,7 @@ mod tests {
let (sessopts, cfg) = build_session_options_and_crate_config(matches); let (sessopts, cfg) = build_session_options_and_crate_config(matches);
let sess = build_session(sessopts, None, registry); let sess = build_session(sessopts, None, registry);
let cfg = build_configuration(&sess, to_crate_config(cfg)); let cfg = build_configuration(&sess, to_crate_config(cfg));
let mut test_items = cfg.iter().filter(|&&(name, _)| name == "test"); let mut test_items = cfg.iter().filter(|&&(name, _)| name == sym::test);
assert!(test_items.next().is_some()); assert!(test_items.next().is_some());
assert!(test_items.next().is_none()); assert!(test_items.next().is_none());
}); });

3
src/librustc/session/mod.rs
View file

@ -29,6 +29,7 @@ use syntax::feature_gate::{self, AttributeType};
use syntax::json::JsonEmitter; use syntax::json::JsonEmitter;
use syntax::source_map; use syntax::source_map;
use syntax::parse::{self, ParseSess}; use syntax::parse::{self, ParseSess};
use syntax::symbol::Symbol;
use syntax_pos::{MultiSpan, Span}; use syntax_pos::{MultiSpan, Span};
use crate::util::profiling::SelfProfiler; use crate::util::profiling::SelfProfiler;
@ -86,7 +87,7 @@ pub struct Session {
/// in order to avoid redundantly verbose output (Issue #24690, #44953). /// in order to avoid redundantly verbose output (Issue #24690, #44953).
pub one_time_diagnostics: Lock<FxHashSet<(DiagnosticMessageId, Option<Span>, String)>>, pub one_time_diagnostics: Lock<FxHashSet<(DiagnosticMessageId, Option<Span>, String)>>,
pub plugin_llvm_passes: OneThread<RefCell<Vec<String>>>, pub plugin_llvm_passes: OneThread<RefCell<Vec<String>>>,
pub plugin_attributes: Lock<Vec<(String, AttributeType)>>, pub plugin_attributes: Lock<Vec<(Symbol, AttributeType)>>,
pub crate_types: Once<Vec<config::CrateType>>, pub crate_types: Once<Vec<config::CrateType>>,
pub dependency_formats: Once<dependency_format::Dependencies>, pub dependency_formats: Once<dependency_format::Dependencies>,
/// The crate_disambiguator is constructed out of all the `-C metadata` /// The crate_disambiguator is constructed out of all the `-C metadata`

9
src/librustc/traits/coherence.rs
View file

@ -4,17 +4,16 @@
//! [trait-resolution]: https://rust-lang.github.io/rustc-guide/traits/resolution.html //! [trait-resolution]: https://rust-lang.github.io/rustc-guide/traits/resolution.html
//! [trait-specialization]: https://rust-lang.github.io/rustc-guide/traits/specialization.html //! [trait-specialization]: https://rust-lang.github.io/rustc-guide/traits/specialization.html
use crate::infer::CombinedSnapshot; use crate::infer::{CombinedSnapshot, InferOk};
use crate::hir::def_id::{DefId, LOCAL_CRATE}; use crate::hir::def_id::{DefId, LOCAL_CRATE};
use syntax_pos::DUMMY_SP;
use crate::traits::{self, Normalized, SelectionContext, Obligation, ObligationCause}; use crate::traits::{self, Normalized, SelectionContext, Obligation, ObligationCause};
use crate::traits::IntercrateMode; use crate::traits::IntercrateMode;
use crate::traits::select::IntercrateAmbiguityCause; use crate::traits::select::IntercrateAmbiguityCause;
use crate::ty::{self, Ty, TyCtxt}; use crate::ty::{self, Ty, TyCtxt};
use crate::ty::fold::TypeFoldable; use crate::ty::fold::TypeFoldable;
use crate::ty::subst::Subst; use crate::ty::subst::Subst;
use syntax::symbol::sym;
use crate::infer::{InferOk}; use syntax_pos::DUMMY_SP;
/// Whether we do the orphan check relative to this crate or /// Whether we do the orphan check relative to this crate or
/// to some remote crate. /// to some remote crate.
@ -233,7 +232,7 @@ pub fn trait_ref_is_knowable<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
pub fn trait_ref_is_local_or_fundamental<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>, pub fn trait_ref_is_local_or_fundamental<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
trait_ref: ty::TraitRef<'tcx>) trait_ref: ty::TraitRef<'tcx>)
-> bool { -> bool {
trait_ref.def_id.krate == LOCAL_CRATE || tcx.has_attr(trait_ref.def_id, "fundamental") trait_ref.def_id.krate == LOCAL_CRATE || tcx.has_attr(trait_ref.def_id, sym::fundamental)
} }
pub enum OrphanCheckErr<'tcx> { pub enum OrphanCheckErr<'tcx> {

3
src/librustc/traits/error_reporting.rs
View file

@ -35,6 +35,7 @@ use crate::util::nodemap::{FxHashMap, FxHashSet};
use errors::{Applicability, DiagnosticBuilder}; use errors::{Applicability, DiagnosticBuilder};
use std::fmt; use std::fmt;
use syntax::ast; use syntax::ast;
use syntax::symbol::sym;
use syntax_pos::{DUMMY_SP, Span, ExpnInfo, ExpnFormat}; use syntax_pos::{DUMMY_SP, Span, ExpnInfo, ExpnFormat};
impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> { impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
@ -329,7 +330,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
return None return None
}; };
if tcx.has_attr(impl_def_id, "rustc_on_unimplemented") { if tcx.has_attr(impl_def_id, sym::rustc_on_unimplemented) {
Some(impl_def_id) Some(impl_def_id)
} else { } else {
None None

11
src/librustc/traits/on_unimplemented.rs
View file

@ -7,6 +7,7 @@ use crate::util::nodemap::FxHashMap;
use syntax::ast::{MetaItem, NestedMetaItem}; use syntax::ast::{MetaItem, NestedMetaItem};
use syntax::attr; use syntax::attr;
use syntax::symbol::sym;
use syntax_pos::Span; use syntax_pos::Span;
use syntax_pos::symbol::LocalInternedString; use syntax_pos::symbol::LocalInternedString;
@ -84,25 +85,25 @@ impl<'a, 'gcx, 'tcx> OnUnimplementedDirective {
let mut note = None; let mut note = None;
let mut subcommands = vec![]; let mut subcommands = vec![];
for item in item_iter { for item in item_iter {
if item.check_name("message") && message.is_none() { if item.check_name(sym::message) && message.is_none() {
if let Some(message_) = item.value_str() { if let Some(message_) = item.value_str() {
message = Some(OnUnimplementedFormatString::try_parse( message = Some(OnUnimplementedFormatString::try_parse(
tcx, trait_def_id, message_.as_str(), span)?); tcx, trait_def_id, message_.as_str(), span)?);
continue; continue;
} }
} else if item.check_name("label") && label.is_none() { } else if item.check_name(sym::label) && label.is_none() {
if let Some(label_) = item.value_str() { if let Some(label_) = item.value_str() {
label = Some(OnUnimplementedFormatString::try_parse( label = Some(OnUnimplementedFormatString::try_parse(
tcx, trait_def_id, label_.as_str(), span)?); tcx, trait_def_id, label_.as_str(), span)?);
continue; continue;
} }
} else if item.check_name("note") && note.is_none() { } else if item.check_name(sym::note) && note.is_none() {
if let Some(note_) = item.value_str() { if let Some(note_) = item.value_str() {
note = Some(OnUnimplementedFormatString::try_parse( note = Some(OnUnimplementedFormatString::try_parse(
tcx, trait_def_id, note_.as_str(), span)?); tcx, trait_def_id, note_.as_str(), span)?);
continue; continue;
} }
} else if item.check_name("on") && is_root && } else if item.check_name(sym::on) && is_root &&
message.is_none() && label.is_none() && note.is_none() message.is_none() && label.is_none() && note.is_none()
{ {
if let Some(items) = item.meta_item_list() { if let Some(items) = item.meta_item_list() {
@ -139,7 +140,7 @@ impl<'a, 'gcx, 'tcx> OnUnimplementedDirective {
{ {
let attrs = tcx.get_attrs(impl_def_id); let attrs = tcx.get_attrs(impl_def_id);
let attr = if let Some(item) = attr::find_by_name(&attrs, "rustc_on_unimplemented") { let attr = if let Some(item) = attr::find_by_name(&attrs, sym::rustc_on_unimplemented) {
item item
} else { } else {
return Ok(None); return Ok(None);

5
src/librustc/traits/project.rs
View file

@ -19,6 +19,7 @@ use crate::mir::interpret::{GlobalId, ConstValue};
use rustc_data_structures::snapshot_map::{Snapshot, SnapshotMap}; use rustc_data_structures::snapshot_map::{Snapshot, SnapshotMap};
use rustc_macros::HashStable; use rustc_macros::HashStable;
use syntax::ast::Ident; use syntax::ast::Ident;
use syntax::symbol::sym;
use crate::ty::subst::{Subst, InternalSubsts}; use crate::ty::subst::{Subst, InternalSubsts};
use crate::ty::{self, ToPredicate, ToPolyTraitRef, Ty, TyCtxt}; use crate::ty::{self, ToPredicate, ToPolyTraitRef, Ty, TyCtxt};
use crate::ty::fold::{TypeFoldable, TypeFolder}; use crate::ty::fold::{TypeFoldable, TypeFolder};
@ -1318,9 +1319,9 @@ fn confirm_generator_candidate<'cx, 'gcx, 'tcx>(
gen_sig) gen_sig)
.map_bound(|(trait_ref, yield_ty, return_ty)| { .map_bound(|(trait_ref, yield_ty, return_ty)| {
let name = tcx.associated_item(obligation.predicate.item_def_id).ident.name; let name = tcx.associated_item(obligation.predicate.item_def_id).ident.name;
let ty = if name == "Return" { let ty = if name == sym::Return {
return_ty return_ty
} else if name == "Yield" { } else if name == sym::Yield {
yield_ty yield_ty
} else { } else {
bug!() bug!()

9
src/librustc/ty/context.rs
View file

@ -74,7 +74,7 @@ use syntax::ast;
use syntax::attr; use syntax::attr;
use syntax::source_map::MultiSpan; use syntax::source_map::MultiSpan;
use syntax::feature_gate; use syntax::feature_gate;
use syntax::symbol::{Symbol, keywords, InternedString}; use syntax::symbol::{Symbol, keywords, InternedString, sym};
use syntax_pos::Span; use syntax_pos::Span;
use crate::hir; use crate::hir;
@ -1213,7 +1213,8 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
} }
span_bug!(attr.span, "no arguments to `rustc_layout_scalar_valid_range` attribute"); span_bug!(attr.span, "no arguments to `rustc_layout_scalar_valid_range` attribute");
}; };
(get("rustc_layout_scalar_valid_range_start"), get("rustc_layout_scalar_valid_range_end")) (get(sym::rustc_layout_scalar_valid_range_start),
get(sym::rustc_layout_scalar_valid_range_end))
} }
pub fn lift<T: ?Sized + Lift<'tcx>>(self, value: &T) -> Option<T::Lifted> { pub fn lift<T: ?Sized + Lift<'tcx>>(self, value: &T) -> Option<T::Lifted> {
@ -3102,10 +3103,10 @@ pub fn provide(providers: &mut ty::query::Providers<'_>) {
}; };
providers.is_panic_runtime = |tcx, cnum| { providers.is_panic_runtime = |tcx, cnum| {
assert_eq!(cnum, LOCAL_CRATE); assert_eq!(cnum, LOCAL_CRATE);
attr::contains_name(tcx.hir().krate_attrs(), "panic_runtime") attr::contains_name(tcx.hir().krate_attrs(), sym::panic_runtime)
}; };
providers.is_compiler_builtins = |tcx, cnum| { providers.is_compiler_builtins = |tcx, cnum| {
assert_eq!(cnum, LOCAL_CRATE); assert_eq!(cnum, LOCAL_CRATE);
attr::contains_name(tcx.hir().krate_attrs(), "compiler_builtins") attr::contains_name(tcx.hir().krate_attrs(), sym::compiler_builtins)
}; };
} }

12
src/librustc/ty/mod.rs
View file

@ -47,7 +47,7 @@ use std::ops::Range;
use syntax::ast::{self, Name, Ident, NodeId}; use syntax::ast::{self, Name, Ident, NodeId};
use syntax::attr; use syntax::attr;
use syntax::ext::hygiene::Mark; use syntax::ext::hygiene::Mark;
use syntax::symbol::{keywords, Symbol, LocalInternedString, InternedString}; use syntax::symbol::{keywords, sym, Symbol, LocalInternedString, InternedString};
use syntax_pos::Span; use syntax_pos::Span;
use smallvec; use smallvec;
@ -1875,11 +1875,11 @@ impl<'a, 'gcx, 'tcx> VariantDef {
); );
let mut flags = VariantFlags::NO_VARIANT_FLAGS; let mut flags = VariantFlags::NO_VARIANT_FLAGS;
if adt_kind == AdtKind::Struct && tcx.has_attr(parent_did, "non_exhaustive") { if adt_kind == AdtKind::Struct && tcx.has_attr(parent_did, sym::non_exhaustive) {
debug!("found non-exhaustive field list for {:?}", parent_did); debug!("found non-exhaustive field list for {:?}", parent_did);
flags = flags | VariantFlags::IS_FIELD_LIST_NON_EXHAUSTIVE; flags = flags | VariantFlags::IS_FIELD_LIST_NON_EXHAUSTIVE;
} else if let Some(variant_did) = variant_did { } else if let Some(variant_did) = variant_did {
if tcx.has_attr(variant_did, "non_exhaustive") { if tcx.has_attr(variant_did, sym::non_exhaustive) {
debug!("found non-exhaustive field list for {:?}", variant_did); debug!("found non-exhaustive field list for {:?}", variant_did);
flags = flags | VariantFlags::IS_FIELD_LIST_NON_EXHAUSTIVE; flags = flags | VariantFlags::IS_FIELD_LIST_NON_EXHAUSTIVE;
} }
@ -2156,7 +2156,7 @@ impl<'a, 'gcx, 'tcx> AdtDef {
debug!("AdtDef::new({:?}, {:?}, {:?}, {:?})", did, kind, variants, repr); debug!("AdtDef::new({:?}, {:?}, {:?}, {:?})", did, kind, variants, repr);
let mut flags = AdtFlags::NO_ADT_FLAGS; let mut flags = AdtFlags::NO_ADT_FLAGS;
if kind == AdtKind::Enum && tcx.has_attr(did, "non_exhaustive") { if kind == AdtKind::Enum && tcx.has_attr(did, sym::non_exhaustive) {
debug!("found non-exhaustive variant list for {:?}", did); debug!("found non-exhaustive variant list for {:?}", did);
flags = flags | AdtFlags::IS_VARIANT_LIST_NON_EXHAUSTIVE; flags = flags | AdtFlags::IS_VARIANT_LIST_NON_EXHAUSTIVE;
} }
@ -2172,7 +2172,7 @@ impl<'a, 'gcx, 'tcx> AdtDef {
} }
let attrs = tcx.get_attrs(did); let attrs = tcx.get_attrs(did);
if attr::contains_name(&attrs, "fundamental") { if attr::contains_name(&attrs, sym::fundamental) {
flags |= AdtFlags::IS_FUNDAMENTAL; flags |= AdtFlags::IS_FUNDAMENTAL;
} }
if Some(did) == tcx.lang_items().phantom_data() { if Some(did) == tcx.lang_items().phantom_data() {
@ -3030,7 +3030,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
} }
/// Determines whether an item is annotated with an attribute. /// Determines whether an item is annotated with an attribute.
pub fn has_attr(self, did: DefId, attr: &str) -> bool { pub fn has_attr(self, did: DefId, attr: Symbol) -> bool {
attr::contains_name(&self.get_attrs(did), attr) attr::contains_name(&self.get_attrs(did), attr)
} }

3
src/librustc/ty/util.rs
View file

@ -22,6 +22,7 @@ use rustc_macros::HashStable;
use std::{cmp, fmt}; use std::{cmp, fmt};
use syntax::ast; use syntax::ast;
use syntax::attr::{self, SignedInt, UnsignedInt}; use syntax::attr::{self, SignedInt, UnsignedInt};
use syntax::symbol::sym;
use syntax_pos::{Span, DUMMY_SP}; use syntax_pos::{Span, DUMMY_SP};
#[derive(Copy, Clone, Debug)] #[derive(Copy, Clone, Debug)]
@ -447,7 +448,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
// Such access can be in plain sight (e.g., dereferencing // Such access can be in plain sight (e.g., dereferencing
// `*foo.0` of `Foo<'a>(&'a u32)`) or indirectly hidden // `*foo.0` of `Foo<'a>(&'a u32)`) or indirectly hidden
// (e.g., calling `foo.0.clone()` of `Foo<T:Clone>`). // (e.g., calling `foo.0.clone()` of `Foo<T:Clone>`).
if self.has_attr(dtor, "unsafe_destructor_blind_to_params") { if self.has_attr(dtor, sym::unsafe_destructor_blind_to_params) {
debug!("destructor_constraint({:?}) - blind", def.did); debug!("destructor_constraint({:?}) - blind", def.did);
return vec![]; return vec![];
} }

4
src/librustc_allocator/expand.rs
View file

@ -19,7 +19,7 @@ use syntax::{
mut_visit::{self, MutVisitor}, mut_visit::{self, MutVisitor},
parse::ParseSess, parse::ParseSess,
ptr::P, ptr::P,
symbol::Symbol symbol::{Symbol, sym}
}; };
use syntax_pos::Span; use syntax_pos::Span;
@ -58,7 +58,7 @@ impl MutVisitor for ExpandAllocatorDirectives<'_> {
fn flat_map_item(&mut self, item: P<Item>) -> SmallVec<[P<Item>; 1]> { fn flat_map_item(&mut self, item: P<Item>) -> SmallVec<[P<Item>; 1]> {
debug!("in submodule {}", self.in_submod); debug!("in submodule {}", self.in_submod);
let name = if attr::contains_name(&item.attrs, "global_allocator") { let name = if attr::contains_name(&item.attrs, sym::global_allocator) {
"global_allocator" "global_allocator"
} else { } else {
return mut_visit::noop_flat_map_item(item, self); return mut_visit::noop_flat_map_item(item, self);

4
src/librustc_codegen_llvm/attributes.rs
View file

@ -321,12 +321,12 @@ pub fn provide(providers: &mut Providers<'_>) {
// rustdoc needs to be able to document functions that use all the features, so // rustdoc needs to be able to document functions that use all the features, so
// whitelist them all // whitelist them all
Lrc::new(llvm_util::all_known_features() Lrc::new(llvm_util::all_known_features()
.map(|(a, b)| (a.to_string(), b.map(|s| s.to_string()))) .map(|(a, b)| (a.to_string(), b))
.collect()) .collect())
} else { } else {
Lrc::new(llvm_util::target_feature_whitelist(tcx.sess) Lrc::new(llvm_util::target_feature_whitelist(tcx.sess)
.iter() .iter()
.map(|&(a, b)| (a.to_string(), b.map(|s| s.to_string()))) .map(|&(a, b)| (a.to_string(), b))
.collect()) .collect())
} }
}; };

3
src/librustc_codegen_llvm/consts.rs
View file

@ -14,6 +14,7 @@ use rustc::mir::interpret::{ConstValue, Allocation, read_target_uint,
use rustc::hir::Node; use rustc::hir::Node;
use syntax_pos::Span; use syntax_pos::Span;
use rustc_target::abi::HasDataLayout; use rustc_target::abi::HasDataLayout;
use syntax::symbol::sym;
use syntax_pos::symbol::LocalInternedString; use syntax_pos::symbol::LocalInternedString;
use rustc::ty::{self, Ty}; use rustc::ty::{self, Ty};
use rustc_codegen_ssa::traits::*; use rustc_codegen_ssa::traits::*;
@ -248,7 +249,7 @@ impl CodegenCx<'ll, 'tcx> {
debug!("get_static: sym={} attrs={:?}", sym, attrs); debug!("get_static: sym={} attrs={:?}", sym, attrs);
for attr in attrs { for attr in attrs {
if attr.check_name("thread_local") { if attr.check_name(sym::thread_local) {
llvm::set_thread_local_mode(g, self.tls_model); llvm::set_thread_local_mode(g, self.tls_model);
} }
} }

4
src/librustc_codegen_llvm/debuginfo/gdb.rs
View file

@ -9,6 +9,7 @@ use rustc::session::config::DebugInfo;
use rustc_codegen_ssa::traits::*; use rustc_codegen_ssa::traits::*;
use syntax::attr; use syntax::attr;
use syntax::symbol::sym;
/// Inserts a side-effect free instruction sequence that makes sure that the /// Inserts a side-effect free instruction sequence that makes sure that the
@ -66,8 +67,7 @@ pub fn get_or_insert_gdb_debug_scripts_section_global(cx: &CodegenCx<'ll, '_>)
pub fn needs_gdb_debug_scripts_section(cx: &CodegenCx<'_, '_>) -> bool { pub fn needs_gdb_debug_scripts_section(cx: &CodegenCx<'_, '_>) -> bool {
let omit_gdb_pretty_printer_section = let omit_gdb_pretty_printer_section =
attr::contains_name(&cx.tcx.hir().krate_attrs(), attr::contains_name(&cx.tcx.hir().krate_attrs(), sym::omit_gdb_pretty_printer_section);
"omit_gdb_pretty_printer_section");
!omit_gdb_pretty_printer_section && !omit_gdb_pretty_printer_section &&
cx.sess().opts.debuginfo != DebugInfo::None && cx.sess().opts.debuginfo != DebugInfo::None &&

135
src/librustc_codegen_llvm/llvm_util.rs
View file

@ -7,6 +7,7 @@ use rustc_target::spec::MergeFunctions;
use libc::c_int; use libc::c_int;
use std::ffi::CString; use std::ffi::CString;
use syntax::feature_gate::UnstableFeatures; use syntax::feature_gate::UnstableFeatures;
use syntax::symbol::sym;
use std::str; use std::str;
use std::slice; use std::slice;
@ -93,106 +94,106 @@ unsafe fn configure_llvm(sess: &Session) {
// to LLVM or the feature detection code will walk past the end of the feature // to LLVM or the feature detection code will walk past the end of the feature
// array, leading to crashes. // array, leading to crashes.
const ARM_WHITELIST: &[(&str, Option<&str>)] = &[ const ARM_WHITELIST: &[(&str, Option<Symbol>)] = &[
("aclass", Some("arm_target_feature")), ("aclass", Some(sym::arm_target_feature)),
("mclass", Some("arm_target_feature")), ("mclass", Some(sym::arm_target_feature)),
("rclass", Some("arm_target_feature")), ("rclass", Some(sym::arm_target_feature)),
("dsp", Some("arm_target_feature")), ("dsp", Some(sym::arm_target_feature)),
("neon", Some("arm_target_feature")), ("neon", Some(sym::arm_target_feature)),
("v5te", Some("arm_target_feature")), ("v5te", Some(sym::arm_target_feature)),
("v6", Some("arm_target_feature")), ("v6", Some(sym::arm_target_feature)),
("v6k", Some("arm_target_feature")), ("v6k", Some(sym::arm_target_feature)),
("v6t2", Some("arm_target_feature")), ("v6t2", Some(sym::arm_target_feature)),
("v7", Some("arm_target_feature")), ("v7", Some(sym::arm_target_feature)),
("v8", Some("arm_target_feature")), ("v8", Some(sym::arm_target_feature)),
("vfp2", Some("arm_target_feature")), ("vfp2", Some(sym::arm_target_feature)),
("vfp3", Some("arm_target_feature")), ("vfp3", Some(sym::arm_target_feature)),
("vfp4", Some("arm_target_feature")), ("vfp4", Some(sym::arm_target_feature)),
]; ];
const AARCH64_WHITELIST: &[(&str, Option<&str>)] = &[ const AARCH64_WHITELIST: &[(&str, Option<Symbol>)] = &[
("fp", Some("aarch64_target_feature")), ("fp", Some(sym::aarch64_target_feature)),
("neon", Some("aarch64_target_feature")), ("neon", Some(sym::aarch64_target_feature)),
("sve", Some("aarch64_target_feature")), ("sve", Some(sym::aarch64_target_feature)),
("crc", Some("aarch64_target_feature")), ("crc", Some(sym::aarch64_target_feature)),
("crypto", Some("aarch64_target_feature")), ("crypto", Some(sym::aarch64_target_feature)),
("ras", Some("aarch64_target_feature")), ("ras", Some(sym::aarch64_target_feature)),
("lse", Some("aarch64_target_feature")), ("lse", Some(sym::aarch64_target_feature)),
("rdm", Some("aarch64_target_feature")), ("rdm", Some(sym::aarch64_target_feature)),
("fp16", Some("aarch64_target_feature")), ("fp16", Some(sym::aarch64_target_feature)),
("rcpc", Some("aarch64_target_feature")), ("rcpc", Some(sym::aarch64_target_feature)),
("dotprod", Some("aarch64_target_feature")), ("dotprod", Some(sym::aarch64_target_feature)),
("v8.1a", Some("aarch64_target_feature")), ("v8.1a", Some(sym::aarch64_target_feature)),
("v8.2a", Some("aarch64_target_feature")), ("v8.2a", Some(sym::aarch64_target_feature)),
("v8.3a", Some("aarch64_target_feature")), ("v8.3a", Some(sym::aarch64_target_feature)),
]; ];
const X86_WHITELIST: &[(&str, Option<&str>)] = &[ const X86_WHITELIST: &[(&str, Option<Symbol>)] = &[
("adx", Some("adx_target_feature")), ("adx", Some(sym::adx_target_feature)),
("aes", None), ("aes", None),
("avx", None), ("avx", None),
("avx2", None), ("avx2", None),
("avx512bw", Some("avx512_target_feature")), ("avx512bw", Some(sym::avx512_target_feature)),
("avx512cd", Some("avx512_target_feature")), ("avx512cd", Some(sym::avx512_target_feature)),
("avx512dq", Some("avx512_target_feature")), ("avx512dq", Some(sym::avx512_target_feature)),
("avx512er", Some("avx512_target_feature")), ("avx512er", Some(sym::avx512_target_feature)),
("avx512f", Some("avx512_target_feature")), ("avx512f", Some(sym::avx512_target_feature)),
("avx512ifma", Some("avx512_target_feature")), ("avx512ifma", Some(sym::avx512_target_feature)),
("avx512pf", Some("avx512_target_feature")), ("avx512pf", Some(sym::avx512_target_feature)),
("avx512vbmi", Some("avx512_target_feature")), ("avx512vbmi", Some(sym::avx512_target_feature)),
("avx512vl", Some("avx512_target_feature")), ("avx512vl", Some(sym::avx512_target_feature)),
("avx512vpopcntdq", Some("avx512_target_feature")), ("avx512vpopcntdq", Some(sym::avx512_target_feature)),
("bmi1", None), ("bmi1", None),
("bmi2", None), ("bmi2", None),
("cmpxchg16b", Some("cmpxchg16b_target_feature")), ("cmpxchg16b", Some(sym::cmpxchg16b_target_feature)),
("f16c", Some("f16c_target_feature")), ("f16c", Some(sym::f16c_target_feature)),
("fma", None), ("fma", None),
("fxsr", None), ("fxsr", None),
("lzcnt", None), ("lzcnt", None),
("mmx", Some("mmx_target_feature")), ("mmx", Some(sym::mmx_target_feature)),
("movbe", Some("movbe_target_feature")), ("movbe", Some(sym::movbe_target_feature)),
("pclmulqdq", None), ("pclmulqdq", None),
("popcnt", None), ("popcnt", None),
("rdrand", None), ("rdrand", None),
("rdseed", None), ("rdseed", None),
("rtm", Some("rtm_target_feature")), ("rtm", Some(sym::rtm_target_feature)),
("sha", None), ("sha", None),
("sse", None), ("sse", None),
("sse2", None), ("sse2", None),
("sse3", None), ("sse3", None),
("sse4.1", None), ("sse4.1", None),
("sse4.2", None), ("sse4.2", None),
("sse4a", Some("sse4a_target_feature")), ("sse4a", Some(sym::sse4a_target_feature)),
("ssse3", None), ("ssse3", None),
("tbm", Some("tbm_target_feature")), ("tbm", Some(sym::tbm_target_feature)),
("xsave", None), ("xsave", None),
("xsavec", None), ("xsavec", None),
("xsaveopt", None), ("xsaveopt", None),
("xsaves", None), ("xsaves", None),
]; ];
const HEXAGON_WHITELIST: &[(&str, Option<&str>)] = &[ const HEXAGON_WHITELIST: &[(&str, Option<Symbol>)] = &[
("hvx", Some("hexagon_target_feature")), ("hvx", Some(sym::hexagon_target_feature)),
("hvx-double", Some("hexagon_target_feature")), ("hvx-double", Some(sym::hexagon_target_feature)),
]; ];
const POWERPC_WHITELIST: &[(&str, Option<&str>)] = &[ const POWERPC_WHITELIST: &[(&str, Option<Symbol>)] = &[
("altivec", Some("powerpc_target_feature")), ("altivec", Some(sym::powerpc_target_feature)),
("power8-altivec", Some("powerpc_target_feature")), ("power8-altivec", Some(sym::powerpc_target_feature)),
("power9-altivec", Some("powerpc_target_feature")), ("power9-altivec", Some(sym::powerpc_target_feature)),
("power8-vector", Some("powerpc_target_feature")), ("power8-vector", Some(sym::powerpc_target_feature)),
("power9-vector", Some("powerpc_target_feature")), ("power9-vector", Some(sym::powerpc_target_feature)),
("vsx", Some("powerpc_target_feature")), ("vsx", Some(sym::powerpc_target_feature)),
]; ];
const MIPS_WHITELIST: &[(&str, Option<&str>)] = &[ const MIPS_WHITELIST: &[(&str, Option<Symbol>)] = &[
("fp64", Some("mips_target_feature")), ("fp64", Some(sym::mips_target_feature)),
("msa", Some("mips_target_feature")), ("msa", Some(sym::mips_target_feature)),
]; ];
const WASM_WHITELIST: &[(&str, Option<&str>)] = &[ const WASM_WHITELIST: &[(&str, Option<Symbol>)] = &[
("simd128", Some("wasm_target_feature")), ("simd128", Some(sym::wasm_target_feature)),
("atomics", Some("wasm_target_feature")), ("atomics", Some(sym::wasm_target_feature)),
]; ];
/// When rustdoc is running, provide a list of all known features so that all their respective /// When rustdoc is running, provide a list of all known features so that all their respective
@ -200,7 +201,7 @@ const WASM_WHITELIST: &[(&str, Option<&str>)] = &[
/// ///
/// IMPORTANT: If you're adding another whitelist to the above lists, make sure to add it to this /// IMPORTANT: If you're adding another whitelist to the above lists, make sure to add it to this
/// iterator! /// iterator!
pub fn all_known_features() -> impl Iterator<Item=(&'static str, Option<&'static str>)> { pub fn all_known_features() -> impl Iterator<Item=(&'static str, Option<Symbol>)> {
ARM_WHITELIST.iter().cloned() ARM_WHITELIST.iter().cloned()
.chain(AARCH64_WHITELIST.iter().cloned()) .chain(AARCH64_WHITELIST.iter().cloned())
.chain(X86_WHITELIST.iter().cloned()) .chain(X86_WHITELIST.iter().cloned())
@ -247,7 +248,7 @@ pub fn target_features(sess: &Session) -> Vec<Symbol> {
} }
pub fn target_feature_whitelist(sess: &Session) pub fn target_feature_whitelist(sess: &Session)
-> &'static [(&'static str, Option<&'static str>)] -> &'static [(&'static str, Option<Symbol>)]
{ {
match &*sess.target.target.arch { match &*sess.target.target.arch {
"arm" => ARM_WHITELIST, "arm" => ARM_WHITELIST,

8
src/librustc_codegen_ssa/back/write.rs
View file

@ -28,7 +28,7 @@ use rustc_target::spec::MergeFunctions;
use syntax::attr; use syntax::attr;
use syntax::ext::hygiene::Mark; use syntax::ext::hygiene::Mark;
use syntax_pos::MultiSpan; use syntax_pos::MultiSpan;
use syntax_pos::symbol::Symbol; use syntax_pos::symbol::{Symbol, sym};
use jobserver::{Client, Acquired}; use jobserver::{Client, Acquired};
use std::any::Any; use std::any::Any;
@ -382,11 +382,11 @@ pub fn start_async_codegen<B: ExtraBackendMethods>(
let sess = tcx.sess; let sess = tcx.sess;
let crate_name = tcx.crate_name(LOCAL_CRATE); let crate_name = tcx.crate_name(LOCAL_CRATE);
let crate_hash = tcx.crate_hash(LOCAL_CRATE); let crate_hash = tcx.crate_hash(LOCAL_CRATE);
let no_builtins = attr::contains_name(&tcx.hir().krate().attrs, "no_builtins"); let no_builtins = attr::contains_name(&tcx.hir().krate().attrs, sym::no_builtins);
let subsystem = attr::first_attr_value_str_by_name(&tcx.hir().krate().attrs, let subsystem = attr::first_attr_value_str_by_name(&tcx.hir().krate().attrs,
"windows_subsystem"); sym::windows_subsystem);
let windows_subsystem = subsystem.map(|subsystem| { let windows_subsystem = subsystem.map(|subsystem| {
if subsystem != "windows" && subsystem != "console" { if subsystem != sym::windows && subsystem != sym::console {
tcx.sess.fatal(&format!("invalid windows subsystem `{}`, only \ tcx.sess.fatal(&format!("invalid windows subsystem `{}`, only \
`windows` and `console` are allowed", `windows` and `console` are allowed",
subsystem)); subsystem));

6
src/librustc_codegen_ssa/mir/rvalue.rs
View file

@ -5,6 +5,7 @@ use rustc::mir;
use rustc::middle::lang_items::ExchangeMallocFnLangItem; use rustc::middle::lang_items::ExchangeMallocFnLangItem;
use rustc_apfloat::{ieee, Float, Status, Round}; use rustc_apfloat::{ieee, Float, Status, Round};
use std::{u128, i128}; use std::{u128, i128};
use syntax::symbol::sym;
use crate::base; use crate::base;
use crate::MemFlags; use crate::MemFlags;
@ -181,9 +182,8 @@ impl<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
mir::CastKind::Pointer(PointerCast::ReifyFnPointer) => { mir::CastKind::Pointer(PointerCast::ReifyFnPointer) => {
match operand.layout.ty.sty { match operand.layout.ty.sty {
ty::FnDef(def_id, substs) => { ty::FnDef(def_id, substs) => {
if bx.cx().tcx().has_attr(def_id, "rustc_args_required_const") { if bx.cx().tcx().has_attr(def_id, sym::rustc_args_required_const) {
bug!("reifying a fn ptr that requires \ bug!("reifying a fn ptr that requires const arguments");
const arguments");
} }
OperandValue::Immediate( OperandValue::Immediate(
callee::resolve_and_get_fn(bx.cx(), def_id, substs)) callee::resolve_and_get_fn(bx.cx(), def_id, substs))

3
src/librustc_codegen_utils/lib.rs
View file

@ -23,6 +23,7 @@ extern crate rustc;
use rustc::ty::TyCtxt; use rustc::ty::TyCtxt;
use rustc::hir::def_id::LOCAL_CRATE; use rustc::hir::def_id::LOCAL_CRATE;
use syntax::symbol::sym;
pub mod link; pub mod link;
pub mod codegen_backend; pub mod codegen_backend;
@ -35,7 +36,7 @@ pub mod symbol_names_test;
/// reporting an error. /// reporting an error.
pub fn check_for_rustc_errors_attr(tcx: TyCtxt<'_, '_, '_>) { pub fn check_for_rustc_errors_attr(tcx: TyCtxt<'_, '_, '_>) {
if let Some((def_id, _)) = tcx.entry_fn(LOCAL_CRATE) { if let Some((def_id, _)) = tcx.entry_fn(LOCAL_CRATE) {
if tcx.has_attr(def_id, "rustc_error") { if tcx.has_attr(def_id, sym::rustc_error) {
tcx.sess.span_fatal(tcx.def_span(def_id), "compilation successful"); tcx.sess.span_fatal(tcx.def_span(def_id), "compilation successful");
} }
} }

5
src/librustc_codegen_utils/link.rs
View file

@ -2,6 +2,7 @@ use rustc::session::config::{self, OutputFilenames, Input, OutputType};
use rustc::session::Session; use rustc::session::Session;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
use syntax::{ast, attr}; use syntax::{ast, attr};
use syntax::symbol::sym;
use syntax_pos::Span; use syntax_pos::Span;
pub fn out_filename(sess: &Session, pub fn out_filename(sess: &Session,
@ -49,13 +50,13 @@ pub fn find_crate_name(sess: Option<&Session>,
// as used. After doing this, however, we still prioritize a crate name from // as used. After doing this, however, we still prioritize a crate name from
// the command line over one found in the #[crate_name] attribute. If we // the command line over one found in the #[crate_name] attribute. If we
// find both we ensure that they're the same later on as well. // find both we ensure that they're the same later on as well.
let attr_crate_name = attr::find_by_name(attrs, "crate_name") let attr_crate_name = attr::find_by_name(attrs, sym::crate_name)
.and_then(|at| at.value_str().map(|s| (at, s))); .and_then(|at| at.value_str().map(|s| (at, s)));
if let Some(sess) = sess { if let Some(sess) = sess {
if let Some(ref s) = sess.opts.crate_name { if let Some(ref s) = sess.opts.crate_name {
if let Some((attr, name)) = attr_crate_name { if let Some((attr, name)) = attr_crate_name {
if name != &**s { if name.as_str() != *s {
let msg = format!("--crate-name and #[crate_name] are \ let msg = format!("--crate-name and #[crate_name] are \
required to match, but `{}` != `{}`", required to match, but `{}` != `{}`",
s, name); s, name);

6
src/librustc_codegen_utils/symbol_names_test.rs
View file

@ -6,11 +6,11 @@
use rustc::hir; use rustc::hir;
use rustc::ty::TyCtxt; use rustc::ty::TyCtxt;
use rustc_mir::monomorphize::Instance; use rustc_mir::monomorphize::Instance;
use syntax::symbol::{Symbol, sym};
const SYMBOL_NAME: &'static str = "rustc_symbol_name"; const SYMBOL_NAME: Symbol = sym::rustc_symbol_name;
const DEF_PATH: &'static str = "rustc_def_path"; const DEF_PATH: Symbol = sym::rustc_def_path;
pub fn report_symbol_names<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) { pub fn report_symbol_names<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
// if the `rustc_attrs` feature is not enabled, then the // if the `rustc_attrs` feature is not enabled, then the

3
src/librustc_driver/lib.rs
View file

@ -63,6 +63,7 @@ use syntax::ast;
use syntax::source_map::FileLoader; use syntax::source_map::FileLoader;
use syntax::feature_gate::{GatedCfg, UnstableFeatures}; use syntax::feature_gate::{GatedCfg, UnstableFeatures};
use syntax::parse::{self, PResult}; use syntax::parse::{self, PResult};
use syntax::symbol::sym;
use syntax_pos::{DUMMY_SP, MultiSpan, FileName}; use syntax_pos::{DUMMY_SP, MultiSpan, FileName};
pub mod pretty; pub mod pretty;
@ -669,7 +670,7 @@ impl RustcDefaultCalls {
// through to build scripts. // through to build scripts.
let value = value.as_ref().map(|s| s.as_str()); let value = value.as_ref().map(|s| s.as_str());
let value = value.as_ref().map(|s| s.as_ref()); let value = value.as_ref().map(|s| s.as_ref());
if name != "target_feature" || value != Some("crt-static") { if name != sym::target_feature || value != Some("crt-static") {
if !allow_unstable_cfg && gated_cfg.is_some() { if !allow_unstable_cfg && gated_cfg.is_some() {
return None return None
} }

9
src/librustc_incremental/assert_module_sources.rs
View file

@ -27,12 +27,13 @@ use rustc::mir::mono::CodegenUnitNameBuilder;
use rustc::ty::TyCtxt; use rustc::ty::TyCtxt;
use std::collections::BTreeSet; use std::collections::BTreeSet;
use syntax::ast; use syntax::ast;
use syntax::symbol::{Symbol, sym};
use rustc::ich::{ATTR_PARTITION_REUSED, ATTR_PARTITION_CODEGENED, use rustc::ich::{ATTR_PARTITION_REUSED, ATTR_PARTITION_CODEGENED,
ATTR_EXPECTED_CGU_REUSE}; ATTR_EXPECTED_CGU_REUSE};
const MODULE: &str = "module"; const MODULE: Symbol = sym::module;
const CFG: &str = "cfg"; const CFG: Symbol = sym::cfg;
const KIND: &str = "kind"; const KIND: Symbol = sym::kind;
pub fn assert_module_sources<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) { pub fn assert_module_sources<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
tcx.dep_graph.with_ignore(|| { tcx.dep_graph.with_ignore(|| {
@ -146,7 +147,7 @@ impl<'a, 'tcx> AssertModuleSource<'a, 'tcx> {
comp_kind); comp_kind);
} }
fn field(&self, attr: &ast::Attribute, name: &str) -> ast::Name { fn field(&self, attr: &ast::Attribute, name: Symbol) -> ast::Name {
for item in attr.meta_item_list().unwrap_or_else(Vec::new) { for item in attr.meta_item_list().unwrap_or_else(Vec::new) {
if item.check_name(name) { if item.check_name(name) {
if let Some(value) = item.value_str() { if let Some(value) = item.value_str() {

15
src/librustc_incremental/persist/dirty_clean.rs
View file

@ -23,14 +23,15 @@ use rustc::hir::def_id::DefId;
use rustc::hir::itemlikevisit::ItemLikeVisitor; use rustc::hir::itemlikevisit::ItemLikeVisitor;
use rustc::hir::intravisit; use rustc::hir::intravisit;
use rustc::ich::{ATTR_DIRTY, ATTR_CLEAN}; use rustc::ich::{ATTR_DIRTY, ATTR_CLEAN};
use syntax::ast::{self, Attribute, NestedMetaItem};
use rustc_data_structures::fx::FxHashSet;
use syntax_pos::Span;
use rustc::ty::TyCtxt; use rustc::ty::TyCtxt;
use rustc_data_structures::fx::FxHashSet;
use syntax::ast::{self, Attribute, NestedMetaItem};
use syntax::symbol::{Symbol, sym};
use syntax_pos::Span;
const EXCEPT: &str = "except"; const EXCEPT: Symbol = sym::except;
const LABEL: &str = "label"; const LABEL: Symbol = sym::label;
const CFG: &str = "cfg"; const CFG: Symbol = sym::cfg;
// Base and Extra labels to build up the labels // Base and Extra labels to build up the labels
@ -591,7 +592,7 @@ fn expect_associated_value(tcx: TyCtxt<'_, '_, '_>, item: &NestedMetaItem) -> as
// nodes. // nodes.
pub struct FindAllAttrs<'a, 'tcx:'a> { pub struct FindAllAttrs<'a, 'tcx:'a> {
tcx: TyCtxt<'a, 'tcx, 'tcx>, tcx: TyCtxt<'a, 'tcx, 'tcx>,
attr_names: Vec<&'static str>, attr_names: Vec<Symbol>,
found_attrs: Vec<&'tcx Attribute>, found_attrs: Vec<&'tcx Attribute>,
} }

2
src/librustc_interface/passes.rs
View file

@ -230,7 +230,7 @@ impl BoxedResolver {
pub struct PluginInfo { pub struct PluginInfo {
syntax_exts: Vec<NamedSyntaxExtension>, syntax_exts: Vec<NamedSyntaxExtension>,
attributes: Vec<(String, AttributeType)>, attributes: Vec<(Symbol, AttributeType)>,
} }
pub fn register_plugins<'a>( pub fn register_plugins<'a>(

3
src/librustc_interface/proc_macro_decls.rs
View file

@ -4,6 +4,7 @@ use rustc::hir;
use rustc::ty::TyCtxt; use rustc::ty::TyCtxt;
use rustc::ty::query::Providers; use rustc::ty::query::Providers;
use syntax::attr; use syntax::attr;
use syntax::symbol::sym;
pub fn find<'tcx>(tcx: TyCtxt<'_, 'tcx, 'tcx>) -> Option<DefId> { pub fn find<'tcx>(tcx: TyCtxt<'_, 'tcx, 'tcx>) -> Option<DefId> {
tcx.proc_macro_decls_static(LOCAL_CRATE) tcx.proc_macro_decls_static(LOCAL_CRATE)
@ -27,7 +28,7 @@ struct Finder {
impl<'v> ItemLikeVisitor<'v> for Finder { impl<'v> ItemLikeVisitor<'v> for Finder {
fn visit_item(&mut self, item: &hir::Item) { fn visit_item(&mut self, item: &hir::Item) {
if attr::contains_name(&item.attrs, "rustc_proc_macro_decls") { if attr::contains_name(&item.attrs, sym::rustc_proc_macro_decls) {
self.decls = Some(item.hir_id); self.decls = Some(item.hir_id);
} }
} }

34
src/librustc_interface/util.rs
View file

@ -35,7 +35,7 @@ use syntax::mut_visit::{*, MutVisitor, visit_clobber};
use syntax::ast::BlockCheckMode; use syntax::ast::BlockCheckMode;
use syntax::util::lev_distance::find_best_match_for_name; use syntax::util::lev_distance::find_best_match_for_name;
use syntax::source_map::{FileLoader, RealFileLoader, SourceMap}; use syntax::source_map::{FileLoader, RealFileLoader, SourceMap};
use syntax::symbol::Symbol; use syntax::symbol::{Symbol, sym};
use syntax::{self, ast, attr}; use syntax::{self, ast, attr};
#[cfg(not(parallel_compiler))] #[cfg(not(parallel_compiler))]
use std::{thread, panic}; use std::{thread, panic};
@ -495,24 +495,24 @@ pub fn collect_crate_types(session: &Session, attrs: &[ast::Attribute]) -> Vec<c
let attr_types: Vec<config::CrateType> = attrs let attr_types: Vec<config::CrateType> = attrs
.iter() .iter()
.filter_map(|a| { .filter_map(|a| {
if a.check_name("crate_type") { if a.check_name(sym::crate_type) {
match a.value_str() { match a.value_str() {
Some(ref n) if *n == "rlib" => Some(config::CrateType::Rlib), Some(sym::rlib) => Some(config::CrateType::Rlib),
Some(ref n) if *n == "dylib" => Some(config::CrateType::Dylib), Some(sym::dylib) => Some(config::CrateType::Dylib),
Some(ref n) if *n == "cdylib" => Some(config::CrateType::Cdylib), Some(sym::cdylib) => Some(config::CrateType::Cdylib),
Some(ref n) if *n == "lib" => Some(config::default_lib_output()), Some(sym::lib) => Some(config::default_lib_output()),
Some(ref n) if *n == "staticlib" => Some(config::CrateType::Staticlib), Some(sym::staticlib) => Some(config::CrateType::Staticlib),
Some(ref n) if *n == "proc-macro" => Some(config::CrateType::ProcMacro), Some(sym::proc_dash_macro) => Some(config::CrateType::ProcMacro),
Some(ref n) if *n == "bin" => Some(config::CrateType::Executable), Some(sym::bin) => Some(config::CrateType::Executable),
Some(ref n) => { Some(n) => {
let crate_types = vec![ let crate_types = vec![
Symbol::intern("rlib"), sym::rlib,
Symbol::intern("dylib"), sym::dylib,
Symbol::intern("cdylib"), sym::cdylib,
Symbol::intern("lib"), sym::lib,
Symbol::intern("staticlib"), sym::staticlib,
Symbol::intern("proc-macro"), sym::proc_dash_macro,
Symbol::intern("bin") sym::bin
]; ];
if let ast::MetaItemKind::NameValue(spanned) = a.meta().unwrap().node { if let ast::MetaItemKind::NameValue(spanned) = a.meta().unwrap().node {

22
src/librustc_lint/builtin.rs
View file

@ -42,7 +42,7 @@ use syntax::edition::Edition;
use syntax::feature_gate::{AttributeGate, AttributeTemplate, AttributeType}; use syntax::feature_gate::{AttributeGate, AttributeTemplate, AttributeType};
use syntax::feature_gate::{Stability, deprecated_attributes}; use syntax::feature_gate::{Stability, deprecated_attributes};
use syntax_pos::{BytePos, Span, SyntaxContext}; use syntax_pos::{BytePos, Span, SyntaxContext};
use syntax::symbol::{Symbol, keywords}; use syntax::symbol::{Symbol, keywords, sym};
use syntax::errors::{Applicability, DiagnosticBuilder}; use syntax::errors::{Applicability, DiagnosticBuilder};
use syntax::print::pprust::expr_to_string; use syntax::print::pprust::expr_to_string;
use syntax::visit::FnKind; use syntax::visit::FnKind;
@ -207,7 +207,7 @@ impl UnsafeCode {
impl EarlyLintPass for UnsafeCode { impl EarlyLintPass for UnsafeCode {
fn check_attribute(&mut self, cx: &EarlyContext<'_>, attr: &ast::Attribute) { fn check_attribute(&mut self, cx: &EarlyContext<'_>, attr: &ast::Attribute) {
if attr.check_name("allow_internal_unsafe") { if attr.check_name(sym::allow_internal_unsafe) {
self.report_unsafe(cx, attr.span, "`allow_internal_unsafe` allows defining \ self.report_unsafe(cx, attr.span, "`allow_internal_unsafe` allows defining \
macros using unsafe without triggering \ macros using unsafe without triggering \
the `unsafe_code` lint at their call site"); the `unsafe_code` lint at their call site");
@ -285,7 +285,7 @@ pub struct MissingDoc {
impl_lint_pass!(MissingDoc => [MISSING_DOCS]); impl_lint_pass!(MissingDoc => [MISSING_DOCS]);
fn has_doc(attr: &ast::Attribute) -> bool { fn has_doc(attr: &ast::Attribute) -> bool {
if !attr.check_name("doc") { if !attr.check_name(sym::doc) {
return false; return false;
} }
@ -295,7 +295,7 @@ fn has_doc(attr: &ast::Attribute) -> bool {
if let Some(list) = attr.meta_item_list() { if let Some(list) = attr.meta_item_list() {
for meta in list { for meta in list {
if meta.check_name("include") || meta.check_name("hidden") { if meta.check_name(sym::include) || meta.check_name(sym::hidden) {
return true; return true;
} }
} }
@ -355,10 +355,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc {
fn enter_lint_attrs(&mut self, _: &LateContext<'_, '_>, attrs: &[ast::Attribute]) { fn enter_lint_attrs(&mut self, _: &LateContext<'_, '_>, attrs: &[ast::Attribute]) {
let doc_hidden = self.doc_hidden() || let doc_hidden = self.doc_hidden() ||
attrs.iter().any(|attr| { attrs.iter().any(|attr| {
attr.check_name("doc") && attr.check_name(sym::doc) &&
match attr.meta_item_list() { match attr.meta_item_list() {
None => false, None => false,
Some(l) => attr::list_contains_name(&l, "hidden"), Some(l) => attr::list_contains_name(&l, sym::hidden),
} }
}); });
self.doc_hidden_stack.push(doc_hidden); self.doc_hidden_stack.push(doc_hidden);
@ -723,7 +723,7 @@ impl UnusedDocComment {
let span = sugared_span.take().unwrap_or_else(|| attr.span); let span = sugared_span.take().unwrap_or_else(|| attr.span);
if attr.check_name("doc") { if attr.check_name(sym::doc) {
let mut err = cx.struct_span_lint(UNUSED_DOC_COMMENTS, span, "unused doc comment"); let mut err = cx.struct_span_lint(UNUSED_DOC_COMMENTS, span, "unused doc comment");
err.span_label( err.span_label(
@ -829,7 +829,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for InvalidNoMangleItems {
fn check_item(&mut self, cx: &LateContext<'_, '_>, it: &hir::Item) { fn check_item(&mut self, cx: &LateContext<'_, '_>, it: &hir::Item) {
match it.node { match it.node {
hir::ItemKind::Fn(.., ref generics, _) => { hir::ItemKind::Fn(.., ref generics, _) => {
if let Some(no_mangle_attr) = attr::find_by_name(&it.attrs, "no_mangle") { if let Some(no_mangle_attr) = attr::find_by_name(&it.attrs, sym::no_mangle) {
for param in &generics.params { for param in &generics.params {
match param.kind { match param.kind {
GenericParamKind::Lifetime { .. } => {} GenericParamKind::Lifetime { .. } => {}
@ -856,7 +856,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for InvalidNoMangleItems {
} }
} }
hir::ItemKind::Const(..) => { hir::ItemKind::Const(..) => {
if attr::contains_name(&it.attrs, "no_mangle") { if attr::contains_name(&it.attrs, sym::no_mangle) {
// Const items do not refer to a particular location in memory, and therefore // Const items do not refer to a particular location in memory, and therefore
// don't have anything to attach a symbol to // don't have anything to attach a symbol to
let msg = "const items should never be #[no_mangle]"; let msg = "const items should never be #[no_mangle]";
@ -947,7 +947,7 @@ declare_lint_pass!(
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnstableFeatures { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnstableFeatures {
fn check_attribute(&mut self, ctx: &LateContext<'_, '_>, attr: &ast::Attribute) { fn check_attribute(&mut self, ctx: &LateContext<'_, '_>, attr: &ast::Attribute) {
if attr.check_name("feature") { if attr.check_name(sym::feature) {
if let Some(items) = attr.meta_item_list() { if let Some(items) = attr.meta_item_list() {
for item in items { for item in items {
ctx.span_lint(UNSTABLE_FEATURES, item.span(), "unstable feature"); ctx.span_lint(UNSTABLE_FEATURES, item.span(), "unstable feature");
@ -1382,7 +1382,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnnameableTestItems {
return; return;
} }
if let Some(attr) = attr::find_by_name(&it.attrs, "rustc_test_marker") { if let Some(attr) = attr::find_by_name(&it.attrs, sym::rustc_test_marker) {
cx.struct_span_lint( cx.struct_span_lint(
UNNAMEABLE_TEST_ITEMS, UNNAMEABLE_TEST_ITEMS,
attr.span, attr.span,

7
src/librustc_lint/nonstandard_style.rs
View file

@ -9,6 +9,7 @@ use lint::{EarlyLintPass, LintPass, LateLintPass};
use syntax::ast; use syntax::ast;
use syntax::attr; use syntax::attr;
use syntax::errors::Applicability; use syntax::errors::Applicability;
use syntax::symbol::sym;
use syntax_pos::{BytePos, symbol::Ident, Span}; use syntax_pos::{BytePos, symbol::Ident, Span};
#[derive(PartialEq)] #[derive(PartialEq)]
@ -253,7 +254,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonSnakeCase {
let crate_ident = if let Some(name) = &cx.tcx.sess.opts.crate_name { let crate_ident = if let Some(name) = &cx.tcx.sess.opts.crate_name {
Some(Ident::from_str(name)) Some(Ident::from_str(name))
} else { } else {
attr::find_by_name(&cx.tcx.hir().attrs_by_hir_id(hir::CRATE_HIR_ID), "crate_name") attr::find_by_name(&cx.tcx.hir().attrs_by_hir_id(hir::CRATE_HIR_ID), sym::crate_name)
.and_then(|attr| attr.meta()) .and_then(|attr| attr.meta())
.and_then(|meta| { .and_then(|meta| {
meta.name_value_literal().and_then(|lit| { meta.name_value_literal().and_then(|lit| {
@ -315,7 +316,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonSnakeCase {
} }
FnKind::ItemFn(ident, _, header, _, attrs) => { FnKind::ItemFn(ident, _, header, _, attrs) => {
// Skip foreign-ABI #[no_mangle] functions (Issue #31924) // Skip foreign-ABI #[no_mangle] functions (Issue #31924)
if header.abi != Abi::Rust && attr::contains_name(attrs, "no_mangle") { if header.abi != Abi::Rust && attr::contains_name(attrs, sym::no_mangle) {
return; return;
} }
self.check_snake_case(cx, "function", ident); self.check_snake_case(cx, "function", ident);
@ -390,7 +391,7 @@ impl NonUpperCaseGlobals {
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonUpperCaseGlobals { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonUpperCaseGlobals {
fn check_item(&mut self, cx: &LateContext<'_, '_>, it: &hir::Item) { fn check_item(&mut self, cx: &LateContext<'_, '_>, it: &hir::Item) {
match it.node { match it.node {
hir::ItemKind::Static(..) if !attr::contains_name(&it.attrs, "no_mangle") => { hir::ItemKind::Static(..) if !attr::contains_name(&it.attrs, sym::no_mangle) => {
NonUpperCaseGlobals::check_upper_case(cx, "static variable", &it.ident); NonUpperCaseGlobals::check_upper_case(cx, "static variable", &it.ident);
} }
hir::ItemKind::Const(..) => { hir::ItemKind::Const(..) => {

10
src/librustc_lint/unused.rs
View file

@ -12,7 +12,7 @@ use syntax::attr;
use syntax::errors::Applicability; use syntax::errors::Applicability;
use syntax::feature_gate::{AttributeType, BuiltinAttribute, BUILTIN_ATTRIBUTE_MAP}; use syntax::feature_gate::{AttributeType, BuiltinAttribute, BUILTIN_ATTRIBUTE_MAP};
use syntax::print::pprust; use syntax::print::pprust;
use syntax::symbol::keywords; use syntax::symbol::{keywords, sym};
use syntax::symbol::Symbol; use syntax::symbol::Symbol;
use syntax::util::parser; use syntax::util::parser;
use syntax_pos::Span; use syntax_pos::Span;
@ -170,7 +170,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedResults {
descr_post_path: &str, descr_post_path: &str,
) -> bool { ) -> bool {
for attr in cx.tcx.get_attrs(def_id).iter() { for attr in cx.tcx.get_attrs(def_id).iter() {
if attr.check_name("must_use") { if attr.check_name(sym::must_use) {
let msg = format!("unused {}`{}`{} that must be used", let msg = format!("unused {}`{}`{} that must be used",
descr_pre_path, cx.tcx.def_path_str(def_id), descr_post_path); descr_pre_path, cx.tcx.def_path_str(def_id), descr_post_path);
let mut err = cx.struct_span_lint(UNUSED_MUST_USE, sp, &msg); let mut err = cx.struct_span_lint(UNUSED_MUST_USE, sp, &msg);
@ -243,8 +243,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedAttributes {
} }
let plugin_attributes = cx.sess().plugin_attributes.borrow_mut(); let plugin_attributes = cx.sess().plugin_attributes.borrow_mut();
for &(ref name, ty) in plugin_attributes.iter() { for &(name, ty) in plugin_attributes.iter() {
if ty == AttributeType::Whitelisted && attr.check_name(&**name) { if ty == AttributeType::Whitelisted && attr.check_name(name) {
debug!("{:?} (plugin attr) is whitelisted with ty {:?}", name, ty); debug!("{:?} (plugin attr) is whitelisted with ty {:?}", name, ty);
break; break;
} }
@ -262,7 +262,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedAttributes {
// Has a plugin registered this attribute as one that must be used at // Has a plugin registered this attribute as one that must be used at
// the crate level? // the crate level?
let plugin_crate = plugin_attributes.iter() let plugin_crate = plugin_attributes.iter()
.find(|&&(ref x, t)| name == x.as_str() && AttributeType::CrateLevel == t) .find(|&&(x, t)| name == x && AttributeType::CrateLevel == t)
.is_some(); .is_some();
if known_crate || plugin_crate { if known_crate || plugin_crate {
let msg = match attr.style { let msg = match attr.style {

43
src/librustc_macros/src/symbols.rs
View file

@ -11,7 +11,7 @@ use quote::quote;
#[allow(non_camel_case_types)] #[allow(non_camel_case_types)]
mod kw { mod kw {
syn::custom_keyword!(Keywords); syn::custom_keyword!(Keywords);
syn::custom_keyword!(Other); syn::custom_keyword!(Symbols);
} }
struct Keyword { struct Keyword {
@ -33,14 +33,24 @@ impl Parse for Keyword {
} }
} }
struct Symbol(Ident); struct Symbol {
name: Ident,
value: Option<LitStr>,
}
impl Parse for Symbol { impl Parse for Symbol {
fn parse(input: ParseStream<'_>) -> Result<Self> { fn parse(input: ParseStream<'_>) -> Result<Self> {
let ident: Ident = input.parse()?; let name = input.parse()?;
let value = match input.parse::<Token![:]>() {
Ok(_) => Some(input.parse()?),
Err(_) => None,
};
input.parse::<Token![,]>()?; input.parse::<Token![,]>()?;
Ok(Symbol(ident)) Ok(Symbol {
name,
value,
})
} }
} }
@ -69,7 +79,7 @@ impl Parse for Input {
braced!(content in input); braced!(content in input);
let keywords = content.parse()?; let keywords = content.parse()?;
input.parse::<kw::Other>()?; input.parse::<kw::Symbols>()?;
let content; let content;
braced!(content in input); braced!(content in input);
let symbols = content.parse()?; let symbols = content.parse()?;
@ -116,19 +126,22 @@ pub fn symbols(input: TokenStream) -> TokenStream {
} }
for symbol in &input.symbols.0 { for symbol in &input.symbols.0 {
let value = &symbol.0; let name = &symbol.name;
let value_str = value.to_string(); let value = match &symbol.value {
check_dup(&value_str); Some(value) => value.value(),
None => name.to_string(),
};
check_dup(&value);
prefill_stream.extend(quote! { prefill_stream.extend(quote! {
#value_str, #value,
}); });
symbols_stream.extend(quote! { symbols_stream.extend(quote! {
pub const #value: Symbol = Symbol::new(#counter); pub const #name: Symbol = Symbol::new(#counter);
}); });
counter += 1; counter += 1;
} }
TokenStream::from(quote! { let tt = TokenStream::from(quote! {
macro_rules! keywords { macro_rules! keywords {
() => { () => {
#keyword_stream #keyword_stream
@ -159,5 +172,11 @@ pub fn symbols(input: TokenStream) -> TokenStream {
]) ])
} }
} }
}) });
// To see the generated code generated, uncomment this line, recompile, and
// run the resulting output through `rustfmt`.
//eprintln!("{}", tt);
tt
} }

17
src/librustc_metadata/creader.rs
View file

@ -27,7 +27,7 @@ use std::{cmp, fs};
use syntax::ast; use syntax::ast;
use syntax::attr; use syntax::attr;
use syntax::ext::base::SyntaxExtension; use syntax::ext::base::SyntaxExtension;
use syntax::symbol::Symbol; use syntax::symbol::{Symbol, sym};
use syntax::visit; use syntax::visit;
use syntax::{span_err, span_fatal}; use syntax::{span_err, span_fatal};
use syntax_pos::{Span, DUMMY_SP}; use syntax_pos::{Span, DUMMY_SP};
@ -650,9 +650,8 @@ impl<'a> CrateLoader<'a> {
/// SVH and DefIndex of the registrar function. /// SVH and DefIndex of the registrar function.
pub fn find_plugin_registrar(&mut self, pub fn find_plugin_registrar(&mut self,
span: Span, span: Span,
name: &str) name: Symbol)
-> Option<(PathBuf, CrateDisambiguator)> { -> Option<(PathBuf, CrateDisambiguator)> {
let name = Symbol::intern(name);
let ekrate = self.read_extension_crate(span, name, name); let ekrate = self.read_extension_crate(span, name, name);
if ekrate.target_only { if ekrate.target_only {
@ -704,7 +703,7 @@ impl<'a> CrateLoader<'a> {
let desired_strategy = self.sess.panic_strategy(); let desired_strategy = self.sess.panic_strategy();
let mut runtime_found = false; let mut runtime_found = false;
let mut needs_panic_runtime = attr::contains_name(&krate.attrs, let mut needs_panic_runtime = attr::contains_name(&krate.attrs,
"needs_panic_runtime"); sym::needs_panic_runtime);
self.cstore.iter_crate_data(|cnum, data| { self.cstore.iter_crate_data(|cnum, data| {
needs_panic_runtime = needs_panic_runtime || needs_panic_runtime = needs_panic_runtime ||
@ -837,7 +836,7 @@ impl<'a> CrateLoader<'a> {
let mut uses_std = false; let mut uses_std = false;
self.cstore.iter_crate_data(|_, data| { self.cstore.iter_crate_data(|_, data| {
if data.name == "std" { if data.name == sym::std {
uses_std = true; uses_std = true;
} }
}); });
@ -898,7 +897,7 @@ impl<'a> CrateLoader<'a> {
// about through the `#![needs_allocator]` attribute and is typically // about through the `#![needs_allocator]` attribute and is typically
// written down in liballoc. // written down in liballoc.
let mut needs_allocator = attr::contains_name(&krate.attrs, let mut needs_allocator = attr::contains_name(&krate.attrs,
"needs_allocator"); sym::needs_allocator);
self.cstore.iter_crate_data(|_, data| { self.cstore.iter_crate_data(|_, data| {
needs_allocator = needs_allocator || data.root.needs_allocator; needs_allocator = needs_allocator || data.root.needs_allocator;
}); });
@ -964,7 +963,7 @@ impl<'a> CrateLoader<'a> {
// allocator. At this point our allocator request is typically fulfilled // allocator. At this point our allocator request is typically fulfilled
// by the standard library, denoted by the `#![default_lib_allocator]` // by the standard library, denoted by the `#![default_lib_allocator]`
// attribute. // attribute.
let mut has_default = attr::contains_name(&krate.attrs, "default_lib_allocator"); let mut has_default = attr::contains_name(&krate.attrs, sym::default_lib_allocator);
self.cstore.iter_crate_data(|_, data| { self.cstore.iter_crate_data(|_, data| {
if data.root.has_default_lib_allocator { if data.root.has_default_lib_allocator {
has_default = true; has_default = true;
@ -987,7 +986,7 @@ impl<'a> CrateLoader<'a> {
impl<'ast> visit::Visitor<'ast> for Finder { impl<'ast> visit::Visitor<'ast> for Finder {
fn visit_item(&mut self, i: &'ast ast::Item) { fn visit_item(&mut self, i: &'ast ast::Item) {
if attr::contains_name(&i.attrs, "global_allocator") { if attr::contains_name(&i.attrs, sym::global_allocator) {
self.0 = true; self.0 = true;
} }
visit::walk_item(self, i) visit::walk_item(self, i)
@ -1065,7 +1064,7 @@ impl<'a> CrateLoader<'a> {
} }
None => item.ident.name, None => item.ident.name,
}; };
let dep_kind = if attr::contains_name(&item.attrs, "no_link") { let dep_kind = if attr::contains_name(&item.attrs, sym::no_link) {
DepKind::UnexportedMacrosOnly DepKind::UnexportedMacrosOnly
} else { } else {
DepKind::Explicit DepKind::Explicit

4
src/librustc_metadata/cstore_impl.rs
View file

@ -31,7 +31,7 @@ use syntax::source_map;
use syntax::edition::Edition; use syntax::edition::Edition;
use syntax::parse::source_file_to_stream; use syntax::parse::source_file_to_stream;
use syntax::parse::parser::emit_unclosed_delims; use syntax::parse::parser::emit_unclosed_delims;
use syntax::symbol::Symbol; use syntax::symbol::{Symbol, sym};
use syntax_pos::{Span, NO_EXPANSION, FileName}; use syntax_pos::{Span, NO_EXPANSION, FileName};
use rustc_data_structures::bit_set::BitSet; use rustc_data_structures::bit_set::BitSet;
@ -432,7 +432,7 @@ impl cstore::CStore {
let data = self.get_crate_data(id.krate); let data = self.get_crate_data(id.krate);
if let Some(ref proc_macros) = data.proc_macros { if let Some(ref proc_macros) = data.proc_macros {
return LoadedMacro::ProcMacro(proc_macros[id.index.to_proc_macro_index()].1.clone()); return LoadedMacro::ProcMacro(proc_macros[id.index.to_proc_macro_index()].1.clone());
} else if data.name == "proc_macro" && data.item_name(id.index) == "quote" { } else if data.name == sym::proc_macro && data.item_name(id.index) == "quote" {
use syntax::ext::base::SyntaxExtension; use syntax::ext::base::SyntaxExtension;
use syntax_ext::proc_macro_impl::BangProcMacro; use syntax_ext::proc_macro_impl::BangProcMacro;

4
src/librustc_metadata/decoder.rs
View file

@ -29,7 +29,7 @@ use rustc_serialize::{Decodable, Decoder, SpecializedDecoder, opaque};
use syntax::attr; use syntax::attr;
use syntax::ast::{self, Ident}; use syntax::ast::{self, Ident};
use syntax::source_map; use syntax::source_map;
use syntax::symbol::InternedString; use syntax::symbol::{InternedString, sym};
use syntax::ext::base::{MacroKind, SyntaxExtension}; use syntax::ext::base::{MacroKind, SyntaxExtension};
use syntax::ext::hygiene::Mark; use syntax::ext::hygiene::Mark;
use syntax_pos::{self, Span, BytePos, Pos, DUMMY_SP, NO_EXPANSION}; use syntax_pos::{self, Span, BytePos, Pos, DUMMY_SP, NO_EXPANSION};
@ -841,7 +841,7 @@ impl<'a, 'tcx> CrateMetadata {
// for other constructors correct visibilities // for other constructors correct visibilities
// were already encoded in metadata. // were already encoded in metadata.
let attrs = self.get_item_attrs(def_id.index, sess); let attrs = self.get_item_attrs(def_id.index, sess);
if attr::contains_name(&attrs, "non_exhaustive") { if attr::contains_name(&attrs, sym::non_exhaustive) {
let crate_def_id = self.local_def_id(CRATE_DEF_INDEX); let crate_def_id = self.local_def_id(CRATE_DEF_INDEX);
vis = ty::Visibility::Restricted(crate_def_id); vis = ty::Visibility::Restricted(crate_def_id);
} }

18
src/librustc_metadata/encoder.rs
View file

@ -33,7 +33,7 @@ use std::u32;
use syntax::ast; use syntax::ast;
use syntax::attr; use syntax::attr;
use syntax::source_map::Spanned; use syntax::source_map::Spanned;
use syntax::symbol::keywords; use syntax::symbol::{keywords, sym};
use syntax_pos::{self, hygiene, FileName, SourceFile, Span}; use syntax_pos::{self, hygiene, FileName, SourceFile, Span};
use log::{debug, trace}; use log::{debug, trace};
@ -469,7 +469,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
let attrs = tcx.hir().krate_attrs(); let attrs = tcx.hir().krate_attrs();
let is_proc_macro = tcx.sess.crate_types.borrow().contains(&CrateType::ProcMacro); let is_proc_macro = tcx.sess.crate_types.borrow().contains(&CrateType::ProcMacro);
let has_default_lib_allocator = attr::contains_name(&attrs, "default_lib_allocator"); let has_default_lib_allocator = attr::contains_name(&attrs, sym::default_lib_allocator);
let has_global_allocator = *tcx.sess.has_global_allocator.get(); let has_global_allocator = *tcx.sess.has_global_allocator.get();
let has_panic_handler = *tcx.sess.has_panic_handler.try_get().unwrap_or(&false); let has_panic_handler = *tcx.sess.has_panic_handler.try_get().unwrap_or(&false);
@ -496,13 +496,13 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
} else { } else {
None None
}, },
compiler_builtins: attr::contains_name(&attrs, "compiler_builtins"), compiler_builtins: attr::contains_name(&attrs, sym::compiler_builtins),
needs_allocator: attr::contains_name(&attrs, "needs_allocator"), needs_allocator: attr::contains_name(&attrs, sym::needs_allocator),
needs_panic_runtime: attr::contains_name(&attrs, "needs_panic_runtime"), needs_panic_runtime: attr::contains_name(&attrs, sym::needs_panic_runtime),
no_builtins: attr::contains_name(&attrs, "no_builtins"), no_builtins: attr::contains_name(&attrs, sym::no_builtins),
panic_runtime: attr::contains_name(&attrs, "panic_runtime"), panic_runtime: attr::contains_name(&attrs, sym::panic_runtime),
profiler_runtime: attr::contains_name(&attrs, "profiler_runtime"), profiler_runtime: attr::contains_name(&attrs, sym::profiler_runtime),
sanitizer_runtime: attr::contains_name(&attrs, "sanitizer_runtime"), sanitizer_runtime: attr::contains_name(&attrs, sym::sanitizer_runtime),
crate_deps, crate_deps,
dylib_dependency_formats, dylib_dependency_formats,

5
src/librustc_metadata/link_args.rs
View file

@ -2,6 +2,7 @@ use rustc::hir::itemlikevisit::ItemLikeVisitor;
use rustc::hir; use rustc::hir;
use rustc::ty::TyCtxt; use rustc::ty::TyCtxt;
use rustc_target::spec::abi::Abi; use rustc_target::spec::abi::Abi;
use syntax::symbol::sym;
pub fn collect<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Vec<String> { pub fn collect<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Vec<String> {
let mut collector = Collector { let mut collector = Collector {
@ -10,7 +11,7 @@ pub fn collect<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Vec<String> {
tcx.hir().krate().visit_all_item_likes(&mut collector); tcx.hir().krate().visit_all_item_likes(&mut collector);
for attr in tcx.hir().krate().attrs.iter() { for attr in tcx.hir().krate().attrs.iter() {
if attr.path == "link_args" { if attr.path == sym::link_args {
if let Some(linkarg) = attr.value_str() { if let Some(linkarg) = attr.value_str() {
collector.add_link_args(&linkarg.as_str()); collector.add_link_args(&linkarg.as_str());
} }
@ -37,7 +38,7 @@ impl<'tcx> ItemLikeVisitor<'tcx> for Collector {
} }
// First, add all of the custom #[link_args] attributes // First, add all of the custom #[link_args] attributes
for m in it.attrs.iter().filter(|a| a.check_name("link_args")) { for m in it.attrs.iter().filter(|a| a.check_name(sym::link_args)) {
if let Some(linkarg) = m.value_str() { if let Some(linkarg) = m.value_str() {
self.add_link_args(&linkarg.as_str()); self.add_link_args(&linkarg.as_str());
} }

4
src/librustc_metadata/locator.rs
View file

@ -225,7 +225,7 @@ use rustc::session::search_paths::PathKind;
use rustc::util::nodemap::FxHashMap; use rustc::util::nodemap::FxHashMap;
use errors::DiagnosticBuilder; use errors::DiagnosticBuilder;
use syntax::symbol::Symbol; use syntax::symbol::{Symbol, sym};
use syntax::struct_span_err; use syntax::struct_span_err;
use syntax_pos::Span; use syntax_pos::Span;
use rustc_target::spec::{Target, TargetTriple}; use rustc_target::spec::{Target, TargetTriple};
@ -408,7 +408,7 @@ impl<'a> Context<'a> {
self.ident, self.ident,
add); add);
if (self.ident == "std" || self.ident == "core") if (self.ident == sym::std || self.ident == sym::core)
&& self.triple != TargetTriple::from_triple(config::host_triple()) { && self.triple != TargetTriple::from_triple(config::host_triple()) {
err.note(&format!("the `{}` target may not be installed", self.triple)); err.note(&format!("the `{}` target may not be installed", self.triple));
} }

20
src/librustc_metadata/native_libs.rs
View file

@ -8,7 +8,7 @@ use rustc_target::spec::abi::Abi;
use syntax::attr; use syntax::attr;
use syntax::source_map::Span; use syntax::source_map::Span;
use syntax::feature_gate::{self, GateIssue}; use syntax::feature_gate::{self, GateIssue};
use syntax::symbol::Symbol; use syntax::symbol::{Symbol, sym};
use syntax::{span_err, struct_span_err}; use syntax::{span_err, struct_span_err};
pub fn collect<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Vec<NativeLibrary> { pub fn collect<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Vec<NativeLibrary> {
@ -47,7 +47,7 @@ impl<'a, 'tcx> ItemLikeVisitor<'tcx> for Collector<'a, 'tcx> {
} }
// Process all of the #[link(..)]-style arguments // Process all of the #[link(..)]-style arguments
for m in it.attrs.iter().filter(|a| a.check_name("link")) { for m in it.attrs.iter().filter(|a| a.check_name(sym::link)) {
let items = match m.meta_item_list() { let items = match m.meta_item_list() {
Some(item) => item, Some(item) => item,
None => continue, None => continue,
@ -62,7 +62,7 @@ impl<'a, 'tcx> ItemLikeVisitor<'tcx> for Collector<'a, 'tcx> {
let mut kind_specified = false; let mut kind_specified = false;
for item in items.iter() { for item in items.iter() {
if item.check_name("kind") { if item.check_name(sym::kind) {
kind_specified = true; kind_specified = true;
let kind = match item.value_str() { let kind = match item.value_str() {
Some(name) => name, Some(name) => name,
@ -81,9 +81,9 @@ impl<'a, 'tcx> ItemLikeVisitor<'tcx> for Collector<'a, 'tcx> {
cstore::NativeUnknown cstore::NativeUnknown
} }
}; };
} else if item.check_name("name") { } else if item.check_name(sym::name) {
lib.name = item.value_str(); lib.name = item.value_str();
} else if item.check_name("cfg") { } else if item.check_name(sym::cfg) {
let cfg = match item.meta_item_list() { let cfg = match item.meta_item_list() {
Some(list) => list, Some(list) => list,
None => continue, // skip like historical compilers None => continue, // skip like historical compilers
@ -98,7 +98,7 @@ impl<'a, 'tcx> ItemLikeVisitor<'tcx> for Collector<'a, 'tcx> {
} else { } else {
self.tcx.sess.span_err(cfg[0].span(), "invalid argument for `cfg(..)`"); self.tcx.sess.span_err(cfg[0].span(), "invalid argument for `cfg(..)`");
} }
} else if item.check_name("wasm_import_module") { } else if item.check_name(sym::wasm_import_module) {
match item.value_str() { match item.value_str() {
Some(s) => lib.wasm_import_module = Some(s), Some(s) => lib.wasm_import_module = Some(s),
None => { None => {
@ -156,7 +156,7 @@ impl<'a, 'tcx> Collector<'a, 'tcx> {
} }
if lib.cfg.is_some() && !self.tcx.features().link_cfg { if lib.cfg.is_some() && !self.tcx.features().link_cfg {
feature_gate::emit_feature_err(&self.tcx.sess.parse_sess, feature_gate::emit_feature_err(&self.tcx.sess.parse_sess,
"link_cfg", sym::link_cfg,
span.unwrap(), span.unwrap(),
GateIssue::Language, GateIssue::Language,
"is feature gated"); "is feature gated");
@ -164,7 +164,7 @@ impl<'a, 'tcx> Collector<'a, 'tcx> {
if lib.kind == cstore::NativeStaticNobundle && if lib.kind == cstore::NativeStaticNobundle &&
!self.tcx.features().static_nobundle { !self.tcx.features().static_nobundle {
feature_gate::emit_feature_err(&self.tcx.sess.parse_sess, feature_gate::emit_feature_err(&self.tcx.sess.parse_sess,
"static_nobundle", sym::static_nobundle,
span.unwrap_or_else(|| syntax_pos::DUMMY_SP), span.unwrap_or_else(|| syntax_pos::DUMMY_SP),
GateIssue::Language, GateIssue::Language,
"kind=\"static-nobundle\" is feature gated"); "kind=\"static-nobundle\" is feature gated");
@ -181,7 +181,7 @@ impl<'a, 'tcx> Collector<'a, 'tcx> {
let any_duplicate = self.libs let any_duplicate = self.libs
.iter() .iter()
.filter_map(|lib| lib.name.as_ref()) .filter_map(|lib| lib.name.as_ref())
.any(|n| n == name); .any(|n| n.as_str() == *name);
if new_name.is_empty() { if new_name.is_empty() {
self.tcx.sess.err( self.tcx.sess.err(
&format!("an empty renaming target was specified for library `{}`",name)); &format!("an empty renaming target was specified for library `{}`",name));
@ -212,7 +212,7 @@ impl<'a, 'tcx> Collector<'a, 'tcx> {
// can move them to the end of the list below. // can move them to the end of the list below.
let mut existing = self.libs.drain_filter(|lib| { let mut existing = self.libs.drain_filter(|lib| {
if let Some(lib_name) = lib.name { if let Some(lib_name) = lib.name {
if lib_name == name as &str { if lib_name.as_str() == *name {
if let Some(k) = kind { if let Some(k) = kind {
lib.kind = k; lib.kind = k;
} }

3
src/librustc_mir/borrow_check/error_reporting.rs
View file

@ -20,6 +20,7 @@ use rustc_data_structures::indexed_vec::Idx;
use rustc_errors::{Applicability, DiagnosticBuilder}; use rustc_errors::{Applicability, DiagnosticBuilder};
use syntax_pos::Span; use syntax_pos::Span;
use syntax::source_map::CompilerDesugaringKind; use syntax::source_map::CompilerDesugaringKind;
use syntax::symbol::sym;
use super::borrow_set::BorrowData; use super::borrow_set::BorrowData;
use super::{MirBorrowckCtxt}; use super::{MirBorrowckCtxt};
@ -1839,7 +1840,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
PlaceBase::Static(box Static{ kind: StaticKind::Static(def_id), .. }) PlaceBase::Static(box Static{ kind: StaticKind::Static(def_id), .. })
) = place { ) = place {
let attrs = self.infcx.tcx.get_attrs(*def_id); let attrs = self.infcx.tcx.get_attrs(*def_id);
let is_thread_local = attrs.iter().any(|attr| attr.check_name("thread_local")); let is_thread_local = attrs.iter().any(|attr| attr.check_name(sym::thread_local));
debug!( debug!(
"is_place_thread_local: attrs={:?} is_thread_local={:?}", "is_place_thread_local: attrs={:?} is_thread_local={:?}",

3
src/librustc_mir/borrow_check/nll/mod.rs
View file

@ -20,6 +20,7 @@ use std::io;
use std::path::PathBuf; use std::path::PathBuf;
use std::rc::Rc; use std::rc::Rc;
use std::str::FromStr; use std::str::FromStr;
use syntax::symbol::sym;
use self::mir_util::PassWhere; use self::mir_util::PassWhere;
use polonius_engine::{Algorithm, Output}; use polonius_engine::{Algorithm, Output};
@ -280,7 +281,7 @@ fn dump_annotation<'a, 'gcx, 'tcx>(
) { ) {
let tcx = infcx.tcx; let tcx = infcx.tcx;
let base_def_id = tcx.closure_base_def_id(mir_def_id); let base_def_id = tcx.closure_base_def_id(mir_def_id);
if !tcx.has_attr(base_def_id, "rustc_regions") { if !tcx.has_attr(base_def_id, sym::rustc_regions) {
return; return;
} }

11
src/librustc_mir/dataflow/mod.rs
View file

@ -1,4 +1,5 @@
use syntax::ast::{self, MetaItem}; use syntax::ast::{self, MetaItem};
use syntax::symbol::{Symbol, sym};
use rustc_data_structures::bit_set::{BitSet, BitSetOperator, HybridBitSet}; use rustc_data_structures::bit_set::{BitSet, BitSetOperator, HybridBitSet};
use rustc_data_structures::indexed_vec::Idx; use rustc_data_structures::indexed_vec::Idx;
@ -100,9 +101,9 @@ where
fn propagate(&mut self) { self.flow_state.propagate(); } fn propagate(&mut self) { self.flow_state.propagate(); }
} }
pub(crate) fn has_rustc_mir_with(attrs: &[ast::Attribute], name: &str) -> Option<MetaItem> { pub(crate) fn has_rustc_mir_with(attrs: &[ast::Attribute], name: Symbol) -> Option<MetaItem> {
for attr in attrs { for attr in attrs {
if attr.check_name("rustc_mir") { if attr.check_name(sym::rustc_mir) {
let items = attr.meta_item_list(); let items = attr.meta_item_list();
for item in items.iter().flat_map(|l| l.iter()) { for item in items.iter().flat_map(|l| l.iter()) {
match item.meta_item() { match item.meta_item() {
@ -158,10 +159,8 @@ impl<'a, 'gcx: 'tcx, 'tcx: 'a, BD> DataflowAnalysis<'a, 'tcx, BD> where BD: BitD
return None; return None;
}; };
let print_preflow_to = let print_preflow_to = name_found(tcx.sess, attributes, sym::borrowck_graphviz_preflow);
name_found(tcx.sess, attributes, "borrowck_graphviz_preflow"); let print_postflow_to = name_found(tcx.sess, attributes, sym::borrowck_graphviz_postflow);
let print_postflow_to =
name_found(tcx.sess, attributes, "borrowck_graphviz_postflow");
let mut mbcx = DataflowBuilder { let mut mbcx = DataflowBuilder {
def_id, def_id,

4
src/librustc_mir/hair/cx/mod.rs
View file

@ -16,7 +16,7 @@ use rustc::ty::subst::{Kind, InternalSubsts};
use rustc::ty::layout::VariantIdx; use rustc::ty::layout::VariantIdx;
use syntax::ast; use syntax::ast;
use syntax::attr; use syntax::attr;
use syntax::symbol::Symbol; use syntax::symbol::{Symbol, sym};
use rustc::hir; use rustc::hir;
use crate::hair::constant::{lit_to_const, LitToConstError}; use crate::hair::constant::{lit_to_const, LitToConstError};
@ -67,7 +67,7 @@ impl<'a, 'gcx, 'tcx> Cx<'a, 'gcx, 'tcx> {
// Some functions always have overflow checks enabled, // Some functions always have overflow checks enabled,
// however, they may not get codegen'd, depending on // however, they may not get codegen'd, depending on
// the settings for the crate they are codegened in. // the settings for the crate they are codegened in.
let mut check_overflow = attr::contains_name(attrs, "rustc_inherit_overflow_checks"); let mut check_overflow = attr::contains_name(attrs, sym::rustc_inherit_overflow_checks);
// Respect -C overflow-checks. // Respect -C overflow-checks.
check_overflow |= tcx.sess.overflow_checks(); check_overflow |= tcx.sess.overflow_checks();

5
src/librustc_mir/hair/pattern/mod.rs
View file

@ -27,6 +27,7 @@ use std::cmp::Ordering;
use std::fmt; use std::fmt;
use syntax::ast; use syntax::ast;
use syntax::ptr::P; use syntax::ptr::P;
use syntax::symbol::sym;
use syntax_pos::Span; use syntax_pos::Span;
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
@ -978,7 +979,7 @@ impl<'a, 'tcx> PatternContext<'a, 'tcx> {
self.tcx.sess.span_err(span, "cannot use unions in constant patterns"); self.tcx.sess.span_err(span, "cannot use unions in constant patterns");
PatternKind::Wild PatternKind::Wild
} }
ty::Adt(adt_def, _) if !self.tcx.has_attr(adt_def.did, "structural_match") => { ty::Adt(adt_def, _) if !self.tcx.has_attr(adt_def.did, sym::structural_match) => {
let path = self.tcx.def_path_str(adt_def.did); let path = self.tcx.def_path_str(adt_def.did);
let msg = format!( let msg = format!(
"to use a constant of type `{}` in a pattern, \ "to use a constant of type `{}` in a pattern, \
@ -990,7 +991,7 @@ impl<'a, 'tcx> PatternContext<'a, 'tcx> {
PatternKind::Wild PatternKind::Wild
} }
ty::Ref(_, ty::TyS { sty: ty::Adt(adt_def, _), .. }, _) ty::Ref(_, ty::TyS { sty: ty::Adt(adt_def, _), .. }, _)
if !self.tcx.has_attr(adt_def.did, "structural_match") => { if !self.tcx.has_attr(adt_def.did, sym::structural_match) => {
// HACK(estebank): Side-step ICE #53708, but anything other than erroring here // HACK(estebank): Side-step ICE #53708, but anything other than erroring here
// would be wrong. Returnging `PatternKind::Wild` is not technically correct. // would be wrong. Returnging `PatternKind::Wild` is not technically correct.
let path = self.tcx.def_path_str(adt_def.did); let path = self.tcx.def_path_str(adt_def.did);

6
src/librustc_mir/interpret/cast.rs
View file

@ -2,6 +2,7 @@ use rustc::ty::{self, Ty, TypeAndMut};
use rustc::ty::layout::{self, TyLayout, Size}; use rustc::ty::layout::{self, TyLayout, Size};
use rustc::ty::adjustment::{PointerCast}; use rustc::ty::adjustment::{PointerCast};
use syntax::ast::{FloatTy, IntTy, UintTy}; use syntax::ast::{FloatTy, IntTy, UintTy};
use syntax::symbol::sym;
use rustc_apfloat::ieee::{Single, Double}; use rustc_apfloat::ieee::{Single, Double};
use rustc::mir::interpret::{ use rustc::mir::interpret::{
@ -76,9 +77,8 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> InterpretCx<'a, 'mir, 'tcx, M>
// The src operand does not matter, just its type // The src operand does not matter, just its type
match src.layout.ty.sty { match src.layout.ty.sty {
ty::FnDef(def_id, substs) => { ty::FnDef(def_id, substs) => {
if self.tcx.has_attr(def_id, "rustc_args_required_const") { if self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
bug!("reifying a fn ptr that requires \ bug!("reifying a fn ptr that requires const arguments");
const arguments");
} }
let instance: EvalResult<'tcx, _> = ty::Instance::resolve( let instance: EvalResult<'tcx, _> = ty::Instance::resolve(
*self.tcx, *self.tcx,

4
src/librustc_mir/transform/check_unsafety.rs
View file

@ -12,7 +12,7 @@ use rustc::lint::builtin::{SAFE_EXTERN_STATICS, SAFE_PACKED_BORROWS, UNUSED_UNSA
use rustc::mir::*; use rustc::mir::*;
use rustc::mir::visit::{PlaceContext, Visitor, MutatingUseContext}; use rustc::mir::visit::{PlaceContext, Visitor, MutatingUseContext};
use syntax::symbol::Symbol; use syntax::symbol::{Symbol, sym};
use std::ops::Bound; use std::ops::Bound;
@ -612,7 +612,7 @@ fn report_unused_unsafe(tcx: TyCtxt<'_, '_, '_>,
fn builtin_derive_def_id<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> Option<DefId> { fn builtin_derive_def_id<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> Option<DefId> {
debug!("builtin_derive_def_id({:?})", def_id); debug!("builtin_derive_def_id({:?})", def_id);
if let Some(impl_def_id) = tcx.impl_of_method(def_id) { if let Some(impl_def_id) = tcx.impl_of_method(def_id) {
if tcx.has_attr(impl_def_id, "automatically_derived") { if tcx.has_attr(impl_def_id, sym::automatically_derived) {
debug!("builtin_derive_def_id({:?}) - is {:?}", def_id, impl_def_id); debug!("builtin_derive_def_id({:?}) - is {:?}", def_id, impl_def_id);
Some(impl_def_id) Some(impl_def_id)
} else { } else {

25
src/librustc_mir/transform/qualify_consts.rs
View file

@ -22,6 +22,7 @@ use rustc::middle::lang_items;
use rustc::session::config::nightly_options; use rustc::session::config::nightly_options;
use syntax::ast::LitKind; use syntax::ast::LitKind;
use syntax::feature_gate::{emit_feature_err, GateIssue}; use syntax::feature_gate::{emit_feature_err, GateIssue};
use syntax::symbol::sym;
use syntax_pos::{Span, DUMMY_SP}; use syntax_pos::{Span, DUMMY_SP};
use std::fmt; use std::fmt;
@ -380,8 +381,8 @@ impl Qualif for IsNotPromotable {
!allowed || !allowed ||
cx.tcx.get_attrs(def_id).iter().any( cx.tcx.get_attrs(def_id).iter().any(
|attr| attr.check_name("thread_local" |attr| attr.check_name(sym::thread_local)
)) )
} }
} }
} }
@ -939,7 +940,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Checker<'a, 'tcx> {
if self.tcx if self.tcx
.get_attrs(def_id) .get_attrs(def_id)
.iter() .iter()
.any(|attr| attr.check_name("thread_local")) { .any(|attr| attr.check_name(sym::thread_local)) {
if self.mode != Mode::Fn { if self.mode != Mode::Fn {
span_err!(self.tcx.sess, self.span, E0625, span_err!(self.tcx.sess, self.span, E0625,
"thread-local statics cannot be \ "thread-local statics cannot be \
@ -994,7 +995,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Checker<'a, 'tcx> {
if let ty::RawPtr(_) = base_ty.sty { if let ty::RawPtr(_) = base_ty.sty {
if !self.tcx.features().const_raw_ptr_deref { if !self.tcx.features().const_raw_ptr_deref {
emit_feature_err( emit_feature_err(
&self.tcx.sess.parse_sess, "const_raw_ptr_deref", &self.tcx.sess.parse_sess, sym::const_raw_ptr_deref,
self.span, GateIssue::Language, self.span, GateIssue::Language,
&format!( &format!(
"dereferencing raw pointers in {}s is unstable", "dereferencing raw pointers in {}s is unstable",
@ -1018,7 +1019,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Checker<'a, 'tcx> {
Mode::ConstFn => { Mode::ConstFn => {
if !self.tcx.features().const_fn_union { if !self.tcx.features().const_fn_union {
emit_feature_err( emit_feature_err(
&self.tcx.sess.parse_sess, "const_fn_union", &self.tcx.sess.parse_sess, sym::const_fn_union,
self.span, GateIssue::Language, self.span, GateIssue::Language,
"unions in const fn are unstable", "unions in const fn are unstable",
); );
@ -1123,7 +1124,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Checker<'a, 'tcx> {
// in const fn and constants require the feature gate // in const fn and constants require the feature gate
// FIXME: make it unsafe inside const fn and constants // FIXME: make it unsafe inside const fn and constants
emit_feature_err( emit_feature_err(
&self.tcx.sess.parse_sess, "const_raw_ptr_to_usize_cast", &self.tcx.sess.parse_sess, sym::const_raw_ptr_to_usize_cast,
self.span, GateIssue::Language, self.span, GateIssue::Language,
&format!( &format!(
"casting pointers to integers in {}s is unstable", "casting pointers to integers in {}s is unstable",
@ -1149,7 +1150,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Checker<'a, 'tcx> {
// FIXME: make it unsafe to use these operations // FIXME: make it unsafe to use these operations
emit_feature_err( emit_feature_err(
&self.tcx.sess.parse_sess, &self.tcx.sess.parse_sess,
"const_compare_raw_pointers", sym::const_compare_raw_pointers,
self.span, self.span,
GateIssue::Language, GateIssue::Language,
&format!("comparing raw pointers inside {}", self.mode), &format!("comparing raw pointers inside {}", self.mode),
@ -1210,7 +1211,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Checker<'a, 'tcx> {
// const eval transmute calls only with the feature gate // const eval transmute calls only with the feature gate
if !self.tcx.features().const_transmute { if !self.tcx.features().const_transmute {
emit_feature_err( emit_feature_err(
&self.tcx.sess.parse_sess, "const_transmute", &self.tcx.sess.parse_sess, sym::const_transmute,
self.span, GateIssue::Language, self.span, GateIssue::Language,
&format!("The use of std::mem::transmute() \ &format!("The use of std::mem::transmute() \
is gated in {}s", self.mode)); is gated in {}s", self.mode));
@ -1249,7 +1250,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Checker<'a, 'tcx> {
// Don't allow panics in constants without the feature gate. // Don't allow panics in constants without the feature gate.
emit_feature_err( emit_feature_err(
&self.tcx.sess.parse_sess, &self.tcx.sess.parse_sess,
"const_panic", sym::const_panic,
self.span, self.span,
GateIssue::Language, GateIssue::Language,
&format!("panicking in {}s is unstable", self.mode), &format!("panicking in {}s is unstable", self.mode),
@ -1260,7 +1261,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Checker<'a, 'tcx> {
// Check `#[unstable]` const fns or `#[rustc_const_unstable]` // Check `#[unstable]` const fns or `#[rustc_const_unstable]`
// functions without the feature gate active in this crate in // functions without the feature gate active in this crate in
// order to report a better error message than the one below. // order to report a better error message than the one below.
if !self.span.allows_unstable(&feature.as_str()) { if !self.span.allows_unstable(feature) {
let mut err = self.tcx.sess.struct_span_err(self.span, let mut err = self.tcx.sess.struct_span_err(self.span,
&format!("`{}` is not yet stable as a const fn", &format!("`{}` is not yet stable as a const fn",
self.tcx.def_path_str(def_id))); self.tcx.def_path_str(def_id)));
@ -1592,7 +1593,7 @@ impl MirPass for QualifyAndPromoteConstants {
if mode == Mode::Static { if mode == Mode::Static {
// `#[thread_local]` statics don't have to be `Sync`. // `#[thread_local]` statics don't have to be `Sync`.
for attr in &tcx.get_attrs(def_id)[..] { for attr in &tcx.get_attrs(def_id)[..] {
if attr.check_name("thread_local") { if attr.check_name(sym::thread_local) {
return; return;
} }
} }
@ -1616,7 +1617,7 @@ impl MirPass for QualifyAndPromoteConstants {
fn args_required_const(tcx: TyCtxt<'_, '_, '_>, def_id: DefId) -> Option<FxHashSet<usize>> { fn args_required_const(tcx: TyCtxt<'_, '_, '_>, def_id: DefId) -> Option<FxHashSet<usize>> {
let attrs = tcx.get_attrs(def_id); let attrs = tcx.get_attrs(def_id);
let attr = attrs.iter().find(|a| a.check_name("rustc_args_required_const"))?; let attr = attrs.iter().find(|a| a.check_name(sym::rustc_args_required_const))?;
let mut ret = FxHashSet::default(); let mut ret = FxHashSet::default();
for meta in attr.meta_item_list()? { for meta in attr.meta_item_list()? {
match meta.literal()?.node { match meta.literal()?.node {

11
src/librustc_mir/transform/rustc_peek.rs
View file

@ -1,5 +1,6 @@
use rustc_target::spec::abi::{Abi}; use rustc_target::spec::abi::{Abi};
use syntax::ast; use syntax::ast;
use syntax::symbol::sym;
use syntax_pos::Span; use syntax_pos::Span;
use rustc::ty::{self, TyCtxt}; use rustc::ty::{self, TyCtxt};
@ -27,7 +28,7 @@ impl MirPass for SanityCheck {
fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>,
src: MirSource<'tcx>, mir: &mut Mir<'tcx>) { src: MirSource<'tcx>, mir: &mut Mir<'tcx>) {
let def_id = src.def_id(); let def_id = src.def_id();
if !tcx.has_attr(def_id, "rustc_mir") { if !tcx.has_attr(def_id, sym::rustc_mir) {
debug!("skipping rustc_peek::SanityCheck on {}", tcx.def_path_str(def_id)); debug!("skipping rustc_peek::SanityCheck on {}", tcx.def_path_str(def_id));
return; return;
} else { } else {
@ -52,16 +53,16 @@ impl MirPass for SanityCheck {
DefinitelyInitializedPlaces::new(tcx, mir, &mdpe), DefinitelyInitializedPlaces::new(tcx, mir, &mdpe),
|bd, i| DebugFormatted::new(&bd.move_data().move_paths[i])); |bd, i| DebugFormatted::new(&bd.move_data().move_paths[i]));
if has_rustc_mir_with(&attributes, "rustc_peek_maybe_init").is_some() { if has_rustc_mir_with(&attributes, sym::rustc_peek_maybe_init).is_some() {
sanity_check_via_rustc_peek(tcx, mir, def_id, &attributes, &flow_inits); sanity_check_via_rustc_peek(tcx, mir, def_id, &attributes, &flow_inits);
} }
if has_rustc_mir_with(&attributes, "rustc_peek_maybe_uninit").is_some() { if has_rustc_mir_with(&attributes, sym::rustc_peek_maybe_uninit).is_some() {
sanity_check_via_rustc_peek(tcx, mir, def_id, &attributes, &flow_uninits); sanity_check_via_rustc_peek(tcx, mir, def_id, &attributes, &flow_uninits);
} }
if has_rustc_mir_with(&attributes, "rustc_peek_definite_init").is_some() { if has_rustc_mir_with(&attributes, sym::rustc_peek_definite_init).is_some() {
sanity_check_via_rustc_peek(tcx, mir, def_id, &attributes, &flow_def_inits); sanity_check_via_rustc_peek(tcx, mir, def_id, &attributes, &flow_def_inits);
} }
if has_rustc_mir_with(&attributes, "stop_after_dataflow").is_some() { if has_rustc_mir_with(&attributes, sym::stop_after_dataflow).is_some() {
tcx.sess.fatal("stop_after_dataflow ended compilation"); tcx.sess.fatal("stop_after_dataflow ended compilation");
} }
} }

8
src/librustc_passes/ast_validation.rs
View file

@ -15,7 +15,7 @@ use rustc_data_structures::fx::FxHashMap;
use syntax::ast::*; use syntax::ast::*;
use syntax::attr; use syntax::attr;
use syntax::source_map::Spanned; use syntax::source_map::Spanned;
use syntax::symbol::keywords; use syntax::symbol::{keywords, sym};
use syntax::ptr::P; use syntax::ptr::P;
use syntax::visit::{self, Visitor}; use syntax::visit::{self, Visitor};
use syntax::{span_err, struct_span_err, walk_list}; use syntax::{span_err, struct_span_err, walk_list};
@ -565,7 +565,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
self.has_proc_macro_decls = true; self.has_proc_macro_decls = true;
} }
if attr::contains_name(&item.attrs, "global_allocator") { if attr::contains_name(&item.attrs, sym::global_allocator) {
self.has_global_allocator = true; self.has_global_allocator = true;
} }
@ -676,8 +676,8 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
} }
ItemKind::Mod(_) => { ItemKind::Mod(_) => {
// Ensure that `path` attributes on modules are recorded as used (cf. issue #35584). // Ensure that `path` attributes on modules are recorded as used (cf. issue #35584).
attr::first_attr_value_str_by_name(&item.attrs, "path"); attr::first_attr_value_str_by_name(&item.attrs, sym::path);
if attr::contains_name(&item.attrs, "warn_directory_ownership") { if attr::contains_name(&item.attrs, sym::warn_directory_ownership) {
let lint = lint::builtin::LEGACY_DIRECTORY_OWNERSHIP; let lint = lint::builtin::LEGACY_DIRECTORY_OWNERSHIP;
let msg = "cannot declare a new module at this location"; let msg = "cannot declare a new module at this location";
self.session.buffer_lint(lint, item.id, item.span, msg); self.session.buffer_lint(lint, item.id, item.span, msg);

13
src/librustc_passes/layout_test.rs
View file

@ -12,6 +12,7 @@ use rustc::ty::ParamEnv;
use rustc::ty::Ty; use rustc::ty::Ty;
use rustc::ty::TyCtxt; use rustc::ty::TyCtxt;
use syntax::ast::Attribute; use syntax::ast::Attribute;
use syntax::symbol::sym;
pub fn test_layout<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) { pub fn test_layout<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
if tcx.features().rustc_attrs { if tcx.features().rustc_attrs {
@ -32,7 +33,7 @@ impl<'a, 'tcx> ItemLikeVisitor<'tcx> for VarianceTest<'a, 'tcx> {
if let ItemKind::Ty(..) = item.node { if let ItemKind::Ty(..) = item.node {
for attr in self.tcx.get_attrs(item_def_id).iter() { for attr in self.tcx.get_attrs(item_def_id).iter() {
if attr.check_name("rustc_layout") { if attr.check_name(sym::rustc_layout) {
self.dump_layout_of(item_def_id, item, attr); self.dump_layout_of(item_def_id, item, attr);
} }
} }
@ -54,26 +55,26 @@ impl<'a, 'tcx> VarianceTest<'a, 'tcx> {
// The `..` are the names of fields to dump. // The `..` are the names of fields to dump.
let meta_items = attr.meta_item_list().unwrap_or_default(); let meta_items = attr.meta_item_list().unwrap_or_default();
for meta_item in meta_items { for meta_item in meta_items {
match meta_item.name_or_empty().get() { match meta_item.name_or_empty() {
"abi" => { sym::abi => {
self.tcx self.tcx
.sess .sess
.span_err(item.span, &format!("abi: {:?}", ty_layout.abi)); .span_err(item.span, &format!("abi: {:?}", ty_layout.abi));
} }
"align" => { sym::align => {
self.tcx self.tcx
.sess .sess
.span_err(item.span, &format!("align: {:?}", ty_layout.align)); .span_err(item.span, &format!("align: {:?}", ty_layout.align));
} }
"size" => { sym::size => {
self.tcx self.tcx
.sess .sess
.span_err(item.span, &format!("size: {:?}", ty_layout.size)); .span_err(item.span, &format!("size: {:?}", ty_layout.size));
} }
"homogeneous_aggregate" => { sym::homogeneous_aggregate => {
self.tcx.sess.span_err( self.tcx.sess.span_err(
item.span, item.span,
&format!( &format!(

3
src/librustc_passes/rvalue_promotion.rs
View file

@ -25,6 +25,7 @@ use rustc::ty::query::Providers;
use rustc::ty::subst::{InternalSubsts, SubstsRef}; use rustc::ty::subst::{InternalSubsts, SubstsRef};
use rustc::util::nodemap::{ItemLocalSet, HirIdSet}; use rustc::util::nodemap::{ItemLocalSet, HirIdSet};
use rustc::hir; use rustc::hir;
use syntax::symbol::sym;
use syntax_pos::{Span, DUMMY_SP}; use syntax_pos::{Span, DUMMY_SP};
use log::debug; use log::debug;
use Promotability::*; use Promotability::*;
@ -335,7 +336,7 @@ fn check_expr_kind<'a, 'tcx>(
if v.in_static { if v.in_static {
for attr in &v.tcx.get_attrs(did)[..] { for attr in &v.tcx.get_attrs(did)[..] {
if attr.check_name("thread_local") { if attr.check_name(sym::thread_local) {
debug!("Reference to Static(id={:?}) is unpromotable \ debug!("Reference to Static(id={:?}) is unpromotable \
due to a #[thread_local] attribute", did); due to a #[thread_local] attribute", did);
return NotPromotable; return NotPromotable;

4
src/librustc_plugin/build.rs
View file

@ -1,6 +1,7 @@
//! Used by `rustc` when compiling a plugin crate. //! Used by `rustc` when compiling a plugin crate.
use syntax::attr; use syntax::attr;
use syntax::symbol::sym;
use syntax_pos::Span; use syntax_pos::Span;
use rustc::hir::itemlikevisit::ItemLikeVisitor; use rustc::hir::itemlikevisit::ItemLikeVisitor;
use rustc::hir; use rustc::hir;
@ -15,8 +16,7 @@ struct RegistrarFinder {
impl<'v> ItemLikeVisitor<'v> for RegistrarFinder { impl<'v> ItemLikeVisitor<'v> for RegistrarFinder {
fn visit_item(&mut self, item: &hir::Item) { fn visit_item(&mut self, item: &hir::Item) {
if let hir::ItemKind::Fn(..) = item.node { if let hir::ItemKind::Fn(..) = item.node {
if attr::contains_name(&item.attrs, if attr::contains_name(&item.attrs, sym::plugin_registrar) {
"plugin_registrar") {
self.registrars.push((item.hir_id, item.span)); self.registrars.push((item.hir_id, item.span));
} }
} }

11
src/librustc_plugin/load.rs
View file

@ -11,6 +11,7 @@ use std::mem;
use std::path::PathBuf; use std::path::PathBuf;
use syntax::ast; use syntax::ast;
use syntax::span_err; use syntax::span_err;
use syntax::symbol::{Symbol, keywords, sym};
use syntax_pos::{Span, DUMMY_SP}; use syntax_pos::{Span, DUMMY_SP};
/// Pointer to a registrar function. /// Pointer to a registrar function.
@ -45,7 +46,7 @@ pub fn load_plugins(sess: &Session,
// the feature enabled will result in an error later... // the feature enabled will result in an error later...
if sess.features_untracked().plugin { if sess.features_untracked().plugin {
for attr in &krate.attrs { for attr in &krate.attrs {
if !attr.check_name("plugin") { if !attr.check_name(sym::plugin) {
continue; continue;
} }
@ -57,9 +58,9 @@ pub fn load_plugins(sess: &Session,
for plugin in plugins { for plugin in plugins {
// plugins must have a name and can't be key = value // plugins must have a name and can't be key = value
let name = plugin.name_or_empty(); let name = plugin.name_or_empty();
if !name.is_empty() && !plugin.is_value_str() { if name != keywords::Invalid.name() && !plugin.is_value_str() {
let args = plugin.meta_item_list().map(ToOwned::to_owned); let args = plugin.meta_item_list().map(ToOwned::to_owned);
loader.load_plugin(plugin.span(), &name, args.unwrap_or_default()); loader.load_plugin(plugin.span(), name, args.unwrap_or_default());
} else { } else {
call_malformed_plugin_attribute(sess, attr.span); call_malformed_plugin_attribute(sess, attr.span);
} }
@ -69,7 +70,7 @@ pub fn load_plugins(sess: &Session,
if let Some(plugins) = addl_plugins { if let Some(plugins) = addl_plugins {
for plugin in plugins { for plugin in plugins {
loader.load_plugin(DUMMY_SP, &plugin, vec![]); loader.load_plugin(DUMMY_SP, Symbol::intern(&plugin), vec![]);
} }
} }
@ -85,7 +86,7 @@ impl<'a> PluginLoader<'a> {
} }
} }
fn load_plugin(&mut self, span: Span, name: &str, args: Vec<ast::NestedMetaItem>) { fn load_plugin(&mut self, span: Span, name: Symbol, args: Vec<ast::NestedMetaItem>) {
let registrar = self.reader.find_plugin_registrar(span, name); let registrar = self.reader.find_plugin_registrar(span, name);
if let Some((lib, disambiguator)) = registrar { if let Some((lib, disambiguator)) = registrar {

8
src/librustc_plugin/registry.rs
View file

@ -7,7 +7,7 @@ use rustc::util::nodemap::FxHashMap;
use syntax::ext::base::{SyntaxExtension, NamedSyntaxExtension, NormalTT, IdentTT}; use syntax::ext::base::{SyntaxExtension, NamedSyntaxExtension, NormalTT, IdentTT};
use syntax::ext::base::MacroExpanderFn; use syntax::ext::base::MacroExpanderFn;
use syntax::ext::hygiene; use syntax::ext::hygiene;
use syntax::symbol::Symbol; use syntax::symbol::{Symbol, sym};
use syntax::ast; use syntax::ast;
use syntax::feature_gate::AttributeType; use syntax::feature_gate::AttributeType;
use syntax_pos::Span; use syntax_pos::Span;
@ -49,7 +49,7 @@ pub struct Registry<'a> {
pub llvm_passes: Vec<String>, pub llvm_passes: Vec<String>,
#[doc(hidden)] #[doc(hidden)]
pub attributes: Vec<(String, AttributeType)>, pub attributes: Vec<(Symbol, AttributeType)>,
} }
impl<'a> Registry<'a> { impl<'a> Registry<'a> {
@ -86,7 +86,7 @@ impl<'a> Registry<'a> {
/// ///
/// This is the most general hook into `libsyntax`'s expansion behavior. /// This is the most general hook into `libsyntax`'s expansion behavior.
pub fn register_syntax_extension(&mut self, name: ast::Name, extension: SyntaxExtension) { pub fn register_syntax_extension(&mut self, name: ast::Name, extension: SyntaxExtension) {
if name == "macro_rules" { if name == sym::macro_rules {
panic!("user-defined macros may not be named `macro_rules`"); panic!("user-defined macros may not be named `macro_rules`");
} }
self.syntax_exts.push((name, match extension { self.syntax_exts.push((name, match extension {
@ -169,7 +169,7 @@ impl<'a> Registry<'a> {
/// Registered attributes will bypass the `custom_attribute` feature gate. /// Registered attributes will bypass the `custom_attribute` feature gate.
/// `Whitelisted` attributes will additionally not trigger the `unused_attribute` /// `Whitelisted` attributes will additionally not trigger the `unused_attribute`
/// lint. `CrateLevel` attributes will not be allowed on anything other than a crate. /// lint. `CrateLevel` attributes will not be allowed on anything other than a crate.
pub fn register_attribute(&mut self, name: String, ty: AttributeType) { pub fn register_attribute(&mut self, name: Symbol, ty: AttributeType) {
self.attributes.push((name, ty)); self.attributes.push((name, ty));
} }
} }

7
src/librustc_privacy/lib.rs
View file

@ -27,7 +27,7 @@ use rustc_data_structures::fx::FxHashSet;
use rustc_data_structures::sync::Lrc; use rustc_data_structures::sync::Lrc;
use syntax::ast::Ident; use syntax::ast::Ident;
use syntax::attr; use syntax::attr;
use syntax::symbol::keywords; use syntax::symbol::{keywords, sym};
use syntax_pos::Span; use syntax_pos::Span;
use std::{cmp, fmt, mem}; use std::{cmp, fmt, mem};
@ -260,7 +260,8 @@ fn def_id_visibility<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId)
ctor_vis = ty::Visibility::Restricted( ctor_vis = ty::Visibility::Restricted(
DefId::local(CRATE_DEF_INDEX)); DefId::local(CRATE_DEF_INDEX));
let attrs = tcx.get_attrs(variant.def_id); let attrs = tcx.get_attrs(variant.def_id);
span = attr::find_by_name(&attrs, "non_exhaustive").unwrap().span; span = attr::find_by_name(&attrs, sym::non_exhaustive)
.unwrap().span;
descr = "crate-visible"; descr = "crate-visible";
} }
@ -291,7 +292,7 @@ fn def_id_visibility<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId)
if adt_def.non_enum_variant().is_field_list_non_exhaustive() { if adt_def.non_enum_variant().is_field_list_non_exhaustive() {
ctor_vis = ctor_vis =
ty::Visibility::Restricted(DefId::local(CRATE_DEF_INDEX)); ty::Visibility::Restricted(DefId::local(CRATE_DEF_INDEX));
span = attr::find_by_name(&item.attrs, "non_exhaustive") span = attr::find_by_name(&item.attrs, sym::non_exhaustive)
.unwrap().span; .unwrap().span;
descr = "crate-visible"; descr = "crate-visible";
} }

24
src/librustc_resolve/build_reduced_graph.rs
View file

@ -37,7 +37,7 @@ use syntax::feature_gate::is_builtin_attr;
use syntax::parse::token::{self, Token}; use syntax::parse::token::{self, Token};
use syntax::span_err; use syntax::span_err;
use syntax::std_inject::injected_crate_name; use syntax::std_inject::injected_crate_name;
use syntax::symbol::keywords; use syntax::symbol::{keywords, sym};
use syntax::visit::{self, Visitor}; use syntax::visit::{self, Visitor};
use syntax_pos::{Span, DUMMY_SP}; use syntax_pos::{Span, DUMMY_SP};
@ -257,7 +257,7 @@ impl<'a> Resolver<'a> {
} }
ast::UseTreeKind::Glob => { ast::UseTreeKind::Glob => {
let subclass = GlobImport { let subclass = GlobImport {
is_prelude: attr::contains_name(&item.attrs, "prelude_import"), is_prelude: attr::contains_name(&item.attrs, sym::prelude_import),
max_vis: Cell::new(ty::Visibility::Invisible), max_vis: Cell::new(ty::Visibility::Invisible),
}; };
self.add_import_directive( self.add_import_directive(
@ -369,7 +369,7 @@ impl<'a> Resolver<'a> {
}; };
self.populate_module_if_necessary(module); self.populate_module_if_necessary(module);
if injected_crate_name().map_or(false, |name| ident.name == name) { if injected_crate_name().map_or(false, |name| ident.name.as_str() == name) {
self.injected_crate = Some(module); self.injected_crate = Some(module);
} }
@ -427,7 +427,7 @@ impl<'a> Resolver<'a> {
let module_kind = ModuleKind::Def(DefKind::Mod, def_id, ident.name); let module_kind = ModuleKind::Def(DefKind::Mod, def_id, ident.name);
let module = self.arenas.alloc_module(ModuleData { let module = self.arenas.alloc_module(ModuleData {
no_implicit_prelude: parent.no_implicit_prelude || { no_implicit_prelude: parent.no_implicit_prelude || {
attr::contains_name(&item.attrs, "no_implicit_prelude") attr::contains_name(&item.attrs, sym::no_implicit_prelude)
}, },
..ModuleData::new(Some(parent), module_kind, def_id, expansion, item.span) ..ModuleData::new(Some(parent), module_kind, def_id, expansion, item.span)
}); });
@ -456,12 +456,12 @@ impl<'a> Resolver<'a> {
// Functions introducing procedural macros reserve a slot // Functions introducing procedural macros reserve a slot
// in the macro namespace as well (see #52225). // in the macro namespace as well (see #52225).
if attr::contains_name(&item.attrs, "proc_macro") || if attr::contains_name(&item.attrs, sym::proc_macro) ||
attr::contains_name(&item.attrs, "proc_macro_attribute") { attr::contains_name(&item.attrs, sym::proc_macro_attribute) {
let res = Res::Def(DefKind::Macro(MacroKind::ProcMacroStub), res.def_id()); let res = Res::Def(DefKind::Macro(MacroKind::ProcMacroStub), res.def_id());
self.define(parent, ident, MacroNS, (res, vis, sp, expansion)); self.define(parent, ident, MacroNS, (res, vis, sp, expansion));
} }
if let Some(attr) = attr::find_by_name(&item.attrs, "proc_macro_derive") { if let Some(attr) = attr::find_by_name(&item.attrs, sym::proc_macro_derive) {
if let Some(trait_attr) = if let Some(trait_attr) =
attr.meta_item_list().and_then(|list| list.get(0).cloned()) { attr.meta_item_list().and_then(|list| list.get(0).cloned()) {
if let Some(ident) = trait_attr.ident() { if let Some(ident) = trait_attr.ident() {
@ -518,7 +518,7 @@ impl<'a> Resolver<'a> {
let mut ctor_vis = vis; let mut ctor_vis = vis;
let has_non_exhaustive = attr::contains_name(&item.attrs, "non_exhaustive"); let has_non_exhaustive = attr::contains_name(&item.attrs, sym::non_exhaustive);
// If the structure is marked as non_exhaustive then lower the visibility // If the structure is marked as non_exhaustive then lower the visibility
// to within the crate. // to within the crate.
@ -599,7 +599,7 @@ impl<'a> Resolver<'a> {
// If the variant is marked as non_exhaustive then lower the visibility to within the // If the variant is marked as non_exhaustive then lower the visibility to within the
// crate. // crate.
let mut ctor_vis = vis; let mut ctor_vis = vis;
let has_non_exhaustive = attr::contains_name(&variant.node.attrs, "non_exhaustive"); let has_non_exhaustive = attr::contains_name(&variant.node.attrs, sym::non_exhaustive);
if has_non_exhaustive && vis == ty::Visibility::Public { if has_non_exhaustive && vis == ty::Visibility::Public {
ctor_vis = ty::Visibility::Restricted(DefId::local(CRATE_DEF_INDEX)); ctor_vis = ty::Visibility::Restricted(DefId::local(CRATE_DEF_INDEX));
} }
@ -825,7 +825,7 @@ impl<'a> Resolver<'a> {
let mut import_all = None; let mut import_all = None;
let mut single_imports = Vec::new(); let mut single_imports = Vec::new();
for attr in &item.attrs { for attr in &item.attrs {
if attr.check_name("macro_use") { if attr.check_name(sym::macro_use) {
if self.current_module.parent.is_some() { if self.current_module.parent.is_some() {
span_err!(self.session, item.span, E0468, span_err!(self.session, item.span, E0468,
"an `extern crate` loading macros must be at the crate root"); "an `extern crate` loading macros must be at the crate root");
@ -908,7 +908,7 @@ impl<'a> Resolver<'a> {
/// Returns `true` if this attribute list contains `macro_use`. /// Returns `true` if this attribute list contains `macro_use`.
fn contains_macro_use(&mut self, attrs: &[ast::Attribute]) -> bool { fn contains_macro_use(&mut self, attrs: &[ast::Attribute]) -> bool {
for attr in attrs { for attr in attrs {
if attr.check_name("macro_escape") { if attr.check_name(sym::macro_escape) {
let msg = "macro_escape is a deprecated synonym for macro_use"; let msg = "macro_escape is a deprecated synonym for macro_use";
let mut err = self.session.struct_span_warn(attr.span, msg); let mut err = self.session.struct_span_warn(attr.span, msg);
if let ast::AttrStyle::Inner = attr.style { if let ast::AttrStyle::Inner = attr.style {
@ -916,7 +916,7 @@ impl<'a> Resolver<'a> {
} else { } else {
err.emit(); err.emit();
} }
} else if !attr.check_name("macro_use") { } else if !attr.check_name(sym::macro_use) {
continue; continue;
} }

14
src/librustc_resolve/lib.rs
View file

@ -43,7 +43,7 @@ use syntax::ast::{self, Name, NodeId, Ident, FloatTy, IntTy, UintTy};
use syntax::ext::base::SyntaxExtension; use syntax::ext::base::SyntaxExtension;
use syntax::ext::base::Determinacy::{self, Determined, Undetermined}; use syntax::ext::base::Determinacy::{self, Determined, Undetermined};
use syntax::ext::base::MacroKind; use syntax::ext::base::MacroKind;
use syntax::symbol::{Symbol, keywords}; use syntax::symbol::{Symbol, keywords, sym};
use syntax::util::lev_distance::find_best_match_for_name; use syntax::util::lev_distance::find_best_match_for_name;
use syntax::visit::{self, FnKind, Visitor}; use syntax::visit::{self, FnKind, Visitor};
@ -1812,8 +1812,8 @@ impl<'a> hir::lowering::Resolver for Resolver<'a> {
fn resolve_str_path( fn resolve_str_path(
&mut self, &mut self,
span: Span, span: Span,
crate_root: Option<&str>, crate_root: Option<Symbol>,
components: &[&str], components: &[Symbol],
is_value: bool is_value: bool
) -> hir::Path { ) -> hir::Path {
let root = if crate_root.is_some() { let root = if crate_root.is_some() {
@ -1825,7 +1825,7 @@ impl<'a> hir::lowering::Resolver for Resolver<'a> {
.chain( .chain(
crate_root.into_iter() crate_root.into_iter()
.chain(components.iter().cloned()) .chain(components.iter().cloned())
.map(Ident::from_str) .map(Ident::with_empty_ctxt)
).map(|i| self.new_ast_path_segment(i)).collect::<Vec<_>>(); ).map(|i| self.new_ast_path_segment(i)).collect::<Vec<_>>();
@ -1964,7 +1964,7 @@ impl<'a> Resolver<'a> {
keywords::Invalid.name(), keywords::Invalid.name(),
); );
let graph_root = arenas.alloc_module(ModuleData { let graph_root = arenas.alloc_module(ModuleData {
no_implicit_prelude: attr::contains_name(&krate.attrs, "no_implicit_prelude"), no_implicit_prelude: attr::contains_name(&krate.attrs, sym::no_implicit_prelude),
..ModuleData::new(None, root_module_kind, root_def_id, Mark::root(), krate.span) ..ModuleData::new(None, root_module_kind, root_def_id, Mark::root(), krate.span)
}); });
let mut module_map = FxHashMap::default(); let mut module_map = FxHashMap::default();
@ -1978,9 +1978,9 @@ impl<'a> Resolver<'a> {
session.opts.externs.iter().map(|kv| (Ident::from_str(kv.0), Default::default())) session.opts.externs.iter().map(|kv| (Ident::from_str(kv.0), Default::default()))
.collect(); .collect();
if !attr::contains_name(&krate.attrs, "no_core") { if !attr::contains_name(&krate.attrs, sym::no_core) {
extern_prelude.insert(Ident::from_str("core"), Default::default()); extern_prelude.insert(Ident::from_str("core"), Default::default());
if !attr::contains_name(&krate.attrs, "no_std") { if !attr::contains_name(&krate.attrs, sym::no_std) {
extern_prelude.insert(Ident::from_str("std"), Default::default()); extern_prelude.insert(Ident::from_str("std"), Default::default());
if session.rust_2018() { if session.rust_2018() {
extern_prelude.insert(Ident::from_str("meta"), Default::default()); extern_prelude.insert(Ident::from_str("meta"), Default::default());

28
src/librustc_resolve/macros.rs
View file

@ -22,7 +22,7 @@ use syntax::ext::tt::macro_rules;
use syntax::feature_gate::{ use syntax::feature_gate::{
feature_err, is_builtin_attr_name, AttributeGate, GateIssue, Stability, BUILTIN_ATTRIBUTES, feature_err, is_builtin_attr_name, AttributeGate, GateIssue, Stability, BUILTIN_ATTRIBUTES,
}; };
use syntax::symbol::{Symbol, keywords}; use syntax::symbol::{Symbol, keywords, sym};
use syntax::visit::Visitor; use syntax::visit::Visitor;
use syntax::util::lev_distance::find_best_match_for_name; use syntax::util::lev_distance::find_best_match_for_name;
use syntax_pos::{Span, DUMMY_SP}; use syntax_pos::{Span, DUMMY_SP};
@ -313,7 +313,8 @@ impl<'a> Resolver<'a> {
if !features.rustc_attrs { if !features.rustc_attrs {
let msg = "unless otherwise specified, attributes with the prefix \ let msg = "unless otherwise specified, attributes with the prefix \
`rustc_` are reserved for internal compiler diagnostics"; `rustc_` are reserved for internal compiler diagnostics";
self.report_unknown_attribute(path.span, &name, msg, "rustc_attrs"); self.report_unknown_attribute(path.span, &name, msg,
sym::rustc_attrs);
} }
} else if !features.custom_attribute { } else if !features.custom_attribute {
let msg = format!("The attribute `{}` is currently unknown to the \ let msg = format!("The attribute `{}` is currently unknown to the \
@ -323,7 +324,7 @@ impl<'a> Resolver<'a> {
path.span, path.span,
&name, &name,
&msg, &msg,
"custom_attribute", sym::custom_attribute,
); );
} }
} }
@ -345,7 +346,7 @@ impl<'a> Resolver<'a> {
Ok((res, self.get_macro(res))) Ok((res, self.get_macro(res)))
} }
fn report_unknown_attribute(&self, span: Span, name: &str, msg: &str, feature: &str) { fn report_unknown_attribute(&self, span: Span, name: &str, msg: &str, feature: Symbol) {
let mut err = feature_err( let mut err = feature_err(
&self.session.parse_sess, &self.session.parse_sess,
feature, feature,
@ -693,7 +694,7 @@ impl<'a> Resolver<'a> {
WhereToResolve::LegacyPluginHelpers => { WhereToResolve::LegacyPluginHelpers => {
if (use_prelude || rust_2015) && if (use_prelude || rust_2015) &&
self.session.plugin_attributes.borrow().iter() self.session.plugin_attributes.borrow().iter()
.any(|(name, _)| ident.name == &**name) { .any(|(name, _)| ident.name == *name) {
let binding = (Res::NonMacroAttr(NonMacroAttrKind::LegacyPluginHelper), let binding = (Res::NonMacroAttr(NonMacroAttrKind::LegacyPluginHelper),
ty::Visibility::Public, DUMMY_SP, Mark::root()) ty::Visibility::Public, DUMMY_SP, Mark::root())
.to_name_binding(self.arenas); .to_name_binding(self.arenas);
@ -981,7 +982,7 @@ impl<'a> Resolver<'a> {
let msg = let msg =
format!("cannot find {} `{}{}` in this scope", kind.descr(), ident, bang); format!("cannot find {} `{}{}` in this scope", kind.descr(), ident, bang);
let mut err = self.session.struct_span_err(ident.span, &msg); let mut err = self.session.struct_span_err(ident.span, &msg);
self.suggest_macro_name(&ident.as_str(), kind, &mut err, ident.span); self.suggest_macro_name(ident.name, kind, &mut err, ident.span);
err.emit(); err.emit();
} }
} }
@ -1009,11 +1010,12 @@ impl<'a> Resolver<'a> {
} }
} }
fn suggest_macro_name(&mut self, name: &str, kind: MacroKind, fn suggest_macro_name(&mut self, name: Symbol, kind: MacroKind,
err: &mut DiagnosticBuilder<'a>, span: Span) { err: &mut DiagnosticBuilder<'a>, span: Span) {
// First check if this is a locally-defined bang macro. // First check if this is a locally-defined bang macro.
let suggestion = if let MacroKind::Bang = kind { let suggestion = if let MacroKind::Bang = kind {
find_best_match_for_name(self.macro_names.iter().map(|ident| &ident.name), name, None) find_best_match_for_name(
self.macro_names.iter().map(|ident| &ident.name), &name.as_str(), None)
} else { } else {
None None
// Then check global macros. // Then check global macros.
@ -1022,7 +1024,7 @@ impl<'a> Resolver<'a> {
.filter_map(|(name, binding)| { .filter_map(|(name, binding)| {
if binding.macro_kind() == Some(kind) { Some(name) } else { None } if binding.macro_kind() == Some(kind) { Some(name) } else { None }
}); });
find_best_match_for_name(names, name, None) find_best_match_for_name(names, &name.as_str(), None)
// Then check modules. // Then check modules.
}).or_else(|| { }).or_else(|| {
let is_macro = |res| { let is_macro = |res| {
@ -1032,7 +1034,7 @@ impl<'a> Resolver<'a> {
false false
} }
}; };
let ident = Ident::new(Symbol::intern(name), span); let ident = Ident::new(name, span);
self.lookup_typo_candidate(&[Segment::from_ident(ident)], MacroNS, is_macro, span) self.lookup_typo_candidate(&[Segment::from_ident(ident)], MacroNS, is_macro, span)
.map(|suggestion| suggestion.candidate) .map(|suggestion| suggestion.candidate)
}); });
@ -1091,7 +1093,7 @@ impl<'a> Resolver<'a> {
current_legacy_scope: &mut LegacyScope<'a>) { current_legacy_scope: &mut LegacyScope<'a>) {
self.local_macro_def_scopes.insert(item.id, self.current_module); self.local_macro_def_scopes.insert(item.id, self.current_module);
let ident = item.ident; let ident = item.ident;
if ident.name == "macro_rules" { if ident.name == sym::macro_rules {
self.session.span_err(item.span, "user-defined macros may not be named `macro_rules`"); self.session.span_err(item.span, "user-defined macros may not be named `macro_rules`");
} }
@ -1106,7 +1108,7 @@ impl<'a> Resolver<'a> {
let ident = ident.modern(); let ident = ident.modern();
self.macro_names.insert(ident); self.macro_names.insert(ident);
let res = Res::Def(DefKind::Macro(MacroKind::Bang), def_id); let res = Res::Def(DefKind::Macro(MacroKind::Bang), def_id);
let is_macro_export = attr::contains_name(&item.attrs, "macro_export"); let is_macro_export = attr::contains_name(&item.attrs, sym::macro_export);
let vis = if is_macro_export { let vis = if is_macro_export {
ty::Visibility::Public ty::Visibility::Public
} else { } else {
@ -1124,7 +1126,7 @@ impl<'a> Resolver<'a> {
self.define(module, ident, MacroNS, self.define(module, ident, MacroNS,
(res, vis, item.span, expansion, IsMacroExport)); (res, vis, item.span, expansion, IsMacroExport));
} else { } else {
if !attr::contains_name(&item.attrs, "rustc_doc_only_macro") { if !attr::contains_name(&item.attrs, sym::rustc_doc_only_macro) {
self.check_reserved_macro_name(ident, MacroNS); self.check_reserved_macro_name(ident, MacroNS);
} }
self.unused_macros.insert(def_id); self.unused_macros.insert(def_id);

13
src/librustc_resolve/resolve_imports.rs
View file

@ -29,7 +29,7 @@ use rustc::{bug, span_bug};
use syntax::ast::{self, Ident, Name, NodeId, CRATE_NODE_ID}; use syntax::ast::{self, Ident, Name, NodeId, CRATE_NODE_ID};
use syntax::ext::base::Determinacy::{self, Determined, Undetermined}; use syntax::ext::base::Determinacy::{self, Determined, Undetermined};
use syntax::ext::hygiene::Mark; use syntax::ext::hygiene::Mark;
use syntax::symbol::keywords; use syntax::symbol::{keywords, sym};
use syntax::util::lev_distance::find_best_match_for_name; use syntax::util::lev_distance::find_best_match_for_name;
use syntax::{struct_span_err, unwrap_or}; use syntax::{struct_span_err, unwrap_or};
use syntax_pos::{MultiSpan, Span}; use syntax_pos::{MultiSpan, Span};
@ -496,7 +496,8 @@ impl<'a> Resolver<'a> {
// Reserve some names that are not quite covered by the general check // Reserve some names that are not quite covered by the general check
// performed on `Resolver::builtin_attrs`. // performed on `Resolver::builtin_attrs`.
if ns == MacroNS && if ns == MacroNS &&
(ident.name == "cfg" || ident.name == "cfg_attr" || ident.name == "derive") { (ident.name == sym::cfg || ident.name == sym::cfg_attr ||
ident.name == sym::derive) {
self.session.span_err(ident.span, self.session.span_err(ident.span,
&format!("name `{}` is reserved in macro namespace", ident)); &format!("name `{}` is reserved in macro namespace", ident));
} }
@ -706,7 +707,7 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> {
has_errors = true; has_errors = true;
if let SingleImport { source, ref source_bindings, .. } = import.subclass { if let SingleImport { source, ref source_bindings, .. } = import.subclass {
if source.name == "self" { if source.name == keywords::SelfLower.name() {
// Silence `unresolved import` error if E0429 is already emitted // Silence `unresolved import` error if E0429 is already emitted
if let Err(Determined) = source_bindings.value_ns.get() { if let Err(Determined) = source_bindings.value_ns.get() {
continue; continue;
@ -1041,7 +1042,8 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> {
let initial_res = source_bindings[ns].get().map(|initial_binding| { let initial_res = source_bindings[ns].get().map(|initial_binding| {
all_ns_err = false; all_ns_err = false;
if let Some(target_binding) = target_bindings[ns].get() { if let Some(target_binding) = target_bindings[ns].get() {
if target.name == "_" && // Note that as_str() de-gensyms the Symbol
if target.name.as_str() == "_" &&
initial_binding.is_extern_crate() && !initial_binding.is_import() { initial_binding.is_extern_crate() && !initial_binding.is_import() {
this.record_use(ident, ns, target_binding, this.record_use(ident, ns, target_binding,
directive.module_path.is_empty()); directive.module_path.is_empty());
@ -1392,7 +1394,8 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> {
// (e.g. implicitly injected `std`) cannot be properly encoded in metadata, // (e.g. implicitly injected `std`) cannot be properly encoded in metadata,
// so they can cause name conflict errors downstream. // so they can cause name conflict errors downstream.
let is_good_import = binding.is_import() && !binding.is_ambiguity() && let is_good_import = binding.is_import() && !binding.is_ambiguity() &&
!(ident.name.is_gensymed() && ident.name != "_"); // Note that as_str() de-gensyms the Symbol
!(ident.name.is_gensymed() && ident.name.as_str() != "_");
if is_good_import || binding.is_macro_def() { if is_good_import || binding.is_macro_def() {
let res = binding.res(); let res = binding.res();
if res != Res::Err { if res != Res::Err {

8
src/librustc_save_analysis/lib.rs
View file

@ -879,7 +879,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
let mut result = String::new(); let mut result = String::new();
for attr in attrs { for attr in attrs {
if attr.check_name("doc") { if attr.check_name(sym::doc) {
if let Some(val) = attr.value_str() { if let Some(val) = attr.value_str() {
if attr.is_sugared_doc { if attr.is_sugared_doc {
result.push_str(&strip_doc_comment_decoration(&val.as_str())); result.push_str(&strip_doc_comment_decoration(&val.as_str()));
@ -889,10 +889,10 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
result.push('\n'); result.push('\n');
} else if let Some(meta_list) = attr.meta_item_list() { } else if let Some(meta_list) = attr.meta_item_list() {
meta_list.into_iter() meta_list.into_iter()
.filter(|it| it.check_name("include")) .filter(|it| it.check_name(sym::include))
.filter_map(|it| it.meta_item_list().map(|l| l.to_owned())) .filter_map(|it| it.meta_item_list().map(|l| l.to_owned()))
.flat_map(|it| it) .flat_map(|it| it)
.filter(|meta| meta.check_name("contents")) .filter(|meta| meta.check_name(sym::contents))
.filter_map(|meta| meta.value_str()) .filter_map(|meta| meta.value_str())
.for_each(|val| { .for_each(|val| {
result.push_str(&val.as_str()); result.push_str(&val.as_str());
@ -1197,7 +1197,7 @@ fn null_id() -> rls_data::Id {
fn lower_attributes(attrs: Vec<Attribute>, scx: &SaveContext<'_, '_>) -> Vec<rls_data::Attribute> { fn lower_attributes(attrs: Vec<Attribute>, scx: &SaveContext<'_, '_>) -> Vec<rls_data::Attribute> {
attrs.into_iter() attrs.into_iter()
// Only retain real attributes. Doc comments are lowered separately. // Only retain real attributes. Doc comments are lowered separately.
.filter(|attr| attr.path != "doc") .filter(|attr| attr.path != sym::doc)
.map(|mut attr| { .map(|mut attr| {
// Remove the surrounding '#[..]' or '#![..]' of the pretty printed // Remove the surrounding '#[..]' or '#![..]' of the pretty printed
// attribute. First normalize all inner attribute (#![..]) to outer // attribute. First normalize all inner attribute (#![..]) to outer

5
src/librustc_traits/lowering/mod.rs
View file

@ -21,6 +21,7 @@ use rustc::ty::query::Providers;
use rustc::ty::{self, List, TyCtxt}; use rustc::ty::{self, List, TyCtxt};
use rustc::ty::subst::{Subst, InternalSubsts}; use rustc::ty::subst::{Subst, InternalSubsts};
use syntax::ast; use syntax::ast;
use syntax::symbol::sym;
use std::iter; use std::iter;
@ -640,11 +641,11 @@ impl<'a, 'tcx> ClauseDumper<'a, 'tcx> {
for attr in attrs { for attr in attrs {
let mut clauses = None; let mut clauses = None;
if attr.check_name("rustc_dump_program_clauses") { if attr.check_name(sym::rustc_dump_program_clauses) {
clauses = Some(self.tcx.program_clauses_for(def_id)); clauses = Some(self.tcx.program_clauses_for(def_id));
} }
if attr.check_name("rustc_dump_env_program_clauses") { if attr.check_name(sym::rustc_dump_env_program_clauses) {
let environment = self.tcx.environment(def_id); let environment = self.tcx.environment(def_id);
clauses = Some(self.tcx.program_clauses_for_env(environment)); clauses = Some(self.tcx.program_clauses_for_env(environment));
} }

3
src/librustc_typeck/astconv.rs
View file

@ -25,6 +25,7 @@ use syntax::ast;
use syntax::feature_gate::{GateIssue, emit_feature_err}; use syntax::feature_gate::{GateIssue, emit_feature_err};
use syntax::ptr::P; use syntax::ptr::P;
use syntax::util::lev_distance::find_best_match_for_name; use syntax::util::lev_distance::find_best_match_for_name;
use syntax::symbol::sym;
use syntax_pos::{DUMMY_SP, Span, MultiSpan}; use syntax_pos::{DUMMY_SP, Span, MultiSpan};
use crate::util::common::ErrorReported; use crate::util::common::ErrorReported;
use crate::util::nodemap::FxHashMap; use crate::util::nodemap::FxHashMap;
@ -802,7 +803,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> dyn AstConv<'gcx, 'tcx> + 'o {
} else { } else {
"parenthetical notation is only stable when used with `Fn`-family traits" "parenthetical notation is only stable when used with `Fn`-family traits"
}; };
emit_feature_err(&self.tcx().sess.parse_sess, "unboxed_closures", emit_feature_err(&self.tcx().sess.parse_sess, sym::unboxed_closures,
span, GateIssue::Language, msg); span, GateIssue::Language, msg);
} }

3
src/librustc_typeck/check/coercion.rs
View file

@ -68,6 +68,7 @@ use smallvec::{smallvec, SmallVec};
use std::ops::Deref; use std::ops::Deref;
use syntax::feature_gate; use syntax::feature_gate;
use syntax::ptr::P; use syntax::ptr::P;
use syntax::symbol::sym;
use syntax_pos; use syntax_pos;
struct Coerce<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> { struct Coerce<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> {
@ -620,7 +621,7 @@ impl<'f, 'gcx, 'tcx> Coerce<'f, 'gcx, 'tcx> {
if has_unsized_tuple_coercion && !self.tcx.features().unsized_tuple_coercion { if has_unsized_tuple_coercion && !self.tcx.features().unsized_tuple_coercion {
feature_gate::emit_feature_err(&self.tcx.sess.parse_sess, feature_gate::emit_feature_err(&self.tcx.sess.parse_sess,
"unsized_tuple_coercion", sym::unsized_tuple_coercion,
self.cause.span, self.cause.span,
feature_gate::GateIssue::Language, feature_gate::GateIssue::Language,
feature_gate::EXPLAIN_UNSIZED_TUPLE_COERCION); feature_gate::EXPLAIN_UNSIZED_TUPLE_COERCION);

3
src/librustc_typeck/check/demand.rs
View file

@ -2,6 +2,7 @@ use crate::check::FnCtxt;
use rustc::infer::InferOk; use rustc::infer::InferOk;
use rustc::traits::{self, ObligationCause, ObligationCauseCode}; use rustc::traits::{self, ObligationCause, ObligationCauseCode};
use syntax::symbol::sym;
use syntax::util::parser::PREC_POSTFIX; use syntax::util::parser::PREC_POSTFIX;
use syntax_pos::Span; use syntax_pos::Span;
use rustc::hir; use rustc::hir;
@ -197,7 +198,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
// //
// FIXME? Other potential candidate methods: `as_ref` and // FIXME? Other potential candidate methods: `as_ref` and
// `as_mut`? // `as_mut`?
.find(|a| a.check_name("rustc_conversion_suggestion")).is_some() .find(|a| a.check_name(sym::rustc_conversion_suggestion)).is_some()
}); });
methods methods

11
src/librustc_typeck/check/mod.rs
View file

@ -123,7 +123,7 @@ use syntax::attr;
use syntax::feature_gate::{GateIssue, emit_feature_err}; use syntax::feature_gate::{GateIssue, emit_feature_err};
use syntax::ptr::P; use syntax::ptr::P;
use syntax::source_map::{DUMMY_SP, original_sp}; use syntax::source_map::{DUMMY_SP, original_sp};
use syntax::symbol::{Symbol, LocalInternedString, keywords}; use syntax::symbol::{Symbol, LocalInternedString, keywords, sym};
use syntax::util::lev_distance::find_best_match_for_name; use syntax::util::lev_distance::find_best_match_for_name;
use std::cell::{Cell, RefCell, Ref, RefMut}; use std::cell::{Cell, RefCell, Ref, RefMut};
@ -1840,7 +1840,7 @@ pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
if vs.is_empty() { if vs.is_empty() {
let attributes = tcx.get_attrs(def_id); let attributes = tcx.get_attrs(def_id);
if let Some(attr) = attr::find_by_name(&attributes, "repr") { if let Some(attr) = attr::find_by_name(&attributes, sym::repr) {
struct_span_err!( struct_span_err!(
tcx.sess, attr.span, E0084, tcx.sess, attr.span, E0084,
"unsupported representation for zero-variant enum") "unsupported representation for zero-variant enum")
@ -1853,7 +1853,7 @@ pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 { if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
if !tcx.features().repr128 { if !tcx.features().repr128 {
emit_feature_err(&tcx.sess.parse_sess, emit_feature_err(&tcx.sess.parse_sess,
"repr128", sym::repr128,
sp, sp,
GateIssue::Language, GateIssue::Language,
"repr with 128-bit type is unstable"); "repr with 128-bit type is unstable");
@ -4197,7 +4197,8 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
// ... except when we try to 'break rust;'. // ... except when we try to 'break rust;'.
// ICE this expression in particular (see #43162). // ICE this expression in particular (see #43162).
if let ExprKind::Path(QPath::Resolved(_, ref path)) = e.node { if let ExprKind::Path(QPath::Resolved(_, ref path)) = e.node {
if path.segments.len() == 1 && path.segments[0].ident.name == "rust" { if path.segments.len() == 1 &&
path.segments[0].ident.name == sym::rust {
fatally_break_rust(self.tcx.sess); fatally_break_rust(self.tcx.sess);
} }
} }
@ -5499,7 +5500,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
span: Span) { span: Span) {
// We're only interested in functions tagged with // We're only interested in functions tagged with
// #[rustc_args_required_const], so ignore anything that's not. // #[rustc_args_required_const], so ignore anything that's not.
if !self.tcx.has_attr(def_id, "rustc_args_required_const") { if !self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
return return
} }

3
src/librustc_typeck/check/wfcheck.rs
View file

@ -13,6 +13,7 @@ use rustc::infer::opaque_types::may_define_existential_type;
use syntax::ast; use syntax::ast;
use syntax::feature_gate::{self, GateIssue}; use syntax::feature_gate::{self, GateIssue};
use syntax_pos::Span; use syntax_pos::Span;
use syntax::symbol::sym;
use errors::{DiagnosticBuilder, DiagnosticId}; use errors::{DiagnosticBuilder, DiagnosticId};
use rustc::hir::itemlikevisit::ParItemLikeVisitor; use rustc::hir::itemlikevisit::ParItemLikeVisitor;
@ -796,7 +797,7 @@ fn check_method_receiver<'fcx, 'gcx, 'tcx>(fcx: &FnCtxt<'fcx, 'gcx, 'tcx>,
// report error, would have worked with arbitrary_self_types // report error, would have worked with arbitrary_self_types
feature_gate::feature_err( feature_gate::feature_err(
&fcx.tcx.sess.parse_sess, &fcx.tcx.sess.parse_sess,
"arbitrary_self_types", sym::arbitrary_self_types,
span, span,
GateIssue::Language, GateIssue::Language,
&format!( &format!(

5
src/librustc_typeck/check/writeback.rs
View file

@ -16,6 +16,7 @@ use rustc::mir::interpret::ConstValue;
use rustc::util::nodemap::DefIdSet; use rustc::util::nodemap::DefIdSet;
use rustc_data_structures::sync::Lrc; use rustc_data_structures::sync::Lrc;
use std::mem; use std::mem;
use syntax::symbol::sym;
use syntax_pos::Span; use syntax_pos::Span;
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
@ -36,8 +37,8 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
let item_def_id = self.tcx.hir().local_def_id(item_id); let item_def_id = self.tcx.hir().local_def_id(item_id);
// This attribute causes us to dump some writeback information // This attribute causes us to dump some writeback information
// in the form of errors, which is used for unit tests. // in the form of errors, which is uSymbolfor unit tests.
let rustc_dump_user_substs = self.tcx.has_attr(item_def_id, "rustc_dump_user_substs"); let rustc_dump_user_substs = self.tcx.has_attr(item_def_id, sym::rustc_dump_user_substs);
let mut wbcx = WritebackCx::new(self, body, rustc_dump_user_substs); let mut wbcx = WritebackCx::new(self, body, rustc_dump_user_substs);
for arg in &body.arguments { for arg in &body.arguments {

88
src/librustc_typeck/collect.rs
View file

@ -39,7 +39,7 @@ use syntax::ast::{Ident, MetaItemKind};
use syntax::attr::{InlineAttr, OptimizeAttr, list_contains_name, mark_used}; use syntax::attr::{InlineAttr, OptimizeAttr, list_contains_name, mark_used};
use syntax::source_map::Spanned; use syntax::source_map::Spanned;
use syntax::feature_gate; use syntax::feature_gate;
use syntax::symbol::{keywords, Symbol}; use syntax::symbol::{keywords, Symbol, sym};
use syntax_pos::{Span, DUMMY_SP}; use syntax_pos::{Span, DUMMY_SP};
use rustc::hir::def::{CtorKind, Res, DefKind}; use rustc::hir::def::{CtorKind, Res, DefKind};
@ -750,7 +750,7 @@ fn trait_def<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> &'tcx ty::
_ => span_bug!(item.span, "trait_def_of_item invoked on non-trait"), _ => span_bug!(item.span, "trait_def_of_item invoked on non-trait"),
}; };
let paren_sugar = tcx.has_attr(def_id, "rustc_paren_sugar"); let paren_sugar = tcx.has_attr(def_id, sym::rustc_paren_sugar);
if paren_sugar && !tcx.features().unboxed_closures { if paren_sugar && !tcx.features().unboxed_closures {
let mut err = tcx.sess.struct_span_err( let mut err = tcx.sess.struct_span_err(
item.span, item.span,
@ -765,7 +765,7 @@ fn trait_def<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> &'tcx ty::
err.emit(); err.emit();
} }
let is_marker = tcx.has_attr(def_id, "marker"); let is_marker = tcx.has_attr(def_id, sym::marker);
let def_path_hash = tcx.def_path_hash(def_id); let def_path_hash = tcx.def_path_hash(def_id);
let def = ty::TraitDef::new(def_id, unsafety, paren_sugar, is_auto, is_marker, def_path_hash); let def = ty::TraitDef::new(def_id, unsafety, paren_sugar, is_auto, is_marker, def_path_hash);
tcx.alloc_trait_def(def) tcx.alloc_trait_def(def)
@ -2382,7 +2382,7 @@ fn from_target_feature(
tcx: TyCtxt<'_, '_, '_>, tcx: TyCtxt<'_, '_, '_>,
id: DefId, id: DefId,
attr: &ast::Attribute, attr: &ast::Attribute,
whitelist: &FxHashMap<String, Option<String>>, whitelist: &FxHashMap<String, Option<Symbol>>,
target_features: &mut Vec<Symbol>, target_features: &mut Vec<Symbol>,
) { ) {
let list = match attr.meta_item_list() { let list = match attr.meta_item_list() {
@ -2392,7 +2392,7 @@ fn from_target_feature(
let rust_features = tcx.features(); let rust_features = tcx.features();
for item in list { for item in list {
// Only `enable = ...` is accepted in the meta item list // Only `enable = ...` is accepted in the meta item list
if !item.check_name("enable") { if !item.check_name(sym::enable) {
let msg = "#[target_feature(..)] only accepts sub-keys of `enable` \ let msg = "#[target_feature(..)] only accepts sub-keys of `enable` \
currently"; currently";
tcx.sess.span_err(item.span(), &msg); tcx.sess.span_err(item.span(), &msg);
@ -2435,29 +2435,29 @@ fn from_target_feature(
}; };
// Only allow features whose feature gates have been enabled // Only allow features whose feature gates have been enabled
let allowed = match feature_gate.as_ref().map(|s| &**s) { let allowed = match feature_gate.as_ref().map(|s| *s) {
Some("arm_target_feature") => rust_features.arm_target_feature, Some(sym::arm_target_feature) => rust_features.arm_target_feature,
Some("aarch64_target_feature") => rust_features.aarch64_target_feature, Some(sym::aarch64_target_feature) => rust_features.aarch64_target_feature,
Some("hexagon_target_feature") => rust_features.hexagon_target_feature, Some(sym::hexagon_target_feature) => rust_features.hexagon_target_feature,
Some("powerpc_target_feature") => rust_features.powerpc_target_feature, Some(sym::powerpc_target_feature) => rust_features.powerpc_target_feature,
Some("mips_target_feature") => rust_features.mips_target_feature, Some(sym::mips_target_feature) => rust_features.mips_target_feature,
Some("avx512_target_feature") => rust_features.avx512_target_feature, Some(sym::avx512_target_feature) => rust_features.avx512_target_feature,
Some("mmx_target_feature") => rust_features.mmx_target_feature, Some(sym::mmx_target_feature) => rust_features.mmx_target_feature,
Some("sse4a_target_feature") => rust_features.sse4a_target_feature, Some(sym::sse4a_target_feature) => rust_features.sse4a_target_feature,
Some("tbm_target_feature") => rust_features.tbm_target_feature, Some(sym::tbm_target_feature) => rust_features.tbm_target_feature,
Some("wasm_target_feature") => rust_features.wasm_target_feature, Some(sym::wasm_target_feature) => rust_features.wasm_target_feature,
Some("cmpxchg16b_target_feature") => rust_features.cmpxchg16b_target_feature, Some(sym::cmpxchg16b_target_feature) => rust_features.cmpxchg16b_target_feature,
Some("adx_target_feature") => rust_features.adx_target_feature, Some(sym::adx_target_feature) => rust_features.adx_target_feature,
Some("movbe_target_feature") => rust_features.movbe_target_feature, Some(sym::movbe_target_feature) => rust_features.movbe_target_feature,
Some("rtm_target_feature") => rust_features.rtm_target_feature, Some(sym::rtm_target_feature) => rust_features.rtm_target_feature,
Some("f16c_target_feature") => rust_features.f16c_target_feature, Some(sym::f16c_target_feature) => rust_features.f16c_target_feature,
Some(name) => bug!("unknown target feature gate {}", name), Some(name) => bug!("unknown target feature gate {}", name),
None => true, None => true,
}; };
if !allowed && id.is_local() { if !allowed && id.is_local() {
feature_gate::emit_feature_err( feature_gate::emit_feature_err(
&tcx.sess.parse_sess, &tcx.sess.parse_sess,
feature_gate.as_ref().unwrap(), feature_gate.unwrap(),
item.span(), item.span(),
feature_gate::GateIssue::Language, feature_gate::GateIssue::Language,
&format!("the target feature `{}` is currently unstable", feature), &format!("the target feature `{}` is currently unstable", feature),
@ -2512,13 +2512,13 @@ fn codegen_fn_attrs<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, id: DefId) -> Codegen
let mut inline_span = None; let mut inline_span = None;
for attr in attrs.iter() { for attr in attrs.iter() {
if attr.check_name("cold") { if attr.check_name(sym::cold) {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::COLD; codegen_fn_attrs.flags |= CodegenFnAttrFlags::COLD;
} else if attr.check_name("allocator") { } else if attr.check_name(sym::allocator) {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::ALLOCATOR; codegen_fn_attrs.flags |= CodegenFnAttrFlags::ALLOCATOR;
} else if attr.check_name("unwind") { } else if attr.check_name(sym::unwind) {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::UNWIND; codegen_fn_attrs.flags |= CodegenFnAttrFlags::UNWIND;
} else if attr.check_name("ffi_returns_twice") { } else if attr.check_name(sym::ffi_returns_twice) {
if tcx.is_foreign_item(id) { if tcx.is_foreign_item(id) {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::FFI_RETURNS_TWICE; codegen_fn_attrs.flags |= CodegenFnAttrFlags::FFI_RETURNS_TWICE;
} else { } else {
@ -2530,21 +2530,21 @@ fn codegen_fn_attrs<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, id: DefId) -> Codegen
"`#[ffi_returns_twice]` may only be used on foreign functions" "`#[ffi_returns_twice]` may only be used on foreign functions"
).emit(); ).emit();
} }
} else if attr.check_name("rustc_allocator_nounwind") { } else if attr.check_name(sym::rustc_allocator_nounwind) {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::RUSTC_ALLOCATOR_NOUNWIND; codegen_fn_attrs.flags |= CodegenFnAttrFlags::RUSTC_ALLOCATOR_NOUNWIND;
} else if attr.check_name("naked") { } else if attr.check_name(sym::naked) {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::NAKED; codegen_fn_attrs.flags |= CodegenFnAttrFlags::NAKED;
} else if attr.check_name("no_mangle") { } else if attr.check_name(sym::no_mangle) {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::NO_MANGLE; codegen_fn_attrs.flags |= CodegenFnAttrFlags::NO_MANGLE;
} else if attr.check_name("rustc_std_internal_symbol") { } else if attr.check_name(sym::rustc_std_internal_symbol) {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL; codegen_fn_attrs.flags |= CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL;
} else if attr.check_name("no_debug") { } else if attr.check_name(sym::no_debug) {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::NO_DEBUG; codegen_fn_attrs.flags |= CodegenFnAttrFlags::NO_DEBUG;
} else if attr.check_name("used") { } else if attr.check_name(sym::used) {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::USED; codegen_fn_attrs.flags |= CodegenFnAttrFlags::USED;
} else if attr.check_name("thread_local") { } else if attr.check_name(sym::thread_local) {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::THREAD_LOCAL; codegen_fn_attrs.flags |= CodegenFnAttrFlags::THREAD_LOCAL;
} else if attr.check_name("export_name") { } else if attr.check_name(sym::export_name) {
if let Some(s) = attr.value_str() { if let Some(s) = attr.value_str() {
if s.as_str().contains("\0") { if s.as_str().contains("\0") {
// `#[export_name = ...]` will be converted to a null-terminated string, // `#[export_name = ...]` will be converted to a null-terminated string,
@ -2558,7 +2558,7 @@ fn codegen_fn_attrs<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, id: DefId) -> Codegen
} }
codegen_fn_attrs.export_name = Some(s); codegen_fn_attrs.export_name = Some(s);
} }
} else if attr.check_name("target_feature") { } else if attr.check_name(sym::target_feature) {
if tcx.fn_sig(id).unsafety() == Unsafety::Normal { if tcx.fn_sig(id).unsafety() == Unsafety::Normal {
let msg = "#[target_feature(..)] can only be applied to \ let msg = "#[target_feature(..)] can only be applied to \
`unsafe` function"; `unsafe` function";
@ -2571,11 +2571,11 @@ fn codegen_fn_attrs<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, id: DefId) -> Codegen
&whitelist, &whitelist,
&mut codegen_fn_attrs.target_features, &mut codegen_fn_attrs.target_features,
); );
} else if attr.check_name("linkage") { } else if attr.check_name(sym::linkage) {
if let Some(val) = attr.value_str() { if let Some(val) = attr.value_str() {
codegen_fn_attrs.linkage = Some(linkage_by_name(tcx, id, &val.as_str())); codegen_fn_attrs.linkage = Some(linkage_by_name(tcx, id, &val.as_str()));
} }
} else if attr.check_name("link_section") { } else if attr.check_name(sym::link_section) {
if let Some(val) = attr.value_str() { if let Some(val) = attr.value_str() {
if val.as_str().bytes().any(|b| b == 0) { if val.as_str().bytes().any(|b| b == 0) {
let msg = format!( let msg = format!(
@ -2588,13 +2588,13 @@ fn codegen_fn_attrs<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, id: DefId) -> Codegen
codegen_fn_attrs.link_section = Some(val); codegen_fn_attrs.link_section = Some(val);
} }
} }
} else if attr.check_name("link_name") { } else if attr.check_name(sym::link_name) {
codegen_fn_attrs.link_name = attr.value_str(); codegen_fn_attrs.link_name = attr.value_str();
} }
} }
codegen_fn_attrs.inline = attrs.iter().fold(InlineAttr::None, |ia, attr| { codegen_fn_attrs.inline = attrs.iter().fold(InlineAttr::None, |ia, attr| {
if attr.path != "inline" { if attr.path != sym::inline {
return ia; return ia;
} }
match attr.meta().map(|i| i.node) { match attr.meta().map(|i| i.node) {
@ -2613,9 +2613,9 @@ fn codegen_fn_attrs<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, id: DefId) -> Codegen
"expected one argument" "expected one argument"
); );
InlineAttr::None InlineAttr::None
} else if list_contains_name(&items[..], "always") { } else if list_contains_name(&items[..], sym::always) {
InlineAttr::Always InlineAttr::Always
} else if list_contains_name(&items[..], "never") { } else if list_contains_name(&items[..], sym::never) {
InlineAttr::Never InlineAttr::Never
} else { } else {
span_err!( span_err!(
@ -2634,7 +2634,7 @@ fn codegen_fn_attrs<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, id: DefId) -> Codegen
}); });
codegen_fn_attrs.optimize = attrs.iter().fold(OptimizeAttr::None, |ia, attr| { codegen_fn_attrs.optimize = attrs.iter().fold(OptimizeAttr::None, |ia, attr| {
if attr.path != "optimize" { if attr.path != sym::optimize {
return ia; return ia;
} }
let err = |sp, s| span_err!(tcx.sess.diagnostic(), sp, E0722, "{}", s); let err = |sp, s| span_err!(tcx.sess.diagnostic(), sp, E0722, "{}", s);
@ -2649,9 +2649,9 @@ fn codegen_fn_attrs<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, id: DefId) -> Codegen
if items.len() != 1 { if items.len() != 1 {
err(attr.span, "expected one argument"); err(attr.span, "expected one argument");
OptimizeAttr::None OptimizeAttr::None
} else if list_contains_name(&items[..], "size") { } else if list_contains_name(&items[..], sym::size) {
OptimizeAttr::Size OptimizeAttr::Size
} else if list_contains_name(&items[..], "speed") { } else if list_contains_name(&items[..], sym::speed) {
OptimizeAttr::Speed OptimizeAttr::Speed
} else { } else {
err(items[0].span(), "invalid argument"); err(items[0].span(), "invalid argument");

3
src/librustc_typeck/outlives/mod.rs
View file

@ -5,6 +5,7 @@ use rustc::ty::query::Providers;
use rustc::ty::subst::UnpackedKind; use rustc::ty::subst::UnpackedKind;
use rustc::ty::{self, CratePredicatesMap, TyCtxt}; use rustc::ty::{self, CratePredicatesMap, TyCtxt};
use rustc_data_structures::sync::Lrc; use rustc_data_structures::sync::Lrc;
use syntax::symbol::sym;
mod explicit; mod explicit;
mod implicit_infer; mod implicit_infer;
@ -40,7 +41,7 @@ fn inferred_outlives_of<'a, 'tcx>(
.map(|p| *p) .map(|p| *p)
.unwrap_or(&[]); .unwrap_or(&[]);
if tcx.has_attr(item_def_id, "rustc_outlives") { if tcx.has_attr(item_def_id, sym::rustc_outlives) {
let mut pred: Vec<String> = predicates let mut pred: Vec<String> = predicates
.iter() .iter()
.map(|out_pred| match out_pred { .map(|out_pred| match out_pred {

3
src/librustc_typeck/outlives/test.rs
View file

@ -1,6 +1,7 @@
use rustc::hir; use rustc::hir;
use rustc::hir::itemlikevisit::ItemLikeVisitor; use rustc::hir::itemlikevisit::ItemLikeVisitor;
use rustc::ty::TyCtxt; use rustc::ty::TyCtxt;
use syntax::symbol::sym;
pub fn test_inferred_outlives<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) { pub fn test_inferred_outlives<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
tcx.hir() tcx.hir()
@ -18,7 +19,7 @@ impl<'a, 'tcx> ItemLikeVisitor<'tcx> for OutlivesTest<'a, 'tcx> {
// For unit testing: check for a special "rustc_outlives" // For unit testing: check for a special "rustc_outlives"
// attribute and report an error with various results if found. // attribute and report an error with various results if found.
if self.tcx.has_attr(item_def_id, "rustc_outlives") { if self.tcx.has_attr(item_def_id, sym::rustc_outlives) {
let inferred_outlives_of = self.tcx.inferred_outlives_of(item_def_id); let inferred_outlives_of = self.tcx.inferred_outlives_of(item_def_id);
span_err!( span_err!(
self.tcx.sess, self.tcx.sess,

3
src/librustc_typeck/variance/test.rs
View file

@ -1,6 +1,7 @@
use rustc::hir; use rustc::hir;
use rustc::hir::itemlikevisit::ItemLikeVisitor; use rustc::hir::itemlikevisit::ItemLikeVisitor;
use rustc::ty::TyCtxt; use rustc::ty::TyCtxt;
use syntax::symbol::sym;
pub fn test_variance<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) { pub fn test_variance<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
tcx.hir().krate().visit_all_item_likes(&mut VarianceTest { tcx }); tcx.hir().krate().visit_all_item_likes(&mut VarianceTest { tcx });
@ -16,7 +17,7 @@ impl<'a, 'tcx> ItemLikeVisitor<'tcx> for VarianceTest<'a, 'tcx> {
// For unit testing: check for a special "rustc_variance" // For unit testing: check for a special "rustc_variance"
// attribute and report an error with various results if found. // attribute and report an error with various results if found.
if self.tcx.has_attr(item_def_id, "rustc_variance") { if self.tcx.has_attr(item_def_id, sym::rustc_variance) {
let variances_of = self.tcx.variances_of(item_def_id); let variances_of = self.tcx.variances_of(item_def_id);
span_err!(self.tcx.sess, span_err!(self.tcx.sess,
item.span, item.span,

4
src/librustdoc/clean/cfg.rs
View file

@ -7,7 +7,7 @@ use std::mem;
use std::fmt::{self, Write}; use std::fmt::{self, Write};
use std::ops; use std::ops;
use syntax::symbol::Symbol; use syntax::symbol::{Symbol, sym};
use syntax::ast::{MetaItem, MetaItemKind, NestedMetaItem, LitKind}; use syntax::ast::{MetaItem, MetaItemKind, NestedMetaItem, LitKind};
use syntax::parse::ParseSess; use syntax::parse::ParseSess;
use syntax::feature_gate::Features; use syntax::feature_gate::Features;
@ -186,7 +186,7 @@ impl Cfg {
fn should_use_with_in_description(&self) -> bool { fn should_use_with_in_description(&self) -> bool {
match *self { match *self {
Cfg::Cfg(ref name, _) if name == &"target_feature" => true, Cfg::Cfg(name, _) if name == sym::target_feature => true,
_ => false, _ => false,
} }
} }

3
src/librustdoc/clean/inline.rs
View file

@ -4,6 +4,7 @@ use std::iter::once;
use syntax::ast; use syntax::ast;
use syntax::ext::base::{MacroKind, SyntaxExtension}; use syntax::ext::base::{MacroKind, SyntaxExtension};
use syntax::symbol::sym;
use syntax_pos::Span; use syntax_pos::Span;
use rustc::hir; use rustc::hir;
@ -186,7 +187,7 @@ pub fn build_external_trait(cx: &DocContext<'_>, did: DefId) -> clean::Trait {
let generics = (cx.tcx.generics_of(did), &predicates).clean(cx); let generics = (cx.tcx.generics_of(did), &predicates).clean(cx);
let generics = filter_non_trait_generics(did, generics); let generics = filter_non_trait_generics(did, generics);
let (generics, supertrait_bounds) = separate_supertrait_bounds(generics); let (generics, supertrait_bounds) = separate_supertrait_bounds(generics);
let is_spotlight = load_attrs(cx, did).has_doc_flag("spotlight"); let is_spotlight = load_attrs(cx, did).has_doc_flag(sym::spotlight);
let is_auto = cx.tcx.trait_is_auto(did); let is_auto = cx.tcx.trait_is_auto(did);
clean::Trait { clean::Trait {
auto: auto_trait, auto: auto_trait,

63
src/librustdoc/clean/mod.rs
View file

@ -32,6 +32,7 @@ use syntax::ext::base::MacroKind;
use syntax::source_map::{dummy_spanned, Spanned}; use syntax::source_map::{dummy_spanned, Spanned};
use syntax::ptr::P; use syntax::ptr::P;
use syntax::symbol::keywords::{self, Keyword}; use syntax::symbol::keywords::{self, Keyword};
use syntax::symbol::{Symbol, sym};
use syntax::symbol::InternedString; use syntax::symbol::InternedString;
use syntax_pos::{self, Pos, FileName}; use syntax_pos::{self, Pos, FileName};
@ -170,7 +171,7 @@ impl<'a, 'tcx> Clean<Crate> for visit_ast::RustdocVisitor<'a, 'tcx> {
// `compiler_builtins` should be masked too, but we can't apply // `compiler_builtins` should be masked too, but we can't apply
// `#[doc(masked)]` to the injected `extern crate` because it's unstable. // `#[doc(masked)]` to the injected `extern crate` because it's unstable.
if it.is_extern_crate() if it.is_extern_crate()
&& (it.attrs.has_doc_flag("masked") && (it.attrs.has_doc_flag(sym::masked)
|| self.cx.tcx.is_compiler_builtins(it.def_id.krate)) || self.cx.tcx.is_compiler_builtins(it.def_id.krate))
{ {
masked_crates.insert(it.def_id.krate); masked_crates.insert(it.def_id.krate);
@ -261,9 +262,9 @@ impl Clean<ExternalCrate> for CrateNum {
if let Res::Def(DefKind::Mod, def_id) = res { if let Res::Def(DefKind::Mod, def_id) = res {
let attrs = cx.tcx.get_attrs(def_id).clean(cx); let attrs = cx.tcx.get_attrs(def_id).clean(cx);
let mut prim = None; let mut prim = None;
for attr in attrs.lists("doc") { for attr in attrs.lists(sym::doc) {
if let Some(v) = attr.value_str() { if let Some(v) = attr.value_str() {
if attr.check_name("primitive") { if attr.check_name(sym::primitive) {
prim = PrimitiveType::from_str(&v.as_str()); prim = PrimitiveType::from_str(&v.as_str());
if prim.is_some() { if prim.is_some() {
break; break;
@ -305,9 +306,9 @@ impl Clean<ExternalCrate> for CrateNum {
if let Res::Def(DefKind::Mod, def_id) = res { if let Res::Def(DefKind::Mod, def_id) = res {
let attrs = cx.tcx.get_attrs(def_id).clean(cx); let attrs = cx.tcx.get_attrs(def_id).clean(cx);
let mut keyword = None; let mut keyword = None;
for attr in attrs.lists("doc") { for attr in attrs.lists(sym::doc) {
if let Some(v) = attr.value_str() { if let Some(v) = attr.value_str() {
if attr.check_name("keyword") { if attr.check_name(sym::keyword) {
keyword = Keyword::from_str(&v.as_str()).ok() keyword = Keyword::from_str(&v.as_str()).ok()
.map(|x| x.name().to_string()); .map(|x| x.name().to_string());
if keyword.is_some() { if keyword.is_some() {
@ -501,7 +502,7 @@ impl Item {
pub fn is_non_exhaustive(&self) -> bool { pub fn is_non_exhaustive(&self) -> bool {
self.attrs.other_attrs.iter() self.attrs.other_attrs.iter()
.any(|a| a.check_name("non_exhaustive")) .any(|a| a.check_name(sym::non_exhaustive))
} }
/// Returns a documentation-level item type from the item. /// Returns a documentation-level item type from the item.
@ -669,7 +670,7 @@ impl Clean<Item> for doctree::Module {
pub struct ListAttributesIter<'a> { pub struct ListAttributesIter<'a> {
attrs: slice::Iter<'a, ast::Attribute>, attrs: slice::Iter<'a, ast::Attribute>,
current_list: vec::IntoIter<ast::NestedMetaItem>, current_list: vec::IntoIter<ast::NestedMetaItem>,
name: &'a str name: Symbol,
} }
impl<'a> Iterator for ListAttributesIter<'a> { impl<'a> Iterator for ListAttributesIter<'a> {
@ -702,11 +703,11 @@ impl<'a> Iterator for ListAttributesIter<'a> {
pub trait AttributesExt { pub trait AttributesExt {
/// Finds an attribute as List and returns the list of attributes nested inside. /// Finds an attribute as List and returns the list of attributes nested inside.
fn lists<'a>(&'a self, name: &'a str) -> ListAttributesIter<'a>; fn lists<'a>(&'a self, name: Symbol) -> ListAttributesIter<'a>;
} }
impl AttributesExt for [ast::Attribute] { impl AttributesExt for [ast::Attribute] {
fn lists<'a>(&'a self, name: &'a str) -> ListAttributesIter<'a> { fn lists<'a>(&'a self, name: Symbol) -> ListAttributesIter<'a> {
ListAttributesIter { ListAttributesIter {
attrs: self.iter(), attrs: self.iter(),
current_list: Vec::new().into_iter(), current_list: Vec::new().into_iter(),
@ -717,11 +718,11 @@ impl AttributesExt for [ast::Attribute] {
pub trait NestedAttributesExt { pub trait NestedAttributesExt {
/// Returns `true` if the attribute list contains a specific `Word` /// Returns `true` if the attribute list contains a specific `Word`
fn has_word(self, word: &str) -> bool; fn has_word(self, word: Symbol) -> bool;
} }
impl<I: IntoIterator<Item=ast::NestedMetaItem>> NestedAttributesExt for I { impl<I: IntoIterator<Item=ast::NestedMetaItem>> NestedAttributesExt for I {
fn has_word(self, word: &str) -> bool { fn has_word(self, word: Symbol) -> bool {
self.into_iter().any(|attr| attr.is_word() && attr.check_name(word)) self.into_iter().any(|attr| attr.is_word() && attr.check_name(word))
} }
} }
@ -803,7 +804,7 @@ impl Attributes {
if let ast::MetaItemKind::List(ref nmis) = mi.node { if let ast::MetaItemKind::List(ref nmis) = mi.node {
if nmis.len() == 1 { if nmis.len() == 1 {
if let MetaItem(ref cfg_mi) = nmis[0] { if let MetaItem(ref cfg_mi) = nmis[0] {
if cfg_mi.check_name("cfg") { if cfg_mi.check_name(sym::cfg) {
if let ast::MetaItemKind::List(ref cfg_nmis) = cfg_mi.node { if let ast::MetaItemKind::List(ref cfg_nmis) = cfg_mi.node {
if cfg_nmis.len() == 1 { if cfg_nmis.len() == 1 {
if let MetaItem(ref content_mi) = cfg_nmis[0] { if let MetaItem(ref content_mi) = cfg_nmis[0] {
@ -827,7 +828,7 @@ impl Attributes {
{ {
mi.meta_item_list().and_then(|list| { mi.meta_item_list().and_then(|list| {
for meta in list { for meta in list {
if meta.check_name("include") { if meta.check_name(sym::include) {
// the actual compiled `#[doc(include="filename")]` gets expanded to // the actual compiled `#[doc(include="filename")]` gets expanded to
// `#[doc(include(file="filename", contents="file contents")]` so we need to // `#[doc(include(file="filename", contents="file contents")]` so we need to
// look for that instead // look for that instead
@ -836,11 +837,11 @@ impl Attributes {
let mut contents: Option<String> = None; let mut contents: Option<String> = None;
for it in list { for it in list {
if it.check_name("file") { if it.check_name(sym::file) {
if let Some(name) = it.value_str() { if let Some(name) = it.value_str() {
filename = Some(name.to_string()); filename = Some(name.to_string());
} }
} else if it.check_name("contents") { } else if it.check_name(sym::contents) {
if let Some(docs) = it.value_str() { if let Some(docs) = it.value_str() {
contents = Some(docs.to_string()); contents = Some(docs.to_string());
} }
@ -860,9 +861,9 @@ impl Attributes {
}) })
} }
pub fn has_doc_flag(&self, flag: &str) -> bool { pub fn has_doc_flag(&self, flag: Symbol) -> bool {
for attr in &self.other_attrs { for attr in &self.other_attrs {
if !attr.check_name("doc") { continue; } if !attr.check_name(sym::doc) { continue; }
if let Some(items) = attr.meta_item_list() { if let Some(items) = attr.meta_item_list() {
if items.iter().filter_map(|i| i.meta_item()).any(|it| it.check_name(flag)) { if items.iter().filter_map(|i| i.meta_item()).any(|it| it.check_name(flag)) {
@ -883,7 +884,7 @@ impl Attributes {
let other_attrs = attrs.iter().filter_map(|attr| { let other_attrs = attrs.iter().filter_map(|attr| {
attr.with_desugared_doc(|attr| { attr.with_desugared_doc(|attr| {
if attr.check_name("doc") { if attr.check_name(sym::doc) {
if let Some(mi) = attr.meta() { if let Some(mi) = attr.meta() {
if let Some(value) = mi.value_str() { if let Some(value) = mi.value_str() {
// Extracted #[doc = "..."] // Extracted #[doc = "..."]
@ -925,8 +926,8 @@ impl Attributes {
// treat #[target_feature(enable = "feat")] attributes as if they were // treat #[target_feature(enable = "feat")] attributes as if they were
// #[doc(cfg(target_feature = "feat"))] attributes as well // #[doc(cfg(target_feature = "feat"))] attributes as well
for attr in attrs.lists("target_feature") { for attr in attrs.lists(sym::target_feature) {
if attr.check_name("enable") { if attr.check_name(sym::enable) {
if let Some(feat) = attr.value_str() { if let Some(feat) = attr.value_str() {
let meta = attr::mk_name_value_item_str(Ident::from_str("target_feature"), let meta = attr::mk_name_value_item_str(Ident::from_str("target_feature"),
dummy_spanned(feat)); dummy_spanned(feat));
@ -938,7 +939,7 @@ impl Attributes {
} }
let inner_docs = attrs.iter() let inner_docs = attrs.iter()
.filter(|a| a.check_name("doc")) .filter(|a| a.check_name(sym::doc))
.next() .next()
.map_or(true, |a| a.style == AttrStyle::Inner); .map_or(true, |a| a.style == AttrStyle::Inner);
@ -1039,7 +1040,7 @@ impl Hash for Attributes {
} }
impl AttributesExt for Attributes { impl AttributesExt for Attributes {
fn lists<'a>(&'a self, name: &'a str) -> ListAttributesIter<'a> { fn lists<'a>(&'a self, name: Symbol) -> ListAttributesIter<'a> {
self.other_attrs.lists(name) self.other_attrs.lists(name)
} }
} }
@ -2133,7 +2134,7 @@ pub struct Trait {
impl Clean<Item> for doctree::Trait { impl Clean<Item> for doctree::Trait {
fn clean(&self, cx: &DocContext<'_>) -> Item { fn clean(&self, cx: &DocContext<'_>) -> Item {
let attrs = self.attrs.clean(cx); let attrs = self.attrs.clean(cx);
let is_spotlight = attrs.has_doc_flag("spotlight"); let is_spotlight = attrs.has_doc_flag(sym::spotlight);
Item { Item {
name: Some(self.name.clean(cx)), name: Some(self.name.clean(cx)),
attrs: attrs, attrs: attrs,
@ -3893,8 +3894,8 @@ impl Clean<Vec<Item>> for doctree::ExternCrate {
fn clean(&self, cx: &DocContext<'_>) -> Vec<Item> { fn clean(&self, cx: &DocContext<'_>) -> Vec<Item> {
let please_inline = self.vis.node.is_pub() && self.attrs.iter().any(|a| { let please_inline = self.vis.node.is_pub() && self.attrs.iter().any(|a| {
a.check_name("doc") && match a.meta_item_list() { a.check_name(sym::doc) && match a.meta_item_list() {
Some(l) => attr::list_contains_name(&l, "inline"), Some(l) => attr::list_contains_name(&l, sym::inline),
None => false, None => false,
} }
}); });
@ -3935,15 +3936,15 @@ impl Clean<Vec<Item>> for doctree::Import {
// #[doc(no_inline)] attribute is present. // #[doc(no_inline)] attribute is present.
// Don't inline doc(hidden) imports so they can be stripped at a later stage. // Don't inline doc(hidden) imports so they can be stripped at a later stage.
let mut denied = !self.vis.node.is_pub() || self.attrs.iter().any(|a| { let mut denied = !self.vis.node.is_pub() || self.attrs.iter().any(|a| {
a.check_name("doc") && match a.meta_item_list() { a.check_name(sym::doc) && match a.meta_item_list() {
Some(l) => attr::list_contains_name(&l, "no_inline") || Some(l) => attr::list_contains_name(&l, sym::no_inline) ||
attr::list_contains_name(&l, "hidden"), attr::list_contains_name(&l, sym::hidden),
None => false, None => false,
} }
}); });
// Also check whether imports were asked to be inlined, in case we're trying to re-export a // Also check whether imports were asked to be inlined, in case we're trying to re-export a
// crate in Rust 2018+ // crate in Rust 2018+
let please_inline = self.attrs.lists("doc").has_word("inline"); let please_inline = self.attrs.lists(sym::doc).has_word(sym::inline);
let path = self.path.clean(cx); let path = self.path.clean(cx);
let inner = if self.glob { let inner = if self.glob {
if !denied { if !denied {
@ -4382,7 +4383,7 @@ where
// Start of code copied from rust-clippy // Start of code copied from rust-clippy
pub fn path_to_def_local(tcx: TyCtxt<'_, '_, '_>, path: &[&str]) -> Option<DefId> { pub fn path_to_def_local(tcx: TyCtxt<'_, '_, '_>, path: &[Symbol]) -> Option<DefId> {
let krate = tcx.hir().krate(); let krate = tcx.hir().krate();
let mut items = krate.module.item_ids.clone(); let mut items = krate.module.item_ids.clone();
let mut path_it = path.iter().peekable(); let mut path_it = path.iter().peekable();
@ -4407,7 +4408,7 @@ pub fn path_to_def_local(tcx: TyCtxt<'_, '_, '_>, path: &[&str]) -> Option<DefId
} }
} }
pub fn path_to_def(tcx: TyCtxt<'_, '_, '_>, path: &[&str]) -> Option<DefId> { pub fn path_to_def(tcx: TyCtxt<'_, '_, '_>, path: &[Symbol]) -> Option<DefId> {
let crates = tcx.crates(); let crates = tcx.crates();
let krate = crates let krate = crates

17
src/librustdoc/core.rs
View file

@ -18,6 +18,7 @@ use rustc_target::spec::TargetTriple;
use syntax::source_map; use syntax::source_map;
use syntax::feature_gate::UnstableFeatures; use syntax::feature_gate::UnstableFeatures;
use syntax::json::JsonEmitter; use syntax::json::JsonEmitter;
use syntax::symbol::sym;
use errors; use errors;
use errors::emitter::{Emitter, EmitterWriter}; use errors::emitter::{Emitter, EmitterWriter};
use parking_lot::ReentrantMutex; use parking_lot::ReentrantMutex;
@ -367,9 +368,9 @@ pub fn run_core(options: RustdocOptions) -> (clean::Crate, RenderInfo, RenderOpt
}; };
let send_trait = if crate_name == Some("core".to_string()) { let send_trait = if crate_name == Some("core".to_string()) {
clean::path_to_def_local(tcx, &["marker", "Send"]) clean::path_to_def_local(tcx, &[sym::marker, sym::Send])
} else { } else {
clean::path_to_def(tcx, &["core", "marker", "Send"]) clean::path_to_def(tcx, &[sym::core, sym::marker, sym::Send])
}; };
let mut renderinfo = RenderInfo::default(); let mut renderinfo = RenderInfo::default();
@ -415,24 +416,24 @@ pub fn run_core(options: RustdocOptions) -> (clean::Crate, RenderInfo, RenderOpt
// Process all of the crate attributes, extracting plugin metadata along // Process all of the crate attributes, extracting plugin metadata along
// with the passes which we are supposed to run. // with the passes which we are supposed to run.
for attr in krate.module.as_ref().unwrap().attrs.lists("doc") { for attr in krate.module.as_ref().unwrap().attrs.lists(sym::doc) {
let diag = ctxt.sess().diagnostic(); let diag = ctxt.sess().diagnostic();
let name = attr.name_or_empty(); let name = attr.name_or_empty();
if attr.is_word() { if attr.is_word() {
if name == "no_default_passes" { if name == sym::no_default_passes {
report_deprecated_attr("no_default_passes", diag); report_deprecated_attr("no_default_passes", diag);
if default_passes == passes::DefaultPassOption::Default { if default_passes == passes::DefaultPassOption::Default {
default_passes = passes::DefaultPassOption::None; default_passes = passes::DefaultPassOption::None;
} }
} }
} else if let Some(value) = attr.value_str() { } else if let Some(value) = attr.value_str() {
let sink = match name.get() { let sink = match name {
"passes" => { sym::passes => {
report_deprecated_attr("passes = \"...\"", diag); report_deprecated_attr("passes = \"...\"", diag);
&mut manual_passes &mut manual_passes
}, },
"plugins" => { sym::plugins => {
report_deprecated_attr("plugins = \"...\"", diag); report_deprecated_attr("plugins = \"...\"", diag);
eprintln!("WARNING: #![doc(plugins = \"...\")] no longer functions; \ eprintln!("WARNING: #![doc(plugins = \"...\")] no longer functions; \
see CVE-2018-1000622"); see CVE-2018-1000622");
@ -445,7 +446,7 @@ pub fn run_core(options: RustdocOptions) -> (clean::Crate, RenderInfo, RenderOpt
} }
} }
if attr.is_word() && name == "document_private_items" { if attr.is_word() && name == sym::document_private_items {
if default_passes == passes::DefaultPassOption::Default { if default_passes == passes::DefaultPassOption::Default {
default_passes = passes::DefaultPassOption::Private; default_passes = passes::DefaultPassOption::Private;
} }

43
src/librustdoc/html/render.rs
View file

@ -50,6 +50,7 @@ use syntax::ast;
use syntax::ext::base::MacroKind; use syntax::ext::base::MacroKind;
use syntax::source_map::FileName; use syntax::source_map::FileName;
use syntax::feature_gate::UnstableFeatures; use syntax::feature_gate::UnstableFeatures;
use syntax::symbol::{Symbol, sym};
use rustc::hir::def_id::{CrateNum, CRATE_DEF_INDEX, DefId}; use rustc::hir::def_id::{CrateNum, CRATE_DEF_INDEX, DefId};
use rustc::middle::privacy::AccessLevels; use rustc::middle::privacy::AccessLevels;
use rustc::middle::stability; use rustc::middle::stability;
@ -571,24 +572,24 @@ pub fn run(mut krate: clean::Crate,
// Crawl the crate attributes looking for attributes which control how we're // Crawl the crate attributes looking for attributes which control how we're
// going to emit HTML // going to emit HTML
if let Some(attrs) = krate.module.as_ref().map(|m| &m.attrs) { if let Some(attrs) = krate.module.as_ref().map(|m| &m.attrs) {
for attr in attrs.lists("doc") { for attr in attrs.lists(sym::doc) {
match (attr.name_or_empty().get(), attr.value_str()) { match (attr.name_or_empty(), attr.value_str()) {
("html_favicon_url", Some(s)) => { (sym::html_favicon_url, Some(s)) => {
scx.layout.favicon = s.to_string(); scx.layout.favicon = s.to_string();
} }
("html_logo_url", Some(s)) => { (sym::html_logo_url, Some(s)) => {
scx.layout.logo = s.to_string(); scx.layout.logo = s.to_string();
} }
("html_playground_url", Some(s)) => { (sym::html_playground_url, Some(s)) => {
markdown::PLAYGROUND.with(|slot| { markdown::PLAYGROUND.with(|slot| {
let name = krate.name.clone(); let name = krate.name.clone();
*slot.borrow_mut() = Some((Some(name), s.to_string())); *slot.borrow_mut() = Some((Some(name), s.to_string()));
}); });
} }
("issue_tracker_base_url", Some(s)) => { (sym::issue_tracker_base_url, Some(s)) => {
scx.issue_tracker_base_url = Some(s.to_string()); scx.issue_tracker_base_url = Some(s.to_string());
} }
("html_no_source", None) if attr.is_word() => { (sym::html_no_source, None) if attr.is_word() => {
scx.include_sources = false; scx.include_sources = false;
} }
_ => {} _ => {}
@ -1388,8 +1389,8 @@ fn extern_location(e: &clean::ExternalCrate, extern_url: Option<&str>, dst: &Pat
// Failing that, see if there's an attribute specifying where to find this // Failing that, see if there's an attribute specifying where to find this
// external crate // external crate
e.attrs.lists("doc") e.attrs.lists(sym::doc)
.filter(|a| a.check_name("html_root_url")) .filter(|a| a.check_name(sym::html_root_url))
.filter_map(|a| a.value_str()) .filter_map(|a| a.value_str())
.map(|url| { .map(|url| {
let mut url = url.to_string(); let mut url = url.to_string();
@ -1779,8 +1780,8 @@ impl<'a> Cache {
let path = self.paths.get(&item.def_id) let path = self.paths.get(&item.def_id)
.map(|p| p.0[..p.0.len() - 1].join("::")) .map(|p| p.0[..p.0.len() - 1].join("::"))
.unwrap_or("std".to_owned()); .unwrap_or("std".to_owned());
for alias in item.attrs.lists("doc") for alias in item.attrs.lists(sym::doc)
.filter(|a| a.check_name("alias")) .filter(|a| a.check_name(sym::alias))
.filter_map(|a| a.value_str() .filter_map(|a| a.value_str()
.map(|s| s.to_string().replace("\"", ""))) .map(|s| s.to_string().replace("\"", "")))
.filter(|v| !v.is_empty()) .filter(|v| !v.is_empty())
@ -3761,22 +3762,22 @@ fn render_attribute(attr: &ast::MetaItem) -> Option<String> {
} }
} }
const ATTRIBUTE_WHITELIST: &'static [&'static str] = &[ const ATTRIBUTE_WHITELIST: &'static [Symbol] = &[
"export_name", sym::export_name,
"lang", sym::lang,
"link_section", sym::link_section,
"must_use", sym::must_use,
"no_mangle", sym::no_mangle,
"repr", sym::repr,
"unsafe_destructor_blind_to_params", sym::unsafe_destructor_blind_to_params,
"non_exhaustive" sym::non_exhaustive
]; ];
fn render_attributes(w: &mut dyn fmt::Write, it: &clean::Item) -> fmt::Result { fn render_attributes(w: &mut dyn fmt::Write, it: &clean::Item) -> fmt::Result {
let mut attrs = String::new(); let mut attrs = String::new();
for attr in &it.attrs.other_attrs { for attr in &it.attrs.other_attrs {
if !ATTRIBUTE_WHITELIST.contains(&attr.name_or_empty().get()) { if !ATTRIBUTE_WHITELIST.contains(&attr.name_or_empty()) {
continue; continue;
} }
if let Some(s) = render_attribute(&attr.meta().unwrap()) { if let Some(s) = render_attribute(&attr.meta().unwrap()) {

3
src/librustdoc/passes/calculate_doc_coverage.rs
View file

@ -5,6 +5,7 @@ use crate::passes::Pass;
use syntax::attr; use syntax::attr;
use syntax_pos::FileName; use syntax_pos::FileName;
use syntax::symbol::sym;
use std::collections::BTreeMap; use std::collections::BTreeMap;
use std::ops; use std::ops;
@ -131,7 +132,7 @@ impl fold::DocFolder for CoverageCalculator {
return Some(i); return Some(i);
} }
clean::ImplItem(ref impl_) clean::ImplItem(ref impl_)
if attr::contains_name(&i.attrs.other_attrs, "automatically_derived") if attr::contains_name(&i.attrs.other_attrs, sym::automatically_derived)
|| impl_.synthetic || impl_.blanket_impl.is_some() => || impl_.synthetic || impl_.blanket_impl.is_some() =>
{ {
// built-in derives get the `#[automatically_derived]` attribute, and // built-in derives get the `#[automatically_derived]` attribute, and

2
src/librustdoc/passes/collect_intra_doc_links.rs
View file

@ -99,7 +99,7 @@ impl<'a, 'tcx> LinkCollector<'a, 'tcx> {
// Try looking for methods and associated items. // Try looking for methods and associated items.
let mut split = path_str.rsplitn(2, "::"); let mut split = path_str.rsplitn(2, "::");
let item_name = if let Some(first) = split.next() { let item_name = if let Some(first) = split.next() {
first Symbol::intern(first)
} else { } else {
return Err(()) return Err(())
}; };

5
src/librustdoc/passes/collect_trait_impls.rs
View file

@ -5,6 +5,7 @@ use super::Pass;
use rustc::util::nodemap::FxHashSet; use rustc::util::nodemap::FxHashSet;
use rustc::hir::def_id::DefId; use rustc::hir::def_id::DefId;
use syntax::symbol::sym;
pub const COLLECT_TRAIT_IMPLS: Pass = Pass { pub const COLLECT_TRAIT_IMPLS: Pass = Pass {
name: "collect-trait-impls", name: "collect-trait-impls",
@ -68,7 +69,7 @@ pub fn collect_trait_impls(krate: Crate, cx: &DocContext<'_>) -> Crate {
inline::build_impl(cx, def_id, &mut new_items); inline::build_impl(cx, def_id, &mut new_items);
// FIXME(eddyb) is this `doc(hidden)` check needed? // FIXME(eddyb) is this `doc(hidden)` check needed?
if !cx.tcx.get_attrs(def_id).lists("doc").has_word("hidden") { if !cx.tcx.get_attrs(def_id).lists(sym::doc).has_word(sym::hidden) {
let self_ty = cx.tcx.type_of(def_id); let self_ty = cx.tcx.type_of(def_id);
let impls = get_auto_trait_and_blanket_impls(cx, self_ty, def_id); let impls = get_auto_trait_and_blanket_impls(cx, self_ty, def_id);
let mut renderinfo = cx.renderinfo.borrow_mut(); let mut renderinfo = cx.renderinfo.borrow_mut();
@ -154,7 +155,7 @@ impl<'a, 'tcx> DocFolder for SyntheticImplCollector<'a, 'tcx> {
fn fold_item(&mut self, i: Item) -> Option<Item> { fn fold_item(&mut self, i: Item) -> Option<Item> {
if i.is_struct() || i.is_enum() || i.is_union() { if i.is_struct() || i.is_enum() || i.is_union() {
// FIXME(eddyb) is this `doc(hidden)` check needed? // FIXME(eddyb) is this `doc(hidden)` check needed?
if !self.cx.tcx.get_attrs(i.def_id).lists("doc").has_word("hidden") { if !self.cx.tcx.get_attrs(i.def_id).lists(sym::doc).has_word(sym::hidden) {
self.impls.extend(get_auto_trait_and_blanket_impls( self.impls.extend(get_auto_trait_and_blanket_impls(
self.cx, self.cx,
self.cx.tcx.type_of(i.def_id), self.cx.tcx.type_of(i.def_id),

3
src/librustdoc/passes/strip_hidden.rs
View file

@ -1,5 +1,6 @@
use rustc::util::nodemap::DefIdSet; use rustc::util::nodemap::DefIdSet;
use std::mem; use std::mem;
use syntax::symbol::sym;
use crate::clean::{self, AttributesExt, NestedAttributesExt}; use crate::clean::{self, AttributesExt, NestedAttributesExt};
use crate::clean::Item; use crate::clean::Item;
@ -37,7 +38,7 @@ struct Stripper<'a> {
impl<'a> DocFolder for Stripper<'a> { impl<'a> DocFolder for Stripper<'a> {
fn fold_item(&mut self, i: Item) -> Option<Item> { fn fold_item(&mut self, i: Item) -> Option<Item> {
if i.attrs.lists("doc").has_word("hidden") { if i.attrs.lists(sym::doc).has_word(sym::hidden) {
debug!("strip_hidden: stripping {} {:?}", i.type_(), i.name); debug!("strip_hidden: stripping {} {:?}", i.type_(), i.name);
// use a dedicated hidden item for given item type if any // use a dedicated hidden item for given item type if any
match i.inner { match i.inner {

16
src/librustdoc/test.rs
View file

@ -11,10 +11,6 @@ use syntax::ast;
use syntax::source_map::SourceMap; use syntax::source_map::SourceMap;
use syntax::edition::Edition; use syntax::edition::Edition;
use syntax::feature_gate::UnstableFeatures; use syntax::feature_gate::UnstableFeatures;
use syntax_pos::{BytePos, DUMMY_SP, Pos, Span, FileName};
use tempfile::Builder as TempFileBuilder;
use testing;
use std::env; use std::env;
use std::io::prelude::*; use std::io::prelude::*;
use std::io; use std::io;
@ -23,6 +19,10 @@ use std::path::PathBuf;
use std::process::Command; use std::process::Command;
use std::str; use std::str;
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
use syntax::symbol::sym;
use syntax_pos::{BytePos, DUMMY_SP, Pos, Span, FileName};
use tempfile::Builder as TempFileBuilder;
use testing;
use crate::clean::Attributes; use crate::clean::Attributes;
use crate::config::Options; use crate::config::Options;
@ -137,17 +137,17 @@ fn scrape_test_config(krate: &::rustc::hir::Crate) -> TestOptions {
}; };
let test_attrs: Vec<_> = krate.attrs.iter() let test_attrs: Vec<_> = krate.attrs.iter()
.filter(|a| a.check_name("doc")) .filter(|a| a.check_name(sym::doc))
.flat_map(|a| a.meta_item_list().unwrap_or_else(Vec::new)) .flat_map(|a| a.meta_item_list().unwrap_or_else(Vec::new))
.filter(|a| a.check_name("test")) .filter(|a| a.check_name(sym::test))
.collect(); .collect();
let attrs = test_attrs.iter().flat_map(|a| a.meta_item_list().unwrap_or(&[])); let attrs = test_attrs.iter().flat_map(|a| a.meta_item_list().unwrap_or(&[]));
for attr in attrs { for attr in attrs {
if attr.check_name("no_crate_inject") { if attr.check_name(sym::no_crate_inject) {
opts.no_crate_inject = true; opts.no_crate_inject = true;
} }
if attr.check_name("attr") { if attr.check_name(sym::attr) {
if let Some(l) = attr.meta_item_list() { if let Some(l) = attr.meta_item_list() {
for item in l { for item in l {
opts.attrs.push(pprust::meta_list_item_to_string(item)); opts.attrs.push(pprust::meta_list_item_to_string(item));

26
src/librustdoc/visit_ast.rs
View file

@ -10,6 +10,7 @@ use syntax::ast;
use syntax::attr; use syntax::attr;
use syntax::ext::base::MacroKind; use syntax::ext::base::MacroKind;
use syntax::source_map::Spanned; use syntax::source_map::Spanned;
use syntax::symbol::sym;
use syntax_pos::{self, Span}; use syntax_pos::{self, Span};
use std::mem; use std::mem;
@ -165,11 +166,11 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
body: hir::BodyId) { body: hir::BodyId) {
debug!("Visiting fn"); debug!("Visiting fn");
let macro_kind = item.attrs.iter().filter_map(|a| { let macro_kind = item.attrs.iter().filter_map(|a| {
if a.check_name("proc_macro") { if a.check_name(sym::proc_macro) {
Some(MacroKind::Bang) Some(MacroKind::Bang)
} else if a.check_name("proc_macro_derive") { } else if a.check_name(sym::proc_macro_derive) {
Some(MacroKind::Derive) Some(MacroKind::Derive)
} else if a.check_name("proc_macro_attribute") { } else if a.check_name(sym::proc_macro_attribute) {
Some(MacroKind::Attr) Some(MacroKind::Attr)
} else { } else {
None None
@ -178,7 +179,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
match macro_kind { match macro_kind {
Some(kind) => { Some(kind) => {
let name = if kind == MacroKind::Derive { let name = if kind == MacroKind::Derive {
item.attrs.lists("proc_macro_derive") item.attrs.lists(sym::proc_macro_derive)
.filter_map(|mi| mi.ident()) .filter_map(|mi| mi.ident())
.next() .next()
.expect("proc-macro derives require a name") .expect("proc-macro derives require a name")
@ -188,8 +189,8 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
}; };
let mut helpers = Vec::new(); let mut helpers = Vec::new();
for mi in item.attrs.lists("proc_macro_derive") { for mi in item.attrs.lists(sym::proc_macro_derive) {
if !mi.check_name("attributes") { if !mi.check_name(sym::attributes) {
continue; continue;
} }
@ -274,7 +275,8 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
fn inherits_doc_hidden(cx: &core::DocContext<'_>, mut node: hir::HirId) -> bool { fn inherits_doc_hidden(cx: &core::DocContext<'_>, mut node: hir::HirId) -> bool {
while let Some(id) = cx.tcx.hir().get_enclosing_scope(node) { while let Some(id) = cx.tcx.hir().get_enclosing_scope(node) {
node = id; node = id;
if cx.tcx.hir().attrs_by_hir_id(node).lists("doc").has_word("hidden") { if cx.tcx.hir().attrs_by_hir_id(node)
.lists(sym::doc).has_word(sym::hidden) {
return true; return true;
} }
if node == hir::CRATE_HIR_ID { if node == hir::CRATE_HIR_ID {
@ -295,8 +297,8 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
let use_attrs = tcx.hir().attrs_by_hir_id(id); let use_attrs = tcx.hir().attrs_by_hir_id(id);
// Don't inline `doc(hidden)` imports so they can be stripped at a later stage. // Don't inline `doc(hidden)` imports so they can be stripped at a later stage.
let is_no_inline = use_attrs.lists("doc").has_word("no_inline") || let is_no_inline = use_attrs.lists(sym::doc).has_word(sym::no_inline) ||
use_attrs.lists("doc").has_word("hidden"); use_attrs.lists(sym::doc).has_word(sym::hidden);
// For cross-crate impl inlining we need to know whether items are // For cross-crate impl inlining we need to know whether items are
// reachable in documentation -- a previously nonreachable item can be // reachable in documentation -- a previously nonreachable item can be
@ -304,7 +306,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
// (this is done here because we need to know this upfront). // (this is done here because we need to know this upfront).
if !res_did.is_local() && !is_no_inline { if !res_did.is_local() && !is_no_inline {
let attrs = clean::inline::load_attrs(self.cx, res_did); let attrs = clean::inline::load_attrs(self.cx, res_did);
let self_is_hidden = attrs.lists("doc").has_word("hidden"); let self_is_hidden = attrs.lists(sym::doc).has_word(sym::hidden);
match res { match res {
Res::Def(DefKind::Trait, did) | Res::Def(DefKind::Trait, did) |
Res::Def(DefKind::Struct, did) | Res::Def(DefKind::Struct, did) |
@ -432,8 +434,8 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
if item.vis.node.is_pub() && self.inside_public_path { if item.vis.node.is_pub() && self.inside_public_path {
let please_inline = item.attrs.iter().any(|item| { let please_inline = item.attrs.iter().any(|item| {
match item.meta_item_list() { match item.meta_item_list() {
Some(ref list) if item.check_name("doc") => { Some(ref list) if item.check_name(sym::doc) => {
list.iter().any(|i| i.check_name("inline")) list.iter().any(|i| i.check_name(sym::inline))
} }
_ => false, _ => false,
} }

3
src/librustdoc/visit_lib.rs
View file

@ -3,6 +3,7 @@ use rustc::hir::def::{Res, DefKind};
use rustc::hir::def_id::{CrateNum, CRATE_DEF_INDEX, DefId}; use rustc::hir::def_id::{CrateNum, CRATE_DEF_INDEX, DefId};
use rustc::ty::Visibility; use rustc::ty::Visibility;
use rustc::util::nodemap::FxHashSet; use rustc::util::nodemap::FxHashSet;
use syntax::symbol::sym;
use std::cell::RefMut; use std::cell::RefMut;
@ -42,7 +43,7 @@ impl<'a, 'tcx> LibEmbargoVisitor<'a, 'tcx> {
// Updates node level and returns the updated level // Updates node level and returns the updated level
fn update(&mut self, did: DefId, level: Option<AccessLevel>) -> Option<AccessLevel> { fn update(&mut self, did: DefId, level: Option<AccessLevel>) -> Option<AccessLevel> {
let is_hidden = self.cx.tcx.get_attrs(did).lists("doc").has_word("hidden"); let is_hidden = self.cx.tcx.get_attrs(did).lists(sym::doc).has_word(sym::hidden);
let old_level = self.access_levels.map.get(&did).cloned(); let old_level = self.access_levels.map.get(&did).cloned();
// Accessibility levels can only grow // Accessibility levels can only grow

6
src/libsyntax/ast.rs
View file

@ -81,12 +81,6 @@ impl PartialEq<Symbol> for Path {
} }
} }
impl<'a> PartialEq<&'a str> for Path {
fn eq(&self, string: &&'a str) -> bool {
self.segments.len() == 1 && self.segments[0].ident.name == *string
}
}
impl fmt::Debug for Path { impl fmt::Debug for Path {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "path({})", pprust::path_to_string(self)) write!(f, "path({})", pprust::path_to_string(self))

121
src/libsyntax/attr/builtin.rs
View file

@ -5,7 +5,7 @@ use crate::feature_gate::{Features, GatedCfg};
use crate::parse::ParseSess; use crate::parse::ParseSess;
use errors::{Applicability, Handler}; use errors::{Applicability, Handler};
use syntax_pos::{symbol::Symbol, Span}; use syntax_pos::{symbol::Symbol, symbol::sym, Span};
use super::{mark_used, MetaItemKind}; use super::{mark_used, MetaItemKind};
@ -80,13 +80,13 @@ pub enum UnwindAttr {
/// Determine what `#[unwind]` attribute is present in `attrs`, if any. /// Determine what `#[unwind]` attribute is present in `attrs`, if any.
pub fn find_unwind_attr(diagnostic: Option<&Handler>, attrs: &[Attribute]) -> Option<UnwindAttr> { pub fn find_unwind_attr(diagnostic: Option<&Handler>, attrs: &[Attribute]) -> Option<UnwindAttr> {
attrs.iter().fold(None, |ia, attr| { attrs.iter().fold(None, |ia, attr| {
if attr.check_name("unwind") { if attr.check_name(sym::unwind) {
if let Some(meta) = attr.meta() { if let Some(meta) = attr.meta() {
if let MetaItemKind::List(items) = meta.node { if let MetaItemKind::List(items) = meta.node {
if items.len() == 1 { if items.len() == 1 {
if items[0].check_name("allowed") { if items[0].check_name(sym::allowed) {
return Some(UnwindAttr::Allowed); return Some(UnwindAttr::Allowed);
} else if items[0].check_name("aborts") { } else if items[0].check_name(sym::aborts) {
return Some(UnwindAttr::Aborts); return Some(UnwindAttr::Aborts);
} }
} }
@ -153,9 +153,9 @@ pub struct RustcDeprecation {
/// Checks if `attrs` contains an attribute like `#![feature(feature_name)]`. /// Checks if `attrs` contains an attribute like `#![feature(feature_name)]`.
/// This will not perform any "sanity checks" on the form of the attributes. /// This will not perform any "sanity checks" on the form of the attributes.
pub fn contains_feature_attr(attrs: &[Attribute], feature_name: &str) -> bool { pub fn contains_feature_attr(attrs: &[Attribute], feature_name: Symbol) -> bool {
attrs.iter().any(|item| { attrs.iter().any(|item| {
item.check_name("feature") && item.check_name(sym::feature) &&
item.meta_item_list().map(|list| { item.meta_item_list().map(|list| {
list.iter().any(|mi| mi.is_word() && mi.check_name(feature_name)) list.iter().any(|mi| mi.is_word() && mi.check_name(feature_name))
}).unwrap_or(false) }).unwrap_or(false)
@ -185,12 +185,12 @@ fn find_stability_generic<'a, I>(sess: &ParseSess,
'outer: for attr in attrs_iter { 'outer: for attr in attrs_iter {
if ![ if ![
"rustc_deprecated", sym::rustc_deprecated,
"rustc_const_unstable", sym::rustc_const_unstable,
"unstable", sym::unstable,
"stable", sym::stable,
"rustc_promotable", sym::rustc_promotable,
"rustc_allow_const_fn_ptr", sym::rustc_allow_const_fn_ptr,
].iter().any(|&s| attr.path == s) { ].iter().any(|&s| attr.path == s) {
continue // not a stability level continue // not a stability level
} }
@ -199,10 +199,10 @@ fn find_stability_generic<'a, I>(sess: &ParseSess,
let meta = attr.meta(); let meta = attr.meta();
if attr.path == "rustc_promotable" { if attr.path == sym::rustc_promotable {
promotable = true; promotable = true;
} }
if attr.path == "rustc_allow_const_fn_ptr" { if attr.path == sym::rustc_allow_const_fn_ptr {
allow_const_fn_ptr = true; allow_const_fn_ptr = true;
} }
// attributes with data // attributes with data
@ -229,10 +229,9 @@ fn find_stability_generic<'a, I>(sess: &ParseSess,
)+ )+
for meta in metas { for meta in metas {
if let Some(mi) = meta.meta_item() { if let Some(mi) = meta.meta_item() {
match mi.name_or_empty().get() { match mi.name_or_empty() {
$( $(
stringify!($name) sym::$name => if !get(mi, &mut $name) { continue 'outer },
=> if !get(mi, &mut $name) { continue 'outer },
)+ )+
_ => { _ => {
let expected = &[ $( stringify!($name) ),+ ]; let expected = &[ $( stringify!($name) ),+ ];
@ -259,8 +258,8 @@ fn find_stability_generic<'a, I>(sess: &ParseSess,
} }
} }
match meta.name_or_empty().get() { match meta.name_or_empty() {
"rustc_deprecated" => { sym::rustc_deprecated => {
if rustc_depr.is_some() { if rustc_depr.is_some() {
span_err!(diagnostic, item_sp, E0540, span_err!(diagnostic, item_sp, E0540,
"multiple rustc_deprecated attributes"); "multiple rustc_deprecated attributes");
@ -287,7 +286,7 @@ fn find_stability_generic<'a, I>(sess: &ParseSess,
} }
} }
} }
"rustc_const_unstable" => { sym::rustc_const_unstable => {
if rustc_const_unstable.is_some() { if rustc_const_unstable.is_some() {
span_err!(diagnostic, item_sp, E0553, span_err!(diagnostic, item_sp, E0553,
"multiple rustc_const_unstable attributes"); "multiple rustc_const_unstable attributes");
@ -302,7 +301,7 @@ fn find_stability_generic<'a, I>(sess: &ParseSess,
continue continue
} }
} }
"unstable" => { sym::unstable => {
if stab.is_some() { if stab.is_some() {
handle_errors(sess, attr.span, AttrError::MultipleStabilityLevels); handle_errors(sess, attr.span, AttrError::MultipleStabilityLevels);
break break
@ -313,10 +312,10 @@ fn find_stability_generic<'a, I>(sess: &ParseSess,
let mut issue = None; let mut issue = None;
for meta in metas { for meta in metas {
if let Some(mi) = meta.meta_item() { if let Some(mi) = meta.meta_item() {
match mi.name_or_empty().get() { match mi.name_or_empty() {
"feature" => if !get(mi, &mut feature) { continue 'outer }, sym::feature => if !get(mi, &mut feature) { continue 'outer },
"reason" => if !get(mi, &mut reason) { continue 'outer }, sym::reason => if !get(mi, &mut reason) { continue 'outer },
"issue" => if !get(mi, &mut issue) { continue 'outer }, sym::issue => if !get(mi, &mut issue) { continue 'outer },
_ => { _ => {
handle_errors( handle_errors(
sess, sess,
@ -374,7 +373,7 @@ fn find_stability_generic<'a, I>(sess: &ParseSess,
} }
} }
} }
"stable" => { sym::stable => {
if stab.is_some() { if stab.is_some() {
handle_errors(sess, attr.span, AttrError::MultipleStabilityLevels); handle_errors(sess, attr.span, AttrError::MultipleStabilityLevels);
break break
@ -385,11 +384,9 @@ fn find_stability_generic<'a, I>(sess: &ParseSess,
for meta in metas { for meta in metas {
match meta { match meta {
NestedMetaItem::MetaItem(mi) => { NestedMetaItem::MetaItem(mi) => {
match mi.name_or_empty().get() { match mi.name_or_empty() {
"feature" => sym::feature => if !get(mi, &mut feature) { continue 'outer },
if !get(mi, &mut feature) { continue 'outer }, sym::since => if !get(mi, &mut since) { continue 'outer },
"since" =>
if !get(mi, &mut since) { continue 'outer },
_ => { _ => {
handle_errors( handle_errors(
sess, sess,
@ -482,7 +479,7 @@ fn find_stability_generic<'a, I>(sess: &ParseSess,
} }
pub fn find_crate_name(attrs: &[Attribute]) -> Option<Symbol> { pub fn find_crate_name(attrs: &[Attribute]) -> Option<Symbol> {
super::first_attr_value_str_by_name(attrs, "crate_name") super::first_attr_value_str_by_name(attrs, sym::crate_name)
} }
/// Tests if a cfg-pattern matches the cfg set /// Tests if a cfg-pattern matches the cfg set
@ -542,14 +539,14 @@ pub fn eval_condition<F>(cfg: &ast::MetaItem, sess: &ParseSess, eval: &mut F)
// The unwraps below may look dangerous, but we've already asserted // The unwraps below may look dangerous, but we've already asserted
// that they won't fail with the loop above. // that they won't fail with the loop above.
match cfg.name_or_empty().get() { match cfg.name_or_empty() {
"any" => mis.iter().any(|mi| { sym::any => mis.iter().any(|mi| {
eval_condition(mi.meta_item().unwrap(), sess, eval) eval_condition(mi.meta_item().unwrap(), sess, eval)
}), }),
"all" => mis.iter().all(|mi| { sym::all => mis.iter().all(|mi| {
eval_condition(mi.meta_item().unwrap(), sess, eval) eval_condition(mi.meta_item().unwrap(), sess, eval)
}), }),
"not" => { sym::not => {
if mis.len() != 1 { if mis.len() != 1 {
span_err!(sess.span_diagnostic, cfg.span, E0536, "expected 1 cfg-pattern"); span_err!(sess.span_diagnostic, cfg.span, E0536, "expected 1 cfg-pattern");
return false; return false;
@ -593,7 +590,7 @@ fn find_deprecation_generic<'a, I>(sess: &ParseSess,
let diagnostic = &sess.span_diagnostic; let diagnostic = &sess.span_diagnostic;
'outer: for attr in attrs_iter { 'outer: for attr in attrs_iter {
if !attr.check_name("deprecated") { if !attr.check_name(sym::deprecated) {
continue; continue;
} }
@ -645,9 +642,9 @@ fn find_deprecation_generic<'a, I>(sess: &ParseSess,
for meta in list { for meta in list {
match meta { match meta {
NestedMetaItem::MetaItem(mi) => { NestedMetaItem::MetaItem(mi) => {
match mi.name_or_empty().get() { match mi.name_or_empty() {
"since" => if !get(mi, &mut since) { continue 'outer }, sym::since => if !get(mi, &mut since) { continue 'outer },
"note" => if !get(mi, &mut note) { continue 'outer }, sym::note => if !get(mi, &mut note) { continue 'outer },
_ => { _ => {
handle_errors( handle_errors(
sess, sess,
@ -721,7 +718,7 @@ pub fn find_repr_attrs(sess: &ParseSess, attr: &Attribute) -> Vec<ReprAttr> {
let mut acc = Vec::new(); let mut acc = Vec::new();
let diagnostic = &sess.span_diagnostic; let diagnostic = &sess.span_diagnostic;
if attr.path == "repr" { if attr.path == sym::repr {
if let Some(items) = attr.meta_item_list() { if let Some(items) = attr.meta_item_list() {
mark_used(attr); mark_used(attr);
for item in items { for item in items {
@ -739,11 +736,11 @@ pub fn find_repr_attrs(sess: &ParseSess, attr: &Attribute) -> Vec<ReprAttr> {
let mut recognised = false; let mut recognised = false;
if item.is_word() { if item.is_word() {
let hint = match item.name_or_empty().get() { let hint = match item.name_or_empty() {
"C" => Some(ReprC), sym::C => Some(ReprC),
"packed" => Some(ReprPacked(1)), sym::packed => Some(ReprPacked(1)),
"simd" => Some(ReprSimd), sym::simd => Some(ReprSimd),
"transparent" => Some(ReprTransparent), sym::transparent => Some(ReprTransparent),
name => int_type_of_word(name).map(ReprInt), name => int_type_of_word(name).map(ReprInt),
}; };
@ -770,14 +767,14 @@ pub fn find_repr_attrs(sess: &ParseSess, attr: &Attribute) -> Vec<ReprAttr> {
}; };
let mut literal_error = None; let mut literal_error = None;
if name == "align" { if name == sym::align {
recognised = true; recognised = true;
match parse_alignment(&value.node) { match parse_alignment(&value.node) {
Ok(literal) => acc.push(ReprAlign(literal)), Ok(literal) => acc.push(ReprAlign(literal)),
Err(message) => literal_error = Some(message) Err(message) => literal_error = Some(message)
}; };
} }
else if name == "packed" { else if name == sym::packed {
recognised = true; recognised = true;
match parse_alignment(&value.node) { match parse_alignment(&value.node) {
Ok(literal) => acc.push(ReprPacked(literal)), Ok(literal) => acc.push(ReprPacked(literal)),
@ -790,7 +787,7 @@ pub fn find_repr_attrs(sess: &ParseSess, attr: &Attribute) -> Vec<ReprAttr> {
} }
} else { } else {
if let Some(meta_item) = item.meta_item() { if let Some(meta_item) = item.meta_item() {
if meta_item.check_name("align") { if meta_item.check_name(sym::align) {
if let MetaItemKind::NameValue(ref value) = meta_item.node { if let MetaItemKind::NameValue(ref value) = meta_item.node {
recognised = true; recognised = true;
let mut err = struct_span_err!(diagnostic, item.span(), E0693, let mut err = struct_span_err!(diagnostic, item.span(), E0693,
@ -830,22 +827,22 @@ pub fn find_repr_attrs(sess: &ParseSess, attr: &Attribute) -> Vec<ReprAttr> {
acc acc
} }
fn int_type_of_word(s: &str) -> Option<IntType> { fn int_type_of_word(s: Symbol) -> Option<IntType> {
use IntType::*; use IntType::*;
match s { match s {
"i8" => Some(SignedInt(ast::IntTy::I8)), sym::i8 => Some(SignedInt(ast::IntTy::I8)),
"u8" => Some(UnsignedInt(ast::UintTy::U8)), sym::u8 => Some(UnsignedInt(ast::UintTy::U8)),
"i16" => Some(SignedInt(ast::IntTy::I16)), sym::i16 => Some(SignedInt(ast::IntTy::I16)),
"u16" => Some(UnsignedInt(ast::UintTy::U16)), sym::u16 => Some(UnsignedInt(ast::UintTy::U16)),
"i32" => Some(SignedInt(ast::IntTy::I32)), sym::i32 => Some(SignedInt(ast::IntTy::I32)),
"u32" => Some(UnsignedInt(ast::UintTy::U32)), sym::u32 => Some(UnsignedInt(ast::UintTy::U32)),
"i64" => Some(SignedInt(ast::IntTy::I64)), sym::i64 => Some(SignedInt(ast::IntTy::I64)),
"u64" => Some(UnsignedInt(ast::UintTy::U64)), sym::u64 => Some(UnsignedInt(ast::UintTy::U64)),
"i128" => Some(SignedInt(ast::IntTy::I128)), sym::i128 => Some(SignedInt(ast::IntTy::I128)),
"u128" => Some(UnsignedInt(ast::UintTy::U128)), sym::u128 => Some(UnsignedInt(ast::UintTy::U128)),
"isize" => Some(SignedInt(ast::IntTy::Isize)), sym::isize => Some(SignedInt(ast::IntTy::Isize)),
"usize" => Some(UnsignedInt(ast::UintTy::Usize)), sym::usize => Some(UnsignedInt(ast::UintTy::Usize)),
_ => None _ => None
} }
} }

Some files were not shown because too many files have changed in this diff Show more