diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs
index 3ec4d4e8cc8f6..90dff5e3fc4b4 100644
--- a/src/librustc/hir/lowering.rs
+++ b/src/librustc/hir/lowering.rs
@@ -64,7 +64,7 @@ use syntax::ptr::P;
use syntax::source_map::{respan, CompilerDesugaringKind, Spanned};
use syntax::source_map::CompilerDesugaringKind::IfTemporary;
use syntax::std_inject;
-use syntax::symbol::{keywords, Symbol, sym};
+use syntax::symbol::{kw, sym, Symbol};
use syntax::tokenstream::{TokenStream, TokenTree};
use syntax::parse::token::Token;
use syntax::visit::{self, Visitor};
@@ -927,11 +927,11 @@ impl<'a> LoweringContext<'a> {
hir::LifetimeParamKind::InBand,
),
ParamName::Fresh(_) => (
- keywords::UnderscoreLifetime.name().as_interned_str(),
+ kw::UnderscoreLifetime.as_interned_str(),
hir::LifetimeParamKind::Elided,
),
ParamName::Error => (
- keywords::UnderscoreLifetime.name().as_interned_str(),
+ kw::UnderscoreLifetime.as_interned_str(),
hir::LifetimeParamKind::Error,
),
};
@@ -1415,7 +1415,7 @@ impl<'a> LoweringContext<'a> {
P(hir::Path {
res,
segments: hir_vec![hir::PathSegment::from_ident(
- keywords::SelfUpper.ident()
+ Ident::with_empty_ctxt(kw::SelfUpper)
)],
span: t.span,
}),
@@ -1614,7 +1614,7 @@ impl<'a> LoweringContext<'a> {
trace!("registering existential type with id {:#?}", exist_ty_id);
let exist_ty_item = hir::Item {
hir_id: exist_ty_id,
- ident: keywords::Invalid.ident(),
+ ident: Ident::invalid(),
attrs: Default::default(),
node: exist_ty_item_kind,
vis: respan(span.shrink_to_lo(), hir::VisibilityKind::Inherited),
@@ -1747,7 +1747,7 @@ impl<'a> LoweringContext<'a> {
let (name, kind) = match name {
hir::LifetimeName::Underscore => (
- hir::ParamName::Plain(keywords::UnderscoreLifetime.ident()),
+ hir::ParamName::Plain(Ident::with_empty_ctxt(kw::UnderscoreLifetime)),
hir::LifetimeParamKind::Elided,
),
hir::LifetimeName::Param(param_name) => (
@@ -2296,7 +2296,7 @@ impl<'a> LoweringContext<'a> {
.iter()
.map(|arg| match arg.pat.node {
PatKind::Ident(_, ident, _) => ident,
- _ => Ident::new(keywords::Invalid.name(), arg.pat.span),
+ _ => Ident::new(kw::Invalid, arg.pat.span),
})
.collect()
}
@@ -2585,9 +2585,9 @@ impl<'a> LoweringContext<'a> {
fn lower_lifetime(&mut self, l: &Lifetime) -> hir::Lifetime {
let span = l.ident.span;
match l.ident {
- ident if ident.name == keywords::StaticLifetime.name() =>
+ ident if ident.name == kw::StaticLifetime =>
self.new_named_lifetime(l.id, span, hir::LifetimeName::Static),
- ident if ident.name == keywords::UnderscoreLifetime.name() =>
+ ident if ident.name == kw::UnderscoreLifetime =>
match self.anonymous_lifetime_mode {
AnonymousLifetimeMode::CreateParameter => {
let fresh_name = self.collect_fresh_in_band_lifetime(span);
@@ -2709,7 +2709,7 @@ impl<'a> LoweringContext<'a> {
// Don't expose `Self` (recovered "keyword used as ident" parse error).
// `rustc::ty` expects `Self` to be only used for a trait's `Self`.
// Instead, use `gensym("Self")` to create a distinct name that looks the same.
- let ident = if param.ident.name == keywords::SelfUpper.name() {
+ let ident = if param.ident.name == kw::SelfUpper {
param.ident.gensym()
} else {
param.ident
@@ -3325,7 +3325,7 @@ impl<'a> LoweringContext<'a> {
// Correctly resolve `self` imports.
if path.segments.len() > 1
- && path.segments.last().unwrap().ident.name == keywords::SelfLower.name()
+ && path.segments.last().unwrap().ident.name == kw::SelfLower
{
let _ = path.segments.pop();
if rename.is_none() {
diff --git a/src/librustc/hir/map/def_collector.rs b/src/librustc/hir/map/def_collector.rs
index 6e7a8f5bc234f..bb9e76f026246 100644
--- a/src/librustc/hir/map/def_collector.rs
+++ b/src/librustc/hir/map/def_collector.rs
@@ -5,7 +5,7 @@ use crate::session::CrateDisambiguator;
use syntax::ast::*;
use syntax::ext::hygiene::Mark;
use syntax::visit;
-use syntax::symbol::keywords;
+use syntax::symbol::kw;
use syntax::symbol::Symbol;
use syntax::parse::token::{self, Token};
use syntax_pos::Span;
@@ -138,7 +138,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
// information we encapsulate into, the better
let def_data = match i.node {
ItemKind::Impl(..) => DefPathData::Impl,
- ItemKind::Mod(..) if i.ident == keywords::Invalid.ident() => {
+ ItemKind::Mod(..) if i.ident.name == kw::Invalid => {
return visit::walk_item(self, i);
}
ItemKind::Mod(..) | ItemKind::Trait(..) | ItemKind::TraitAlias(..) |
diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs
index 23f4d20857135..e5ca97b82ab48 100644
--- a/src/librustc/hir/map/mod.rs
+++ b/src/librustc/hir/map/mod.rs
@@ -519,7 +519,7 @@ impl<'hir> Map<'hir> {
pub fn ty_param_name(&self, id: HirId) -> Name {
match self.get_by_hir_id(id) {
Node::Item(&Item { node: ItemKind::Trait(..), .. }) |
- Node::Item(&Item { node: ItemKind::TraitAlias(..), .. }) => keywords::SelfUpper.name(),
+ Node::Item(&Item { node: ItemKind::TraitAlias(..), .. }) => kw::SelfUpper,
Node::GenericParam(param) => param.name.ident().name,
_ => bug!("ty_param_name: {} not a type parameter", self.hir_to_string(id)),
}
diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs
index d2b926d188697..e3e930f5d1d3c 100644
--- a/src/librustc/hir/mod.rs
+++ b/src/librustc/hir/mod.rs
@@ -24,7 +24,7 @@ use syntax::ast::{Attribute, Label, LitKind, StrStyle, FloatTy, IntTy, UintTy};
use syntax::attr::{InlineAttr, OptimizeAttr};
use syntax::ext::hygiene::SyntaxContext;
use syntax::ptr::P;
-use syntax::symbol::{Symbol, keywords};
+use syntax::symbol::{Symbol, kw};
use syntax::tokenstream::TokenStream;
use syntax::util::parser::ExprPrecedence;
use crate::ty::AdtKind;
@@ -160,7 +160,7 @@ pub struct Lifetime {
pub span: Span,
/// Either "`'a`", referring to a named lifetime definition,
- /// or "``" (i.e., `keywords::Invalid`), for elision placeholders.
+ /// or "``" (i.e., `kw::Invalid`), for elision placeholders.
///
/// HIR lowering inserts these placeholders in type paths that
/// refer to type definitions needing lifetime parameters,
@@ -199,7 +199,8 @@ impl ParamName {
pub fn ident(&self) -> Ident {
match *self {
ParamName::Plain(ident) => ident,
- ParamName::Error | ParamName::Fresh(_) => keywords::UnderscoreLifetime.ident(),
+ ParamName::Fresh(_) |
+ ParamName::Error => Ident::with_empty_ctxt(kw::UnderscoreLifetime),
}
}
@@ -233,10 +234,9 @@ pub enum LifetimeName {
impl LifetimeName {
pub fn ident(&self) -> Ident {
match *self {
- LifetimeName::Implicit => keywords::Invalid.ident(),
- LifetimeName::Error => keywords::Invalid.ident(),
- LifetimeName::Underscore => keywords::UnderscoreLifetime.ident(),
- LifetimeName::Static => keywords::StaticLifetime.ident(),
+ LifetimeName::Implicit | LifetimeName::Error => Ident::invalid(),
+ LifetimeName::Underscore => Ident::with_empty_ctxt(kw::UnderscoreLifetime),
+ LifetimeName::Static => Ident::with_empty_ctxt(kw::StaticLifetime),
LifetimeName::Param(param_name) => param_name.ident(),
}
}
@@ -305,7 +305,7 @@ pub struct Path {
impl Path {
pub fn is_global(&self) -> bool {
- !self.segments.is_empty() && self.segments[0].ident.name == keywords::PathRoot.name()
+ !self.segments.is_empty() && self.segments[0].ident.name == kw::PathRoot
}
}
diff --git a/src/librustc/hir/print.rs b/src/librustc/hir/print.rs
index 8a9028e544391..60511ecc883ce 100644
--- a/src/librustc/hir/print.rs
+++ b/src/librustc/hir/print.rs
@@ -7,7 +7,7 @@ use syntax::print::pp::{self, Breaks};
use syntax::print::pp::Breaks::{Consistent, Inconsistent};
use syntax::print::pprust::{self, PrintState};
use syntax::ptr::P;
-use syntax::symbol::keywords;
+use syntax::symbol::kw;
use syntax::util::parser::{self, AssocOp, Fixity};
use syntax_pos::{self, BytePos, FileName};
@@ -798,7 +798,7 @@ impl<'a> State<'a> {
hir::VisibilityKind::Restricted { ref path, .. } => {
self.s.word("pub(")?;
if path.segments.len() == 1 &&
- path.segments[0].ident.name == keywords::Super.name() {
+ path.segments[0].ident.name == kw::Super {
// Special case: `super` can print like `pub(super)`.
self.s.word("super")?;
} else {
@@ -1559,7 +1559,7 @@ impl<'a> State<'a> {
if i > 0 {
self.s.word("::")?
}
- if segment.ident.name != keywords::PathRoot.name() {
+ if segment.ident.name != kw::PathRoot {
self.print_ident(segment.ident)?;
segment.with_generic_args(|generic_args| {
self.print_generic_args(generic_args, segment.infer_types,
@@ -1572,7 +1572,7 @@ impl<'a> State<'a> {
}
pub fn print_path_segment(&mut self, segment: &hir::PathSegment) -> io::Result<()> {
- if segment.ident.name != keywords::PathRoot.name() {
+ if segment.ident.name != kw::PathRoot {
self.print_ident(segment.ident)?;
segment.with_generic_args(|generic_args| {
self.print_generic_args(generic_args, segment.infer_types, false)
@@ -1599,7 +1599,7 @@ impl<'a> State<'a> {
if i > 0 {
self.s.word("::")?
}
- if segment.ident.name != keywords::PathRoot.name() {
+ if segment.ident.name != kw::PathRoot {
self.print_ident(segment.ident)?;
segment.with_generic_args(|generic_args| {
self.print_generic_args(generic_args,
diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs
index cb333b5b0cba2..91a19852c6c0e 100644
--- a/src/librustc/middle/liveness.rs
+++ b/src/librustc/middle/liveness.rs
@@ -112,7 +112,7 @@ use std::io;
use std::rc::Rc;
use syntax::ast::{self, NodeId};
use syntax::ptr::P;
-use syntax::symbol::{keywords, sym};
+use syntax::symbol::{kw, sym};
use syntax_pos::Span;
use crate::hir;
@@ -1552,7 +1552,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
let sp = ident.span;
let var = self.variable(hir_id, sp);
// Ignore unused self.
- if ident.name != keywords::SelfLower.name() {
+ if ident.name != kw::SelfLower {
if !self.warn_about_unused(vec![sp], hir_id, entry_ln, var) {
if self.live_on_entry(entry_ln, var).is_none() {
self.report_dead_assign(hir_id, sp, var, true);
diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs
index 2402d0eefde48..419cc5936862c 100644
--- a/src/librustc/middle/resolve_lifetime.rs
+++ b/src/librustc/middle/resolve_lifetime.rs
@@ -23,7 +23,7 @@ use std::mem::replace;
use syntax::ast;
use syntax::attr;
use syntax::ptr::P;
-use syntax::symbol::{keywords, sym};
+use syntax::symbol::{kw, sym};
use syntax_pos::Span;
use crate::hir::intravisit::{self, NestedVisitorMap, Visitor};
@@ -711,7 +711,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
GenericParamKind::Lifetime { .. } => {
let (name, reg) = Region::early(&self.tcx.hir(), &mut index, ¶m);
if let hir::ParamName::Plain(param_name) = name {
- if param_name.name == keywords::UnderscoreLifetime.name() {
+ if param_name.name == kw::UnderscoreLifetime {
// Pick the elided lifetime "definition" if one exists
// and use it to make an elision scope.
elision = Some(reg);
@@ -1602,7 +1602,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
} {
debug!("id = {:?} span = {:?} name = {:?}", id, span, name);
- if name == keywords::UnderscoreLifetime.ident() {
+ if name.name == kw::UnderscoreLifetime {
continue;
}
@@ -2525,8 +2525,8 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
for (i, (lifetime_i, lifetime_i_name)) in lifetimes.iter().enumerate() {
if let hir::ParamName::Plain(_) = lifetime_i_name {
let name = lifetime_i_name.ident().name;
- if name == keywords::UnderscoreLifetime.name()
- || name == keywords::StaticLifetime.name()
+ if name == kw::UnderscoreLifetime
+ || name == kw::StaticLifetime
{
let mut err = struct_span_err!(
self.tcx.sess,
diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs
index c9fee02f66bbd..b5a17684c0ff2 100644
--- a/src/librustc/ty/context.rs
+++ b/src/librustc/ty/context.rs
@@ -74,7 +74,7 @@ use syntax::ast;
use syntax::attr;
use syntax::source_map::MultiSpan;
use syntax::feature_gate;
-use syntax::symbol::{Symbol, keywords, InternedString, sym};
+use syntax::symbol::{Symbol, InternedString, kw, sym};
use syntax_pos::Span;
use crate::hir;
@@ -2735,7 +2735,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
#[inline]
pub fn mk_self_type(self) -> Ty<'tcx> {
- self.mk_ty_param(0, keywords::SelfUpper.name().as_interned_str())
+ self.mk_ty_param(0, kw::SelfUpper.as_interned_str())
}
pub fn mk_param_from_def(self, param: &ty::GenericParamDef) -> Kind<'tcx> {
diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
index 4d242265e618f..a2c89489b95dc 100644
--- a/src/librustc/ty/mod.rs
+++ b/src/librustc/ty/mod.rs
@@ -47,7 +47,7 @@ use std::ops::Range;
use syntax::ast::{self, Name, Ident, NodeId};
use syntax::attr;
use syntax::ext::hygiene::Mark;
-use syntax::symbol::{keywords, sym, Symbol, LocalInternedString, InternedString};
+use syntax::symbol::{kw, sym, Symbol, LocalInternedString, InternedString};
use syntax_pos::Span;
use smallvec;
@@ -835,7 +835,7 @@ impl ty::EarlyBoundRegion {
/// Does this early bound region have a name? Early bound regions normally
/// always have names except when using anonymous lifetimes (`'_`).
pub fn has_name(&self) -> bool {
- self.name != keywords::UnderscoreLifetime.name().as_interned_str()
+ self.name != kw::UnderscoreLifetime.as_interned_str()
}
}
diff --git a/src/librustc/ty/print/pretty.rs b/src/librustc/ty/print/pretty.rs
index c18852a832fce..7a8d5d3bb9a67 100644
--- a/src/librustc/ty/print/pretty.rs
+++ b/src/librustc/ty/print/pretty.rs
@@ -8,7 +8,7 @@ use crate::ty::{self, DefIdTree, ParamConst, Ty, TyCtxt, TypeFoldable};
use crate::ty::subst::{Kind, Subst, UnpackedKind};
use crate::mir::interpret::ConstValue;
use rustc_target::spec::abi::Abi;
-use syntax::symbol::{keywords, InternedString};
+use syntax::symbol::{kw, InternedString};
use std::cell::Cell;
use std::fmt::{self, Write as _};
@@ -980,7 +980,7 @@ impl<F: fmt::Write> Printer<'gcx, 'tcx> for FmtPrinter<'_, 'gcx, 'tcx, F> {
if self.tcx.sess.rust_2018() {
// We add the `crate::` keyword on Rust 2018, only when desired.
if SHOULD_PREFIX_WITH_CRATE.with(|flag| flag.get()) {
- write!(self, "{}", keywords::Crate.name())?;
+ write!(self, "{}", kw::Crate)?;
self.empty_path = false;
}
}
@@ -1140,16 +1140,16 @@ impl<F: fmt::Write> PrettyPrinter<'gcx, 'tcx> for FmtPrinter<'_, 'gcx, 'tcx, F>
match *region {
ty::ReEarlyBound(ref data) => {
- data.name.as_symbol() != keywords::Invalid.name() &&
- data.name.as_symbol() != keywords::UnderscoreLifetime.name()
+ data.name.as_symbol() != kw::Invalid &&
+ data.name.as_symbol() != kw::UnderscoreLifetime
}
ty::ReLateBound(_, br) |
ty::ReFree(ty::FreeRegion { bound_region: br, .. }) |
ty::RePlaceholder(ty::Placeholder { name: br, .. }) => {
if let ty::BrNamed(_, name) = br {
- if name.as_symbol() != keywords::Invalid.name() &&
- name.as_symbol() != keywords::UnderscoreLifetime.name() {
+ if name.as_symbol() != kw::Invalid &&
+ name.as_symbol() != kw::UnderscoreLifetime {
return true;
}
}
@@ -1205,7 +1205,7 @@ impl<F: fmt::Write> FmtPrinter<'_, '_, '_, F> {
// `explain_region()` or `note_and_explain_region()`.
match *region {
ty::ReEarlyBound(ref data) => {
- if data.name.as_symbol() != keywords::Invalid.name() {
+ if data.name.as_symbol() != kw::Invalid {
p!(write("{}", data.name));
return Ok(self);
}
@@ -1214,8 +1214,8 @@ impl<F: fmt::Write> FmtPrinter<'_, '_, '_, F> {
ty::ReFree(ty::FreeRegion { bound_region: br, .. }) |
ty::RePlaceholder(ty::Placeholder { name: br, .. }) => {
if let ty::BrNamed(_, name) = br {
- if name.as_symbol() != keywords::Invalid.name() &&
- name.as_symbol() != keywords::UnderscoreLifetime.name() {
+ if name.as_symbol() != kw::Invalid &&
+ name.as_symbol() != kw::UnderscoreLifetime {
p!(write("{}", name));
return Ok(self);
}
diff --git a/src/librustc/ty/sty.rs b/src/librustc/ty/sty.rs
index e8f3bad4d3ee3..0b5a6fce5cb87 100644
--- a/src/librustc/ty/sty.rs
+++ b/src/librustc/ty/sty.rs
@@ -22,7 +22,7 @@ use std::marker::PhantomData;
use std::ops::Range;
use rustc_target::spec::abi;
use syntax::ast::{self, Ident};
-use syntax::symbol::{keywords, InternedString};
+use syntax::symbol::{kw, InternedString};
use serialize;
use self::InferTy::*;
@@ -1121,7 +1121,7 @@ impl<'a, 'gcx, 'tcx> ParamTy {
}
pub fn for_self() -> ParamTy {
- ParamTy::new(0, keywords::SelfUpper.name().as_interned_str())
+ ParamTy::new(0, kw::SelfUpper.as_interned_str())
}
pub fn for_def(def: &ty::GenericParamDef) -> ParamTy {
@@ -1136,7 +1136,7 @@ impl<'a, 'gcx, 'tcx> ParamTy {
// FIXME(#50125): Ignoring `Self` with `index != 0` might lead to weird behavior elsewhere,
// but this should only be possible when using `-Z continue-parse-after-error` like
// `compile-fail/issue-36638.rs`.
- self.name.as_symbol() == keywords::SelfUpper.name() && self.index == 0
+ self.name.as_symbol() == kw::SelfUpper && self.index == 0
}
}
diff --git a/src/librustc_allocator/expand.rs b/src/librustc_allocator/expand.rs
index 0c19d770194b2..b9cd30694f6e8 100644
--- a/src/librustc_allocator/expand.rs
+++ b/src/librustc_allocator/expand.rs
@@ -19,7 +19,7 @@ use syntax::{
mut_visit::{self, MutVisitor},
parse::ParseSess,
ptr::P,
- symbol::{keywords, Symbol, sym}
+ symbol::{kw, sym, Symbol}
};
use syntax_pos::Span;
@@ -116,8 +116,7 @@ impl MutVisitor for ExpandAllocatorDirectives<'_> {
// We will generate a new submodule. To `use` the static from that module, we need to get
// the `super::...` path.
- let super_path =
- f.cx.path(f.span, vec![Ident::with_empty_ctxt(keywords::Super.name()), f.global]);
+ let super_path = f.cx.path(f.span, vec![Ident::with_empty_ctxt(kw::Super), f.global]);
// Generate the items in the submodule
let mut items = vec![
diff --git a/src/librustc_codegen_ssa/mir/mod.rs b/src/librustc_codegen_ssa/mir/mod.rs
index 060d7d18625fc..fed12c9a29fd2 100644
--- a/src/librustc_codegen_ssa/mir/mod.rs
+++ b/src/librustc_codegen_ssa/mir/mod.rs
@@ -10,7 +10,7 @@ use crate::debuginfo::{self, VariableAccess, VariableKind, FunctionDebugContext}
use crate::traits::*;
use syntax_pos::{DUMMY_SP, NO_EXPANSION, BytePos, Span};
-use syntax::symbol::keywords;
+use syntax::symbol::kw;
use std::iter;
@@ -496,7 +496,7 @@ fn arg_local_refs<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>(
};
bx.declare_local(
&fx.debug_context,
- arg_decl.name.unwrap_or(keywords::Invalid.name()),
+ arg_decl.name.unwrap_or(kw::Invalid),
arg_ty, scope,
variable_access,
VariableKind::ArgumentVariable(arg_index + 1),
@@ -613,7 +613,7 @@ fn arg_local_refs<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>(
bx.declare_local(
&fx.debug_context,
- arg_decl.name.unwrap_or(keywords::Invalid.name()),
+ arg_decl.name.unwrap_or(kw::Invalid),
arg.layout.ty,
scope,
variable_access,
diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs
index d17a92efb066b..d52e497cf63d9 100644
--- a/src/librustc_lint/builtin.rs
+++ b/src/librustc_lint/builtin.rs
@@ -42,7 +42,7 @@ use syntax::edition::Edition;
use syntax::feature_gate::{AttributeGate, AttributeTemplate, AttributeType};
use syntax::feature_gate::{Stability, deprecated_attributes};
use syntax_pos::{BytePos, Span, SyntaxContext};
-use syntax::symbol::{Symbol, keywords, sym};
+use syntax::symbol::{Symbol, kw, sym};
use syntax::errors::{Applicability, DiagnosticBuilder};
use syntax::print::pprust::expr_to_string;
use syntax::visit::FnKind;
@@ -607,7 +607,7 @@ impl EarlyLintPass for AnonymousParameters {
for arg in sig.decl.inputs.iter() {
match arg.pat.node {
ast::PatKind::Ident(_, ident, None) => {
- if ident.name == keywords::Invalid.name() {
+ if ident.name == kw::Invalid {
let ty_snip = cx
.sess
.source_map()
diff --git a/src/librustc_lint/unused.rs b/src/librustc_lint/unused.rs
index c3dfd44ad8572..34f7e04c16420 100644
--- a/src/librustc_lint/unused.rs
+++ b/src/librustc_lint/unused.rs
@@ -12,7 +12,7 @@ use syntax::attr;
use syntax::errors::Applicability;
use syntax::feature_gate::{AttributeType, BuiltinAttribute, BUILTIN_ATTRIBUTE_MAP};
use syntax::print::pprust;
-use syntax::symbol::{keywords, sym};
+use syntax::symbol::{kw, sym};
use syntax::symbol::Symbol;
use syntax::util::parser;
use syntax_pos::Span;
@@ -455,7 +455,7 @@ impl UnusedImportBraces {
match items[0].0.kind {
ast::UseTreeKind::Simple(rename, ..) => {
let orig_ident = items[0].0.prefix.segments.last().unwrap().ident;
- if orig_ident.name == keywords::SelfLower.name() {
+ if orig_ident.name == kw::SelfLower {
return;
}
node_ident = rename.unwrap_or(orig_ident);
diff --git a/src/librustc_macros/src/symbols.rs b/src/librustc_macros/src/symbols.rs
index a4c7daf088ff2..3883682fa9df5 100644
--- a/src/librustc_macros/src/symbols.rs
+++ b/src/librustc_macros/src/symbols.rs
@@ -97,7 +97,6 @@ pub fn symbols(input: TokenStream) -> TokenStream {
let mut keyword_stream = quote! {};
let mut symbols_stream = quote! {};
let mut prefill_stream = quote! {};
- let mut from_str_stream = quote! {};
let mut counter = 0u32;
let mut keys = HashSet::<String>::new();
@@ -115,12 +114,7 @@ pub fn symbols(input: TokenStream) -> TokenStream {
#value,
});
keyword_stream.extend(quote! {
- pub const #name: Keyword = Keyword {
- ident: Ident::with_empty_ctxt(super::Symbol::new(#counter))
- };
- });
- from_str_stream.extend(quote! {
- #value => Ok(#name),
+ pub const #name: Symbol = Symbol::new(#counter);
});
counter += 1;
}
@@ -145,17 +139,6 @@ pub fn symbols(input: TokenStream) -> TokenStream {
macro_rules! keywords {
() => {
#keyword_stream
-
- impl std::str::FromStr for Keyword {
- type Err = ();
-
- fn from_str(s: &str) -> Result<Self, ()> {
- match s {
- #from_str_stream
- _ => Err(()),
- }
- }
- }
}
}
diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs
index 7f0993e799f54..dfc3439fc5539 100644
--- a/src/librustc_metadata/encoder.rs
+++ b/src/librustc_metadata/encoder.rs
@@ -33,7 +33,7 @@ use std::u32;
use syntax::ast;
use syntax::attr;
use syntax::source_map::Spanned;
-use syntax::symbol::{keywords, sym};
+use syntax::symbol::{kw, sym};
use syntax_pos::{self, FileName, SourceFile, Span};
use log::{debug, trace};
@@ -1042,7 +1042,7 @@ impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> {
self.lazy_seq(body.arguments.iter().map(|arg| {
match arg.pat.node {
PatKind::Binding(_, _, ident, _) => ident.name,
- _ => keywords::Invalid.name(),
+ _ => kw::Invalid,
}
}))
})
diff --git a/src/librustc_mir/borrow_check/mutability_errors.rs b/src/librustc_mir/borrow_check/mutability_errors.rs
index 32088ff9f61ee..4bee7f9c4bf86 100644
--- a/src/librustc_mir/borrow_check/mutability_errors.rs
+++ b/src/librustc_mir/borrow_check/mutability_errors.rs
@@ -8,7 +8,7 @@ use rustc::mir::{Terminator, TerminatorKind};
use rustc::ty::{self, Const, DefIdTree, Ty, TyS, TyCtxt};
use rustc_data_structures::indexed_vec::Idx;
use syntax_pos::Span;
-use syntax_pos::symbol::keywords;
+use syntax_pos::symbol::kw;
use crate::dataflow::move_paths::InitLocation;
use crate::borrow_check::MirBorrowckCtxt;
@@ -256,7 +256,7 @@ impl<'a, 'gcx, 'tcx> MirBorrowckCtxt<'a, 'gcx, 'tcx> {
// Deliberately fall into this case for all implicit self types,
// so that we don't fall in to the next case with them.
*kind == mir::ImplicitSelfKind::MutRef
- } else if Some(keywords::SelfLower.name()) == local_decl.name {
+ } else if Some(kw::SelfLower) == local_decl.name {
// Otherwise, check if the name is the self kewyord - in which case
// we have an explicit self. Do the same thing in this case and check
// for a `self: &mut Self` to suggest removing the `&mut`.
diff --git a/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/mod.rs b/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/mod.rs
index 00e81ee049183..18ca105070e8f 100644
--- a/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/mod.rs
+++ b/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/mod.rs
@@ -15,7 +15,7 @@ use rustc_data_structures::indexed_vec::IndexVec;
use rustc_errors::{Diagnostic, DiagnosticBuilder};
use std::collections::VecDeque;
use syntax::errors::Applicability;
-use syntax::symbol::keywords;
+use syntax::symbol::kw;
use syntax_pos::Span;
mod region_name;
@@ -631,7 +631,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
"add_static_impl_trait_suggestion: has_static_predicate={:?}",
has_static_predicate
);
- let static_str = keywords::StaticLifetime.name();
+ let static_str = kw::StaticLifetime;
// If there is a static predicate, then the only sensible suggestion is to replace
// fr with `'static`.
if has_static_predicate {
diff --git a/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/region_name.rs b/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/region_name.rs
index 4d8acd241acd8..f3cfc1a59a981 100644
--- a/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/region_name.rs
+++ b/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/region_name.rs
@@ -12,7 +12,7 @@ use rustc::ty::subst::{SubstsRef, UnpackedKind};
use rustc::ty::{self, RegionKind, RegionVid, Ty, TyCtxt};
use rustc::ty::print::RegionHighlightMode;
use rustc_errors::DiagnosticBuilder;
-use syntax::symbol::keywords;
+use syntax::symbol::kw;
use syntax_pos::Span;
use syntax_pos::symbol::InternedString;
@@ -216,7 +216,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
}
ty::ReStatic => Some(RegionName {
- name: keywords::StaticLifetime.name().as_interned_str(),
+ name: kw::StaticLifetime.as_interned_str(),
source: RegionNameSource::Static
}),
diff --git a/src/librustc_mir/build/mod.rs b/src/librustc_mir/build/mod.rs
index e46c515355521..199b0176601e1 100644
--- a/src/librustc_mir/build/mod.rs
+++ b/src/librustc_mir/build/mod.rs
@@ -20,7 +20,7 @@ use std::mem;
use std::u32;
use rustc_target::spec::abi::Abi;
use syntax::attr::{self, UnwindAttr};
-use syntax::symbol::keywords;
+use syntax::symbol::kw;
use syntax_pos::Span;
use super::lints;
@@ -660,7 +660,7 @@ fn construct_fn<'a, 'gcx, 'tcx, A>(hir: Cx<'a, 'gcx, 'tcx>,
ty::UpvarCapture::ByRef(..) => true,
};
let mut debuginfo = UpvarDebuginfo {
- debug_name: keywords::Invalid.name(),
+ debug_name: kw::Invalid,
by_ref,
};
let mut mutability = Mutability::Not;
diff --git a/src/librustc_passes/ast_validation.rs b/src/librustc_passes/ast_validation.rs
index 2bea1db841ae9..3091570d14802 100644
--- a/src/librustc_passes/ast_validation.rs
+++ b/src/librustc_passes/ast_validation.rs
@@ -15,7 +15,7 @@ use rustc_data_structures::fx::FxHashMap;
use syntax::ast::*;
use syntax::attr;
use syntax::source_map::Spanned;
-use syntax::symbol::{keywords, sym};
+use syntax::symbol::{kw, sym};
use syntax::ptr::P;
use syntax::visit::{self, Visitor};
use syntax::{span_err, struct_span_err, walk_list};
@@ -177,9 +177,9 @@ impl<'a> AstValidator<'a> {
}
fn check_lifetime(&self, ident: Ident) {
- let valid_names = [keywords::UnderscoreLifetime.name(),
- keywords::StaticLifetime.name(),
- keywords::Invalid.name()];
+ let valid_names = [kw::UnderscoreLifetime,
+ kw::StaticLifetime,
+ kw::Invalid];
if !valid_names.contains(&ident.name) && ident.without_first_quote().is_reserved() {
self.err_handler().span_err(ident.span, "lifetimes cannot use keyword names");
}
diff --git a/src/librustc_plugin/load.rs b/src/librustc_plugin/load.rs
index 680bdcc4bbe97..46cd66fe58546 100644
--- a/src/librustc_plugin/load.rs
+++ b/src/librustc_plugin/load.rs
@@ -11,7 +11,7 @@ use std::mem;
use std::path::PathBuf;
use syntax::ast;
use syntax::span_err;
-use syntax::symbol::{Symbol, keywords, sym};
+use syntax::symbol::{Symbol, kw, sym};
use syntax_pos::{Span, DUMMY_SP};
/// Pointer to a registrar function.
@@ -58,7 +58,7 @@ pub fn load_plugins(sess: &Session,
for plugin in plugins {
// plugins must have a name and can't be key = value
let name = plugin.name_or_empty();
- if name != keywords::Invalid.name() && !plugin.is_value_str() {
+ if name != kw::Invalid && !plugin.is_value_str() {
let args = plugin.meta_item_list().map(ToOwned::to_owned);
loader.load_plugin(plugin.span(), name, args.unwrap_or_default());
} else {
diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs
index cd21713cddf97..1df42a9504275 100644
--- a/src/librustc_privacy/lib.rs
+++ b/src/librustc_privacy/lib.rs
@@ -27,7 +27,7 @@ use rustc_data_structures::fx::FxHashSet;
use rustc_data_structures::sync::Lrc;
use syntax::ast::Ident;
use syntax::attr;
-use syntax::symbol::{keywords, sym};
+use syntax::symbol::{kw, sym};
use syntax_pos::Span;
use std::{cmp, fmt, mem};
@@ -844,7 +844,7 @@ impl<'a, 'tcx> NamePrivacyVisitor<'a, 'tcx> {
span: Span, // span of the field pattern, e.g., `x: 0`
def: &'tcx ty::AdtDef, // definition of the struct or enum
field: &'tcx ty::FieldDef) { // definition of the field
- let ident = Ident::new(keywords::Invalid.name(), use_ctxt);
+ let ident = Ident::new(kw::Invalid, use_ctxt);
let current_hir = self.current_item;
let def_id = self.tcx.adjust_ident(ident, def.did, current_hir).1;
if !def.is_enum() && !field.vis.is_accessible_from(def_id, self.tcx) {
diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs
index 3b58a99d19fe0..8c516a4da4e5f 100644
--- a/src/librustc_resolve/build_reduced_graph.rs
+++ b/src/librustc_resolve/build_reduced_graph.rs
@@ -37,7 +37,7 @@ use syntax::feature_gate::is_builtin_attr;
use syntax::parse::token::{self, Token};
use syntax::span_err;
use syntax::std_inject::injected_crate_name;
-use syntax::symbol::{keywords, sym};
+use syntax::symbol::{kw, sym};
use syntax::visit::{self, Visitor};
use syntax_pos::{Span, DUMMY_SP};
@@ -143,7 +143,7 @@ impl<'a> Resolver<'a> {
}
_ => None,
}.map(|ctxt| Segment::from_ident(Ident::new(
- keywords::PathRoot.name(), use_tree.prefix.span.shrink_to_lo().with_ctxt(ctxt)
+ kw::PathRoot, use_tree.prefix.span.shrink_to_lo().with_ctxt(ctxt)
)));
let prefix = crate_root.into_iter().chain(prefix_iter).collect::<Vec<_>>();
@@ -151,7 +151,7 @@ impl<'a> Resolver<'a> {
let empty_for_self = |prefix: &[Segment]| {
prefix.is_empty() ||
- prefix.len() == 1 && prefix[0].ident.name == keywords::PathRoot.name()
+ prefix.len() == 1 && prefix[0].ident.name == kw::PathRoot
};
match use_tree.kind {
ast::UseTreeKind::Simple(rename, ..) => {
@@ -162,7 +162,7 @@ impl<'a> Resolver<'a> {
if nested {
// Correctly handle `self`
- if source.ident.name == keywords::SelfLower.name() {
+ if source.ident.name == kw::SelfLower {
type_ns_only = true;
if empty_for_self(&module_path) {
@@ -183,14 +183,14 @@ impl<'a> Resolver<'a> {
}
} else {
// Disallow `self`
- if source.ident.name == keywords::SelfLower.name() {
+ if source.ident.name == kw::SelfLower {
resolve_error(self,
use_tree.span,
ResolutionError::SelfImportsOnlyAllowedWithin);
}
// Disallow `use $crate;`
- if source.ident.name == keywords::DollarCrate.name() && module_path.is_empty() {
+ if source.ident.name == kw::DollarCrate && module_path.is_empty() {
let crate_root = self.resolve_crate_root(source.ident);
let crate_name = match crate_root.kind {
ModuleKind::Def(.., name) => name,
@@ -199,11 +199,11 @@ impl<'a> Resolver<'a> {
// HACK(eddyb) unclear how good this is, but keeping `$crate`
// in `source` breaks `src/test/compile-fail/import-crate-var.rs`,
// while the current crate doesn't have a valid `crate_name`.
- if crate_name != keywords::Invalid.name() {
+ if crate_name != kw::Invalid {
// `crate_name` should not be interpreted as relative.
module_path.push(Segment {
ident: Ident {
- name: keywords::PathRoot.name(),
+ name: kw::PathRoot,
span: source.ident.span,
},
id: Some(self.session.next_node_id()),
@@ -221,7 +221,7 @@ impl<'a> Resolver<'a> {
}
}
- if ident.name == keywords::Crate.name() {
+ if ident.name == kw::Crate {
self.session.span_err(ident.span,
"crate root imports need to be explicitly named: \
`use crate as name;`");
@@ -276,7 +276,7 @@ impl<'a> Resolver<'a> {
// Ensure there is at most one `self` in the list
let self_spans = items.iter().filter_map(|&(ref use_tree, _)| {
if let ast::UseTreeKind::Simple(..) = use_tree.kind {
- if use_tree.ident().name == keywords::SelfLower.name() {
+ if use_tree.ident().name == kw::SelfLower {
return Some(use_tree.span);
}
}
@@ -311,7 +311,7 @@ impl<'a> Resolver<'a> {
let new_span = prefix[prefix.len() - 1].ident.span;
let tree = ast::UseTree {
prefix: ast::Path::from_ident(
- Ident::new(keywords::SelfLower.name(), new_span)
+ Ident::new(kw::SelfLower, new_span)
),
kind: ast::UseTreeKind::Simple(
Some(Ident::from_str_and_span("__dummy", new_span).gensym()),
@@ -350,7 +350,7 @@ impl<'a> Resolver<'a> {
}
ItemKind::ExternCrate(orig_name) => {
- let module = if orig_name.is_none() && ident.name == keywords::SelfLower.name() {
+ let module = if orig_name.is_none() && ident.name == kw::SelfLower {
self.session
.struct_span_err(item.span, "`extern crate self;` requires renaming")
.span_suggestion(
@@ -361,7 +361,7 @@ impl<'a> Resolver<'a> {
)
.emit();
return;
- } else if orig_name == Some(keywords::SelfLower.name()) {
+ } else if orig_name == Some(kw::SelfLower) {
self.graph_root
} else {
let crate_id = self.crate_loader.process_extern_crate(item, &self.definitions);
@@ -420,7 +420,7 @@ impl<'a> Resolver<'a> {
ItemKind::GlobalAsm(..) => {}
- ItemKind::Mod(..) if ident == keywords::Invalid.ident() => {} // Crate root
+ ItemKind::Mod(..) if ident.name == kw::Invalid => {} // Crate root
ItemKind::Mod(..) => {
let def_id = self.definitions.local_def_id(item.id);
@@ -831,7 +831,7 @@ impl<'a> Resolver<'a> {
"an `extern crate` loading macros must be at the crate root");
}
if let ItemKind::ExternCrate(Some(orig_name)) = item.node {
- if orig_name == keywords::SelfLower.name() {
+ if orig_name == kw::SelfLower {
self.session.span_err(attr.span,
"`macro_use` is not supported on `extern crate self`");
}
diff --git a/src/librustc_resolve/diagnostics.rs b/src/librustc_resolve/diagnostics.rs
index 509aa95bb61df..8b5e2b86d5ee8 100644
--- a/src/librustc_resolve/diagnostics.rs
+++ b/src/librustc_resolve/diagnostics.rs
@@ -7,7 +7,7 @@ use rustc::hir::def_id::{CRATE_DEF_INDEX, DefId};
use rustc::session::{Session, config::nightly_options};
use syntax::ast::{self, Expr, ExprKind, Ident};
use syntax::ext::base::MacroKind;
-use syntax::symbol::{Symbol, keywords};
+use syntax::symbol::{Symbol, kw};
use syntax_pos::{BytePos, Span};
type Res = def::Res<ast::NodeId>;
@@ -48,7 +48,7 @@ impl<'a> Resolver<'a> {
let item_span = path.last().unwrap().ident.span;
let (mod_prefix, mod_str) = if path.len() == 1 {
(String::new(), "this scope".to_string())
- } else if path.len() == 2 && path[0].ident.name == keywords::PathRoot.name() {
+ } else if path.len() == 2 && path[0].ident.name == kw::PathRoot {
(String::new(), "the crate root".to_string())
} else {
let mod_path = &path[..path.len() - 1];
@@ -454,13 +454,13 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> {
match (path.get(0), path.get(1)) {
// `{{root}}::ident::...` on both editions.
// On 2015 `{{root}}` is usually added implicitly.
- (Some(fst), Some(snd)) if fst.ident.name == keywords::PathRoot.name() &&
+ (Some(fst), Some(snd)) if fst.ident.name == kw::PathRoot &&
!snd.ident.is_path_segment_keyword() => {}
// `ident::...` on 2018.
(Some(fst), _) if fst.ident.span.rust_2018() &&
!fst.ident.is_path_segment_keyword() => {
// Insert a placeholder that's later replaced by `self`/`super`/etc.
- path.insert(0, Segment::from_ident(keywords::Invalid.ident()));
+ path.insert(0, Segment::from_ident(Ident::invalid()));
}
_ => return None,
}
@@ -485,7 +485,7 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> {
parent_scope: &ParentScope<'b>,
) -> Option<(Vec<Segment>, Vec<String>)> {
// Replace first ident with `self` and check if that is valid.
- path[0].ident.name = keywords::SelfLower.name();
+ path[0].ident.name = kw::SelfLower;
let result = self.resolve_path(&path, None, parent_scope, false, span, CrateLint::No);
debug!("make_missing_self_suggestion: path={:?} result={:?}", path, result);
if let PathResult::Module(..) = result {
@@ -509,7 +509,7 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> {
parent_scope: &ParentScope<'b>,
) -> Option<(Vec<Segment>, Vec<String>)> {
// Replace first ident with `crate` and check if that is valid.
- path[0].ident.name = keywords::Crate.name();
+ path[0].ident.name = kw::Crate;
let result = self.resolve_path(&path, None, parent_scope, false, span, CrateLint::No);
debug!("make_missing_crate_suggestion: path={:?} result={:?}", path, result);
if let PathResult::Module(..) = result {
@@ -540,7 +540,7 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> {
parent_scope: &ParentScope<'b>,
) -> Option<(Vec<Segment>, Vec<String>)> {
// Replace first ident with `crate` and check if that is valid.
- path[0].ident.name = keywords::Super.name();
+ path[0].ident.name = kw::Super;
let result = self.resolve_path(&path, None, parent_scope, false, span, CrateLint::No);
debug!("make_missing_super_suggestion: path={:?} result={:?}", path, result);
if let PathResult::Module(..) = result {
diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
index c4a4dd306055b..a7097a9475ede 100644
--- a/src/librustc_resolve/lib.rs
+++ b/src/librustc_resolve/lib.rs
@@ -43,7 +43,7 @@ use syntax::ast::{self, Name, NodeId, Ident, FloatTy, IntTy, UintTy};
use syntax::ext::base::SyntaxExtension;
use syntax::ext::base::Determinacy::{self, Determined, Undetermined};
use syntax::ext::base::MacroKind;
-use syntax::symbol::{Symbol, keywords, sym};
+use syntax::symbol::{Symbol, kw, sym};
use syntax::util::lev_distance::find_best_match_for_name;
use syntax::visit::{self, FnKind, Visitor};
@@ -820,7 +820,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Resolver<'a> {
self.smart_resolve_path(ty.id, qself.as_ref(), path, PathSource::Type);
}
TyKind::ImplicitSelf => {
- let self_ty = keywords::SelfUpper.ident();
+ let self_ty = Ident::with_empty_ctxt(kw::SelfUpper);
let res = self.resolve_ident_in_lexical_scope(self_ty, TypeNS, Some(ty.id), ty.span)
.map_or(Res::Err, |d| d.res());
self.record_partial_res(ty.id, PartialRes::new(res));
@@ -1817,18 +1817,17 @@ impl<'a> hir::lowering::Resolver for Resolver<'a> {
is_value: bool
) -> hir::Path {
let root = if crate_root.is_some() {
- keywords::PathRoot
+ kw::PathRoot
} else {
- keywords::Crate
+ kw::Crate
};
- let segments = iter::once(root.ident())
+ let segments = iter::once(Ident::with_empty_ctxt(root))
.chain(
crate_root.into_iter()
.chain(components.iter().cloned())
.map(Ident::with_empty_ctxt)
).map(|i| self.new_ast_path_segment(i)).collect::<Vec<_>>();
-
let path = ast::Path {
span,
segments,
@@ -1866,7 +1865,7 @@ impl<'a> Resolver<'a> {
let path = if path_str.starts_with("::") {
ast::Path {
span,
- segments: iter::once(keywords::PathRoot.ident())
+ segments: iter::once(Ident::with_empty_ctxt(kw::PathRoot))
.chain({
path_str.split("::").skip(1).map(Ident::from_str)
})
@@ -1961,7 +1960,7 @@ impl<'a> Resolver<'a> {
let root_module_kind = ModuleKind::Def(
DefKind::Mod,
root_def_id,
- keywords::Invalid.name(),
+ kw::Invalid,
);
let graph_root = arenas.alloc_module(ModuleData {
no_implicit_prelude: attr::contains_name(&krate.attrs, sym::no_implicit_prelude),
@@ -2187,10 +2186,10 @@ impl<'a> Resolver<'a> {
path_span: Span)
-> Option<LexicalScopeBinding<'a>> {
assert!(ns == TypeNS || ns == ValueNS);
- if ident.name == keywords::Invalid.name() {
+ if ident.name == kw::Invalid {
return Some(LexicalScopeBinding::Res(Res::Err));
}
- ident.span = if ident.name == keywords::SelfUpper.name() {
+ ident.span = if ident.name == kw::SelfUpper {
// FIXME(jseyfried) improve `Self` hygiene
ident.span.with_ctxt(SyntaxContext::empty())
} else if ns == TypeNS {
@@ -2405,7 +2404,7 @@ impl<'a> Resolver<'a> {
fn resolve_crate_root(&mut self, ident: Ident) -> Module<'a> {
let mut ctxt = ident.span.ctxt();
- let mark = if ident.name == keywords::DollarCrate.name() {
+ let mark = if ident.name == kw::DollarCrate {
// When resolving `$crate` from a `macro_rules!` invoked in a `macro`,
// we don't want to pretend that the `macro_rules!` definition is in the `macro`
// as described in `SyntaxContext::apply_mark`, so we ignore prepended modern marks.
@@ -2851,7 +2850,7 @@ impl<'a> Resolver<'a> {
let mut self_type_rib = Rib::new(NormalRibKind);
// Plain insert (no renaming, since types are not currently hygienic)
- self_type_rib.bindings.insert(keywords::SelfUpper.ident(), self_res);
+ self_type_rib.bindings.insert(Ident::with_empty_ctxt(kw::SelfUpper), self_res);
self.ribs[TypeNS].push(self_type_rib);
f(self);
self.ribs[TypeNS].pop();
@@ -2862,7 +2861,7 @@ impl<'a> Resolver<'a> {
{
let self_res = Res::SelfCtor(impl_id);
let mut self_type_rib = Rib::new(NormalRibKind);
- self_type_rib.bindings.insert(keywords::SelfUpper.ident(), self_res);
+ self_type_rib.bindings.insert(Ident::with_empty_ctxt(kw::SelfUpper), self_res);
self.ribs[ValueNS].push(self_type_rib);
f(self);
self.ribs[ValueNS].pop();
@@ -3199,7 +3198,7 @@ impl<'a> Resolver<'a> {
}
None => {
// A completely fresh binding, add to the lists if it's valid.
- if ident.name != keywords::Invalid.name() {
+ if ident.name != kw::Invalid {
bindings.insert(ident, outer_pat_id);
self.ribs[ValueNS].last_mut().unwrap().bindings.insert(ident, res);
}
@@ -3494,13 +3493,13 @@ impl<'a> Resolver<'a> {
}
fn self_type_is_available(&mut self, span: Span) -> bool {
- let binding = self.resolve_ident_in_lexical_scope(keywords::SelfUpper.ident(),
+ let binding = self.resolve_ident_in_lexical_scope(Ident::with_empty_ctxt(kw::SelfUpper),
TypeNS, None, span);
if let Some(LexicalScopeBinding::Res(res)) = binding { res != Res::Err } else { false }
}
fn self_value_is_available(&mut self, self_span: Span, path_span: Span) -> bool {
- let ident = Ident::new(keywords::SelfLower.name(), self_span);
+ let ident = Ident::new(kw::SelfLower, self_span);
let binding = self.resolve_ident_in_lexical_scope(ident, ValueNS, None, path_span);
if let Some(LexicalScopeBinding::Res(res)) = binding { res != Res::Err } else { false }
}
@@ -3657,8 +3656,8 @@ impl<'a> Resolver<'a> {
};
if path.len() > 1 && !global_by_default && result.base_res() != Res::Err &&
- path[0].ident.name != keywords::PathRoot.name() &&
- path[0].ident.name != keywords::DollarCrate.name() {
+ path[0].ident.name != kw::PathRoot &&
+ path[0].ident.name != kw::DollarCrate {
let unqualified_result = {
match self.resolve_path_without_parent_scope(
&[*path.last().unwrap()],
@@ -3739,11 +3738,11 @@ impl<'a> Resolver<'a> {
let name = ident.name;
allow_super &= ns == TypeNS &&
- (name == keywords::SelfLower.name() ||
- name == keywords::Super.name());
+ (name == kw::SelfLower ||
+ name == kw::Super);
if ns == TypeNS {
- if allow_super && name == keywords::Super.name() {
+ if allow_super && name == kw::Super {
let mut ctxt = ident.span.ctxt().modern();
let self_module = match i {
0 => Some(self.resolve_self(&mut ctxt, self.current_module)),
@@ -3768,25 +3767,25 @@ impl<'a> Resolver<'a> {
};
}
if i == 0 {
- if name == keywords::SelfLower.name() {
+ if name == kw::SelfLower {
let mut ctxt = ident.span.ctxt().modern();
module = Some(ModuleOrUniformRoot::Module(
self.resolve_self(&mut ctxt, self.current_module)));
continue;
}
- if name == keywords::PathRoot.name() && ident.span.rust_2018() {
+ if name == kw::PathRoot && ident.span.rust_2018() {
module = Some(ModuleOrUniformRoot::ExternPrelude);
continue;
}
- if name == keywords::PathRoot.name() &&
+ if name == kw::PathRoot &&
ident.span.rust_2015() && self.session.rust_2018() {
// `::a::b` from 2015 macro on 2018 global edition
module = Some(ModuleOrUniformRoot::CrateRootAndExternPrelude);
continue;
}
- if name == keywords::PathRoot.name() ||
- name == keywords::Crate.name() ||
- name == keywords::DollarCrate.name() {
+ if name == kw::PathRoot ||
+ name == kw::Crate ||
+ name == kw::DollarCrate {
// `::a::b`, `crate::a::b` or `$crate::a::b`
module = Some(ModuleOrUniformRoot::Module(
self.resolve_crate_root(ident)));
@@ -3797,12 +3796,12 @@ impl<'a> Resolver<'a> {
// Report special messages for path segment keywords in wrong positions.
if ident.is_path_segment_keyword() && i != 0 {
- let name_str = if name == keywords::PathRoot.name() {
+ let name_str = if name == kw::PathRoot {
"crate root".to_string()
} else {
format!("`{}`", name)
};
- let label = if i == 1 && path[0].ident.name == keywords::PathRoot.name() {
+ let label = if i == 1 && path[0].ident.name == kw::PathRoot {
format!("global paths cannot start with {}", name_str)
} else {
format!("{} in paths can only be used in start position", name_str)
@@ -3971,13 +3970,13 @@ impl<'a> Resolver<'a> {
// We're only interested in `use` paths which should start with
// `{{root}}` currently.
- if first_name != keywords::PathRoot.name() {
+ if first_name != kw::PathRoot {
return
}
match path.get(1) {
// If this import looks like `crate::...` it's already good
- Some(Segment { ident, .. }) if ident.name == keywords::Crate.name() => return,
+ Some(Segment { ident, .. }) if ident.name == kw::Crate => return,
// Otherwise go below to see if it's an extern crate
Some(_) => {}
// If the path has length one (and it's `PathRoot` most likely)
@@ -4670,7 +4669,7 @@ impl<'a> Resolver<'a> {
{
let mut candidates = Vec::new();
let mut seen_modules = FxHashSet::default();
- let not_local_module = crate_name != keywords::Crate.ident();
+ let not_local_module = crate_name.name != kw::Crate;
let mut worklist = vec![(start_module, Vec::<ast::PathSegment>::new(), not_local_module)];
while let Some((in_module,
@@ -4764,7 +4763,8 @@ impl<'a> Resolver<'a> {
where FilterFn: Fn(Res) -> bool
{
let mut suggestions = self.lookup_import_candidates_from_module(
- lookup_ident, namespace, self.graph_root, keywords::Crate.ident(), &filter_fn);
+ lookup_ident, namespace, self.graph_root, Ident::with_empty_ctxt(kw::Crate), &filter_fn
+ );
if lookup_ident.span.rust_2018() {
let extern_prelude_names = self.extern_prelude.clone();
@@ -4883,7 +4883,7 @@ impl<'a> Resolver<'a> {
} else {
let ctxt = ident.span.ctxt();
Some(Segment::from_ident(Ident::new(
- keywords::PathRoot.name(), path.span.shrink_to_lo().with_ctxt(ctxt)
+ kw::PathRoot, path.span.shrink_to_lo().with_ctxt(ctxt)
)))
};
@@ -5352,17 +5352,17 @@ impl<'a> Resolver<'a> {
}
fn is_self_type(path: &[Segment], namespace: Namespace) -> bool {
- namespace == TypeNS && path.len() == 1 && path[0].ident.name == keywords::SelfUpper.name()
+ namespace == TypeNS && path.len() == 1 && path[0].ident.name == kw::SelfUpper
}
fn is_self_value(path: &[Segment], namespace: Namespace) -> bool {
- namespace == ValueNS && path.len() == 1 && path[0].ident.name == keywords::SelfLower.name()
+ namespace == ValueNS && path.len() == 1 && path[0].ident.name == kw::SelfLower
}
fn names_to_string(idents: &[Ident]) -> String {
let mut result = String::new();
for (i, ident) in idents.iter()
- .filter(|ident| ident.name != keywords::PathRoot.name())
+ .filter(|ident| ident.name != kw::PathRoot)
.enumerate() {
if i > 0 {
result.push_str("::");
diff --git a/src/librustc_resolve/macros.rs b/src/librustc_resolve/macros.rs
index d07f7b65275f1..9bb607a2cc28f 100644
--- a/src/librustc_resolve/macros.rs
+++ b/src/librustc_resolve/macros.rs
@@ -22,7 +22,7 @@ use syntax::ext::tt::macro_rules;
use syntax::feature_gate::{
feature_err, is_builtin_attr_name, AttributeGate, GateIssue, Stability, BUILTIN_ATTRIBUTES,
};
-use syntax::symbol::{Symbol, keywords, sym};
+use syntax::symbol::{Symbol, kw, sym};
use syntax::visit::Visitor;
use syntax::util::lev_distance::find_best_match_for_name;
use syntax_pos::{Span, DUMMY_SP};
@@ -137,10 +137,10 @@ impl<'a> base::Resolver for Resolver<'a> {
}
impl<'a> Visitor<'a> for ResolveDollarCrates<'a, '_> {
fn visit_ident(&mut self, ident: Ident) {
- if ident.name == keywords::DollarCrate.name() {
+ if ident.name == kw::DollarCrate {
let name = match self.resolver.resolve_crate_root(ident).kind {
- ModuleKind::Def(.., name) if name != keywords::Invalid.name() => name,
- _ => keywords::Crate.name(),
+ ModuleKind::Def(.., name) if name != kw::Invalid => name,
+ _ => kw::Crate,
};
ident.span.ctxt().set_dollar_crate_name(name);
}
@@ -415,7 +415,7 @@ impl<'a> Resolver<'a> {
if kind == MacroKind::Bang && path.len() == 1 &&
path[0].ident.span.ctxt().outer().expn_info()
.map_or(false, |info| info.local_inner_macros) {
- let root = Ident::new(keywords::DollarCrate.name(), path[0].ident.span);
+ let root = Ident::new(kw::DollarCrate, path[0].ident.span);
path.insert(0, Segment::from_ident(root));
}
@@ -613,7 +613,7 @@ impl<'a> Resolver<'a> {
_ => Err(Determinacy::Determined),
}
WhereToResolve::CrateRoot => {
- let root_ident = Ident::new(keywords::PathRoot.name(), orig_ident.span);
+ let root_ident = Ident::new(kw::PathRoot, orig_ident.span);
let root_module = self.resolve_crate_root(root_ident);
let binding = self.resolve_ident_in_module_ext(
ModuleOrUniformRoot::Module(root_module),
diff --git a/src/librustc_resolve/resolve_imports.rs b/src/librustc_resolve/resolve_imports.rs
index 3a6a8b56ff35d..c0ff7b310b581 100644
--- a/src/librustc_resolve/resolve_imports.rs
+++ b/src/librustc_resolve/resolve_imports.rs
@@ -29,7 +29,7 @@ use rustc::{bug, span_bug};
use syntax::ast::{self, Ident, Name, NodeId, CRATE_NODE_ID};
use syntax::ext::base::Determinacy::{self, Determined, Undetermined};
use syntax::ext::hygiene::Mark;
-use syntax::symbol::{keywords, sym};
+use syntax::symbol::{kw, sym};
use syntax::util::lev_distance::find_best_match_for_name;
use syntax::{struct_span_err, unwrap_or};
use syntax_pos::{MultiSpan, Span};
@@ -217,15 +217,15 @@ impl<'a> Resolver<'a> {
parent_scope.expect("no parent scope for a single-segment import");
if ns == TypeNS {
- if ident.name == keywords::Crate.name() ||
- ident.name == keywords::DollarCrate.name() {
+ if ident.name == kw::Crate ||
+ ident.name == kw::DollarCrate {
let module = self.resolve_crate_root(ident);
let binding = (module, ty::Visibility::Public,
module.span, Mark::root())
.to_name_binding(self.arenas);
return Ok(binding);
- } else if ident.name == keywords::Super.name() ||
- ident.name == keywords::SelfLower.name() {
+ } else if ident.name == kw::Super ||
+ ident.name == kw::SelfLower {
// FIXME: Implement these with renaming requirements so that e.g.
// `use super;` doesn't work, but `use super as name;` does.
// Fall through here to get an error from `early_resolve_...`.
@@ -707,7 +707,7 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> {
has_errors = true;
if let SingleImport { source, ref source_bindings, .. } = import.subclass {
- if source.name == keywords::SelfLower.name() {
+ if source.name == kw::SelfLower {
// Silence `unresolved import` error if E0429 is already emitted
if let Err(Determined) = source_bindings.value_ns.get() {
continue;
@@ -992,7 +992,7 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> {
// HACK(eddyb) `lint_if_path_starts_with_module` needs at least
// 2 segments, so the `resolve_path` above won't trigger it.
let mut full_path = directive.module_path.clone();
- full_path.push(Segment::from_ident(keywords::Invalid.ident()));
+ full_path.push(Segment::from_ident(Ident::invalid()));
self.lint_if_path_starts_with_module(
directive.crate_lint(),
&full_path,
@@ -1484,8 +1484,8 @@ fn import_path_to_string(names: &[Ident],
subclass: &ImportDirectiveSubclass<'_>,
span: Span) -> String {
let pos = names.iter()
- .position(|p| span == p.span && p.name != keywords::PathRoot.name());
- let global = !names.is_empty() && names[0].name == keywords::PathRoot.name();
+ .position(|p| span == p.span && p.name != kw::PathRoot);
+ let global = !names.is_empty() && names[0].name == kw::PathRoot;
if let Some(pos) = pos {
let names = if global { &names[1..pos + 1] } else { &names[..pos + 1] };
names_to_string(names)
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
index 362b6f0504d99..a20a91b3e6f6d 100644
--- a/src/librustc_typeck/check/mod.rs
+++ b/src/librustc_typeck/check/mod.rs
@@ -123,7 +123,7 @@ use syntax::attr;
use syntax::feature_gate::{GateIssue, emit_feature_err};
use syntax::ptr::P;
use syntax::source_map::{DUMMY_SP, original_sp};
-use syntax::symbol::{Symbol, LocalInternedString, keywords, sym};
+use syntax::symbol::{Symbol, LocalInternedString, kw, sym};
use syntax::util::lev_distance::find_best_match_for_name;
use std::cell::{Cell, RefCell, Ref, RefMut};
@@ -3290,7 +3290,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
Ok(method)
}
Err(error) => {
- if segment.ident.name != keywords::Invalid.name() {
+ if segment.ident.name != kw::Invalid {
self.report_method_error(span,
rcvr_t,
segment.ident,
@@ -3402,7 +3402,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
}
err.emit();
field_ty
- } else if field.name == keywords::Invalid.name() {
+ } else if field.name == kw::Invalid {
self.tcx().types.err
} else if self.method_exists(field, expr_t, expr.hir_id, true) {
let mut err = type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
@@ -4672,7 +4672,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
_ => Err(ErrorReported),
};
- if item_name.name != keywords::Invalid.name() {
+ if item_name.name != kw::Invalid {
self.report_method_error(
span,
ty,
diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs
index 7adf86a99bd43..2a4d8f304b592 100644
--- a/src/librustc_typeck/collect.rs
+++ b/src/librustc_typeck/collect.rs
@@ -39,7 +39,7 @@ use syntax::ast::{Ident, MetaItemKind};
use syntax::attr::{InlineAttr, OptimizeAttr, list_contains_name, mark_used};
use syntax::source_map::Spanned;
use syntax::feature_gate;
-use syntax::symbol::{InternedString, keywords, Symbol, sym};
+use syntax::symbol::{InternedString, kw, Symbol, sym};
use syntax_pos::{Span, DUMMY_SP};
use rustc::hir::def::{CtorKind, Res, DefKind};
@@ -939,7 +939,7 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> &'tcx ty
opt_self = Some(ty::GenericParamDef {
index: 0,
- name: keywords::SelfUpper.name().as_interned_str(),
+ name: kw::SelfUpper.as_interned_str(),
def_id: tcx.hir().local_def_id_from_hir_id(param_id),
pure_wrt_drop: false,
kind: ty::GenericParamDefKind::Type {
@@ -1008,7 +1008,7 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> &'tcx ty
synthetic,
..
} => {
- if param.name.ident().name == keywords::SelfUpper.name() {
+ if param.name.ident().name == kw::SelfUpper {
span_bug!(
param.span,
"`Self` should not be the name of a regular parameter"
@@ -1038,7 +1038,7 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> &'tcx ty
}
}
GenericParamKind::Const { .. } => {
- if param.name.ident().name == keywords::SelfUpper.name() {
+ if param.name.ident().name == kw::SelfUpper {
span_bug!(
param.span,
"`Self` should not be the name of a regular parameter",
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 6d03a5ad63bbb..1bbbe581c3ce1 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -31,8 +31,7 @@ use syntax::attr;
use syntax::ext::base::MacroKind;
use syntax::source_map::{dummy_spanned, Spanned};
use syntax::ptr::P;
-use syntax::symbol::keywords::{self, Keyword};
-use syntax::symbol::{Symbol, sym};
+use syntax::symbol::{Symbol, kw, sym};
use syntax::symbol::InternedString;
use syntax_pos::{self, Pos, FileName};
@@ -43,7 +42,6 @@ use std::default::Default;
use std::{mem, slice, vec};
use std::iter::{FromIterator, once};
use std::rc::Rc;
-use std::str::FromStr;
use std::cell::RefCell;
use std::sync::Arc;
use std::u32;
@@ -309,10 +307,9 @@ impl Clean<ExternalCrate> for CrateNum {
for attr in attrs.lists(sym::doc) {
if let Some(v) = attr.value_str() {
if attr.check_name(sym::keyword) {
- keyword = Keyword::from_str(&v.as_str()).ok()
- .map(|x| x.name().to_string());
- if keyword.is_some() {
- break
+ if v.is_doc_keyword() {
+ keyword = Some(v.to_string());
+ break;
}
// FIXME: should warn on unknown keywords?
}
@@ -1702,7 +1699,7 @@ impl<'a, 'tcx> Clean<Generics> for (&'a ty::Generics,
let stripped_typarams = gens.params.iter().filter_map(|param| match param.kind {
ty::GenericParamDefKind::Lifetime => None,
ty::GenericParamDefKind::Type { .. } => {
- if param.name.as_symbol() == keywords::SelfUpper.name() {
+ if param.name.as_symbol() == kw::SelfUpper {
assert_eq!(param.index, 0);
return None;
}
@@ -3596,7 +3593,7 @@ fn qpath_to_string(p: &hir::QPath) -> String {
if i > 0 {
s.push_str("::");
}
- if seg.ident.name != keywords::PathRoot.name() {
+ if seg.ident.name != kw::PathRoot {
s.push_str(&*seg.ident.as_str());
}
}
@@ -4176,7 +4173,7 @@ fn resolve_type(cx: &DocContext<'_>,
hir::Float(float_ty) => return Primitive(float_ty.into()),
},
Res::SelfTy(..) if path.segments.len() == 1 => {
- return Generic(keywords::SelfUpper.name().to_string());
+ return Generic(kw::SelfUpper.to_string());
}
Res::Def(DefKind::TyParam, _) if path.segments.len() == 1 => {
return Generic(format!("{:#}", path));
diff --git a/src/librustdoc/html/highlight.rs b/src/librustdoc/html/highlight.rs
index 5bb06516ac49e..e5b44077fc993 100644
--- a/src/librustdoc/html/highlight.rs
+++ b/src/librustdoc/html/highlight.rs
@@ -15,6 +15,7 @@ use syntax::source_map::{SourceMap, FilePathMapping};
use syntax::parse::lexer::{self, TokenAndSpan};
use syntax::parse::token;
use syntax::parse;
+use syntax::symbol::{kw, sym};
use syntax_pos::{Span, FileName};
/// Highlights `src`, returning the HTML output.
@@ -325,16 +326,15 @@ impl<'a> Classifier<'a> {
// Keywords are also included in the identifier set.
token::Ident(ident, is_raw) => {
- match &*ident.as_str() {
- "ref" | "mut" if !is_raw => Class::RefKeyWord,
+ match ident.name {
+ kw::Ref | kw::Mut if !is_raw => Class::RefKeyWord,
- "self" | "Self" => Class::Self_,
- "false" | "true" if !is_raw => Class::Bool,
+ kw::SelfLower | kw::SelfUpper => Class::Self_,
+ kw::False | kw::True if !is_raw => Class::Bool,
- "Option" | "Result" => Class::PreludeTy,
- "Some" | "None" | "Ok" | "Err" => Class::PreludeVal,
+ sym::Option | sym::Result => Class::PreludeTy,
+ sym::Some | sym::None | sym::Ok | sym::Err => Class::PreludeVal,
- "$crate" => Class::KeyWord,
_ if tas.tok.is_reserved_ident() => Class::KeyWord,
_ => {
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index da45bc1d9f5c5..0df00e7f4416d 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -10,7 +10,7 @@ use crate::parse::token;
use crate::print::pprust;
use crate::ptr::P;
use crate::source_map::{dummy_spanned, respan, Spanned};
-use crate::symbol::{keywords, Symbol};
+use crate::symbol::{kw, Symbol};
use crate::tokenstream::TokenStream;
use crate::ThinVec;
@@ -65,7 +65,7 @@ impl fmt::Debug for Lifetime {
pub struct Path {
pub span: Span,
/// The segments in the path: the things separated by `::`.
- /// Global paths begin with `keywords::PathRoot`.
+ /// Global paths begin with `kw::PathRoot`.
pub segments: Vec<PathSegment>,
}
@@ -100,7 +100,7 @@ impl Path {
}
pub fn is_global(&self) -> bool {
- !self.segments.is_empty() && self.segments[0].ident.name == keywords::PathRoot.name()
+ !self.segments.is_empty() && self.segments[0].ident.name == kw::PathRoot
}
}
@@ -128,7 +128,7 @@ impl PathSegment {
PathSegment { ident, id: DUMMY_NODE_ID, args: None }
}
pub fn path_root(span: Span) -> Self {
- PathSegment::from_ident(Ident::new(keywords::PathRoot.name(), span))
+ PathSegment::from_ident(Ident::new(kw::PathRoot, span))
}
}
@@ -1782,7 +1782,7 @@ pub type ExplicitSelf = Spanned<SelfKind>;
impl Arg {
pub fn to_self(&self) -> Option<ExplicitSelf> {
if let PatKind::Ident(BindingMode::ByValue(mutbl), ident, _) = self.pat.node {
- if ident.name == keywords::SelfLower.name() {
+ if ident.name == kw::SelfLower {
return match self.ty.node {
TyKind::ImplicitSelf => Some(respan(self.pat.span, SelfKind::Value(mutbl))),
TyKind::Rptr(lt, MutTy { ref ty, mutbl }) if ty.node.is_implicit_self() => {
@@ -1800,7 +1800,7 @@ impl Arg {
pub fn is_self(&self) -> bool {
if let PatKind::Ident(_, ident, _) = self.pat.node {
- ident.name == keywords::SelfLower.name()
+ ident.name == kw::SelfLower
} else {
false
}
diff --git a/src/libsyntax/attr/mod.rs b/src/libsyntax/attr/mod.rs
index 592b40df1764e..a97c094418dfb 100644
--- a/src/libsyntax/attr/mod.rs
+++ b/src/libsyntax/attr/mod.rs
@@ -22,7 +22,7 @@ use crate::parse::parser::Parser;
use crate::parse::{self, ParseSess, PResult};
use crate::parse::token::{self, Token};
use crate::ptr::P;
-use crate::symbol::{keywords, Symbol, sym};
+use crate::symbol::{sym, Symbol};
use crate::ThinVec;
use crate::tokenstream::{TokenStream, TokenTree, DelimSpan};
use crate::GLOBALS;
@@ -90,7 +90,7 @@ impl NestedMetaItem {
self.meta_item().and_then(|meta_item| meta_item.ident())
}
pub fn name_or_empty(&self) -> Symbol {
- self.ident().unwrap_or(keywords::Invalid.ident()).name
+ self.ident().unwrap_or(Ident::invalid()).name
}
/// Gets the string value if self is a MetaItem and the MetaItem is a
@@ -168,7 +168,7 @@ impl Attribute {
}
}
pub fn name_or_empty(&self) -> Symbol {
- self.ident().unwrap_or(keywords::Invalid.ident()).name
+ self.ident().unwrap_or(Ident::invalid()).name
}
pub fn value_str(&self) -> Option<Symbol> {
@@ -206,7 +206,7 @@ impl MetaItem {
}
}
pub fn name_or_empty(&self) -> Symbol {
- self.ident().unwrap_or(keywords::Invalid.ident()).name
+ self.ident().unwrap_or(Ident::invalid()).name
}
// #[attribute(name = "value")]
diff --git a/src/libsyntax/diagnostics/plugin.rs b/src/libsyntax/diagnostics/plugin.rs
index c988dc61bec44..e9476e2fdfd51 100644
--- a/src/libsyntax/diagnostics/plugin.rs
+++ b/src/libsyntax/diagnostics/plugin.rs
@@ -7,7 +7,7 @@ use crate::ext::base::{ExtCtxt, MacEager, MacResult};
use crate::ext::build::AstBuilder;
use crate::parse::token;
use crate::ptr::P;
-use crate::symbol::keywords;
+use crate::symbol::kw;
use crate::tokenstream::{TokenTree};
use smallvec::smallvec;
@@ -185,7 +185,7 @@ pub fn expand_build_diagnostic_array<'cx>(ecx: &'cx mut ExtCtxt<'_>,
(descriptions.len(), ecx.expr_vec(span, descriptions))
});
- let static_ = ecx.lifetime(span, keywords::StaticLifetime.ident());
+ let static_ = ecx.lifetime(span, Ident::with_empty_ctxt(kw::StaticLifetime));
let ty_str = ecx.ty_rptr(
span,
ecx.ty_ident(span, ecx.ident_of("str")),
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index 489fac4f1ca4c..f1a20d5406574 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -10,7 +10,7 @@ use crate::mut_visit::{self, MutVisitor};
use crate::parse::{self, parser, DirectoryOwnership};
use crate::parse::token;
use crate::ptr::P;
-use crate::symbol::{keywords, Ident, Symbol, sym};
+use crate::symbol::{kw, sym, Ident, Symbol};
use crate::ThinVec;
use crate::tokenstream::{self, TokenStream};
@@ -971,7 +971,7 @@ impl<'a> ExtCtxt<'a> {
}
pub fn std_path(&self, components: &[&str]) -> Vec<ast::Ident> {
let def_site = DUMMY_SP.apply_mark(self.current_expansion.mark);
- iter::once(Ident::new(keywords::DollarCrate.name(), def_site))
+ iter::once(Ident::new(kw::DollarCrate, def_site))
.chain(components.iter().map(|s| self.ident_of(s)))
.collect()
}
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index d24106f697e19..466715e69fd56 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -3,7 +3,7 @@ use crate::attr;
use crate::source_map::{dummy_spanned, respan, Spanned};
use crate::ext::base::ExtCtxt;
use crate::ptr::P;
-use crate::symbol::{Symbol, keywords};
+use crate::symbol::{Symbol, kw};
use crate::ThinVec;
use rustc_target::spec::abi::Abi;
@@ -628,7 +628,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
self.expr_path(self.path_ident(span, id))
}
fn expr_self(&self, span: Span) -> P<ast::Expr> {
- self.expr_ident(span, keywords::SelfLower.ident())
+ self.expr_ident(span, Ident::with_empty_ctxt(kw::SelfLower))
}
fn expr_binary(&self, sp: Span, op: ast::BinOpKind,
@@ -1175,7 +1175,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
vis: ast::Visibility, vp: P<ast::UseTree>) -> P<ast::Item> {
P(ast::Item {
id: ast::DUMMY_NODE_ID,
- ident: keywords::Invalid.ident(),
+ ident: Ident::invalid(),
attrs: vec![],
node: ast::ItemKind::Use(vp),
vis,
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index 478ae4de82b74..fbe052252a114 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -14,7 +14,7 @@ use crate::parse::token::{self, Token};
use crate::parse::parser::Parser;
use crate::ptr::P;
use crate::symbol::Symbol;
-use crate::symbol::{keywords, sym};
+use crate::symbol::{kw, sym};
use crate::tokenstream::{TokenStream, TokenTree};
use crate::visit::{self, Visitor};
use crate::util::map_in_place::MapInPlace;
@@ -198,7 +198,7 @@ fn macro_bang_format(path: &ast::Path) -> ExpnFormat {
if i != 0 {
path_str.push_str("::");
}
- if segment.ident.name != keywords::PathRoot.name() {
+ if segment.ident.name != kw::PathRoot {
path_str.push_str(&segment.ident.as_str())
}
}
@@ -271,7 +271,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
attrs: krate.attrs,
span: krate.span,
node: ast::ItemKind::Mod(krate.module),
- ident: keywords::Invalid.ident(),
+ ident: Ident::invalid(),
id: ast::DUMMY_NODE_ID,
vis: respan(krate.span.shrink_to_lo(), ast::VisibilityKind::Public),
tokens: None,
@@ -708,7 +708,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
};
let path = &mac.node.path;
- let ident = ident.unwrap_or_else(|| keywords::Invalid.ident());
+ let ident = ident.unwrap_or_else(|| Ident::invalid());
let validate_and_set_expn_info = |this: &mut Self, // arg instead of capture
def_site_span: Option<Span>,
allow_internal_unstable,
@@ -736,7 +736,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
}
}
- if ident.name != keywords::Invalid.name() {
+ if ident.name != kw::Invalid {
let msg = format!("macro {}! expects no ident argument, given '{}'", path, ident);
this.cx.span_err(path.span, &msg);
this.cx.trace_macros_diag();
@@ -792,7 +792,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
}
IdentTT { ref expander, span: tt_span, ref allow_internal_unstable } => {
- if ident.name == keywords::Invalid.name() {
+ if ident.name == kw::Invalid {
self.cx.span_err(path.span,
&format!("macro {}! expects an ident argument", path));
self.cx.trace_macros_diag();
@@ -828,7 +828,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
}
SyntaxExtension::ProcMacro { ref expander, ref allow_internal_unstable, edition } => {
- if ident.name != keywords::Invalid.name() {
+ if ident.name != kw::Invalid {
let msg =
format!("macro {}! expects no ident argument, given '{}'", path, ident);
self.cx.span_err(path.span, &msg);
@@ -929,7 +929,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
invoc.expansion_data.mark.set_expn_info(expn_info);
let span = span.with_ctxt(self.cx.backtrace());
let dummy = ast::MetaItem { // FIXME(jseyfried) avoid this
- path: Path::from_ident(keywords::Invalid.ident()),
+ path: Path::from_ident(Ident::invalid()),
span: DUMMY_SP,
node: ast::MetaItemKind::Word,
};
@@ -1338,7 +1338,7 @@ impl<'a, 'b> MutVisitor for InvocationCollector<'a, 'b> {
})
}
ast::ItemKind::Mod(ast::Mod { inner, .. }) => {
- if item.ident == keywords::Invalid.ident() {
+ if item.ident == Ident::invalid() {
return noop_flat_map_item(item, self);
}
diff --git a/src/libsyntax/ext/placeholders.rs b/src/libsyntax/ext/placeholders.rs
index f5e18e98436e6..8f24d11cfd5b0 100644
--- a/src/libsyntax/ext/placeholders.rs
+++ b/src/libsyntax/ext/placeholders.rs
@@ -6,7 +6,6 @@ use crate::ext::hygiene::Mark;
use crate::tokenstream::TokenStream;
use crate::mut_visit::*;
use crate::ptr::P;
-use crate::symbol::keywords;
use crate::ThinVec;
use smallvec::{smallvec, SmallVec};
@@ -22,7 +21,7 @@ pub fn placeholder(kind: AstFragmentKind, id: ast::NodeId) -> AstFragment {
})
}
- let ident = keywords::Invalid.ident();
+ let ident = ast::Ident::invalid();
let attrs = Vec::new();
let generics = ast::Generics::default();
let vis = dummy_spanned(ast::VisibilityKind::Inherited);
diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs
index 084a69f4cda0f..fa1f85c0e7b57 100644
--- a/src/libsyntax/ext/tt/macro_parser.rs
+++ b/src/libsyntax/ext/tt/macro_parser.rs
@@ -80,7 +80,7 @@ use crate::parse::{Directory, ParseSess};
use crate::parse::parser::{Parser, PathStyle};
use crate::parse::token::{self, DocComment, Nonterminal, Token};
use crate::print::pprust;
-use crate::symbol::keywords;
+use crate::symbol::kw;
use crate::tokenstream::{DelimSpan, TokenStream};
use errors::FatalError;
@@ -382,7 +382,7 @@ fn nameize<I: Iterator<Item = NamedMatch>>(
TokenTree::Delimited(_, ref delim) => for next_m in &delim.tts {
n_rec(sess, next_m, res.by_ref(), ret_val)?;
},
- TokenTree::MetaVarDecl(span, _, id) if id.name == keywords::Invalid.name() => {
+ TokenTree::MetaVarDecl(span, _, id) if id.name == kw::Invalid => {
if sess.missing_fragment_specifiers.borrow_mut().remove(&span) {
return Err((span, "missing fragment specifier".to_string()));
}
@@ -587,7 +587,7 @@ fn inner_parse_loop<'root, 'tt>(
}
// We need to match a metavar (but the identifier is invalid)... this is an error
- TokenTree::MetaVarDecl(span, _, id) if id.name == keywords::Invalid.name() => {
+ TokenTree::MetaVarDecl(span, _, id) if id.name == kw::Invalid => {
if sess.missing_fragment_specifiers.borrow_mut().remove(&span) {
return Error(span, "missing fragment specifier".to_string());
}
@@ -802,7 +802,7 @@ pub fn parse(
/// We prohibit passing `_` to macros expecting `ident` for now.
fn get_macro_ident(token: &Token) -> Option<(Ident, bool)> {
match *token {
- token::Ident(ident, is_raw) if ident.name != keywords::Underscore.name() =>
+ token::Ident(ident, is_raw) if ident.name != kw::Underscore =>
Some((ident, is_raw)),
_ => None,
}
diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs
index 672b7b4285522..37c49112dcaac 100644
--- a/src/libsyntax/ext/tt/macro_rules.rs
+++ b/src/libsyntax/ext/tt/macro_rules.rs
@@ -13,7 +13,7 @@ use crate::parse::{Directory, ParseSess};
use crate::parse::parser::Parser;
use crate::parse::token::{self, NtTT};
use crate::parse::token::Token::*;
-use crate::symbol::{Symbol, keywords, sym};
+use crate::symbol::{Symbol, kw, sym};
use crate::tokenstream::{DelimSpan, TokenStream, TokenTree};
use errors::FatalError;
@@ -1046,8 +1046,8 @@ fn is_in_follow(tok: "ed::TokenTree, frag: &str) -> IsInFollow {
match *tok {
TokenTree::Token(_, ref tok) => match *tok {
FatArrow | Comma | Eq | BinOp(token::Or) => IsInFollow::Yes,
- Ident(i, false) if i.name == keywords::If.name() ||
- i.name == keywords::In.name() => IsInFollow::Yes,
+ Ident(i, false) if i.name == kw::If ||
+ i.name == kw::In => IsInFollow::Yes,
_ => IsInFollow::No(tokens),
},
_ => IsInFollow::No(tokens),
@@ -1064,8 +1064,8 @@ fn is_in_follow(tok: "ed::TokenTree, frag: &str) -> IsInFollow {
OpenDelim(token::DelimToken::Bracket) |
Comma | FatArrow | Colon | Eq | Gt | BinOp(token::Shr) | Semi |
BinOp(token::Or) => IsInFollow::Yes,
- Ident(i, false) if i.name == keywords::As.name() ||
- i.name == keywords::Where.name() => IsInFollow::Yes,
+ Ident(i, false) if i.name == kw::As ||
+ i.name == kw::Where => IsInFollow::Yes,
_ => IsInFollow::No(tokens),
},
TokenTree::MetaVarDecl(_, _, frag) if frag.name == sym::block =>
@@ -1092,7 +1092,7 @@ fn is_in_follow(tok: "ed::TokenTree, frag: &str) -> IsInFollow {
match *tok {
TokenTree::Token(_, ref tok) => match *tok {
Comma => IsInFollow::Yes,
- Ident(i, is_raw) if is_raw || i.name != keywords::Priv.name() =>
+ Ident(i, is_raw) if is_raw || i.name != kw::Priv =>
IsInFollow::Yes,
ref tok => if tok.can_begin_type() {
IsInFollow::Yes
@@ -1107,7 +1107,7 @@ fn is_in_follow(tok: "ed::TokenTree, frag: &str) -> IsInFollow {
_ => IsInFollow::No(tokens),
}
},
- "" => IsInFollow::Yes, // keywords::Invalid
+ "" => IsInFollow::Yes, // kw::Invalid
_ => IsInFollow::Invalid(format!("invalid fragment specifier `{}`", frag),
VALID_FRAGMENT_NAMES_MSG),
}
diff --git a/src/libsyntax/ext/tt/quoted.rs b/src/libsyntax/ext/tt/quoted.rs
index ed8395f11ad50..a029c65465952 100644
--- a/src/libsyntax/ext/tt/quoted.rs
+++ b/src/libsyntax/ext/tt/quoted.rs
@@ -6,7 +6,7 @@ use crate::parse::{token, ParseSess};
use crate::print::pprust;
use crate::tokenstream::{self, DelimSpan};
use crate::ast;
-use crate::symbol::keywords;
+use crate::symbol::kw;
use syntax_pos::{edition::Edition, BytePos, Span};
@@ -228,7 +228,7 @@ pub fn parse(
result.push(TokenTree::MetaVarDecl(
span,
ident,
- keywords::Invalid.ident(),
+ ast::Ident::invalid(),
));
}
@@ -319,8 +319,8 @@ where
Some(tokenstream::TokenTree::Token(ident_span, ref token)) if token.is_ident() => {
let (ident, is_raw) = token.ident().unwrap();
let span = ident_span.with_lo(span.lo());
- if ident.name == keywords::Crate.name() && !is_raw {
- let ident = ast::Ident::new(keywords::DollarCrate.name(), ident.span);
+ if ident.name == kw::Crate && !is_raw {
+ let ident = ast::Ident::new(kw::DollarCrate, ident.span);
TokenTree::Token(span, token::Ident(ident, is_raw))
} else {
TokenTree::MetaVar(span, ident)
@@ -334,7 +334,7 @@ where
pprust::token_to_string(&tok)
);
sess.span_diagnostic.span_err(span, &msg);
- TokenTree::MetaVar(span, keywords::Invalid.ident())
+ TokenTree::MetaVar(span, ast::Ident::invalid())
}
// There are no more tokens. Just return the `$` we already have.
diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs
index 5b1a9bb739ff8..57a6656140f00 100644
--- a/src/libsyntax/feature_gate.rs
+++ b/src/libsyntax/feature_gate.rs
@@ -22,7 +22,7 @@ use crate::source_map::Spanned;
use crate::edition::{ALL_EDITIONS, Edition};
use crate::visit::{self, FnKind, Visitor};
use crate::parse::{token, ParseSess};
-use crate::symbol::{Symbol, keywords, sym};
+use crate::symbol::{Symbol, kw, sym};
use crate::tokenstream::TokenTree;
use errors::{DiagnosticBuilder, Handler};
@@ -1948,7 +1948,7 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
fn visit_item(&mut self, i: &'a ast::Item) {
match i.node {
ast::ItemKind::Const(_,_) => {
- if i.ident.name == keywords::Underscore.name() {
+ if i.ident.name == kw::Underscore {
gate_feature_post!(&self, underscore_const_names, i.span,
"naming constants with `_` is unstable");
}
diff --git a/src/libsyntax/mut_visit.rs b/src/libsyntax/mut_visit.rs
index 8fdd15a029f13..a6564de3b982d 100644
--- a/src/libsyntax/mut_visit.rs
+++ b/src/libsyntax/mut_visit.rs
@@ -11,7 +11,6 @@ use crate::ast::*;
use crate::source_map::{Spanned, respan};
use crate::parse::token::{self, Token};
use crate::ptr::P;
-use crate::symbol::keywords;
use crate::ThinVec;
use crate::tokenstream::*;
use crate::util::map_in_place::MapInPlace;
@@ -977,7 +976,7 @@ pub fn noop_visit_mod<T: MutVisitor>(Mod { inner, items, inline: _ }: &mut Mod,
pub fn noop_visit_crate<T: MutVisitor>(krate: &mut Crate, vis: &mut T) {
visit_clobber(krate, |Crate { module, attrs, span }| {
let item = P(Item {
- ident: keywords::Invalid.ident(),
+ ident: Ident::invalid(),
attrs,
id: DUMMY_NODE_ID,
vis: respan(span.shrink_to_lo(), VisibilityKind::Public),
diff --git a/src/libsyntax/parse/diagnostics.rs b/src/libsyntax/parse/diagnostics.rs
index 1a2393be806d5..d48fcbbd6720d 100644
--- a/src/libsyntax/parse/diagnostics.rs
+++ b/src/libsyntax/parse/diagnostics.rs
@@ -6,7 +6,7 @@ use crate::parse::PResult;
use crate::parse::Parser;
use crate::print::pprust;
use crate::ptr::P;
-use crate::symbol::keywords;
+use crate::symbol::kw;
use crate::ThinVec;
use errors::{Applicability, DiagnosticBuilder};
use syntax_pos::Span;
@@ -405,7 +405,7 @@ impl<'a> Parser<'a> {
/// Recover from `pub` keyword in places where it seems _reasonable_ but isn't valid.
crate fn eat_bad_pub(&mut self) {
- if self.token.is_keyword(keywords::Pub) {
+ if self.token.is_keyword(kw::Pub) {
match self.parse_visibility(false) {
Ok(vis) => {
self.diagnostic()
diff --git a/src/libsyntax/parse/literal.rs b/src/libsyntax/parse/literal.rs
index 53195421ddcee..f277f0522b8e5 100644
--- a/src/libsyntax/parse/literal.rs
+++ b/src/libsyntax/parse/literal.rs
@@ -6,7 +6,7 @@ use crate::parse::PResult;
use crate::parse::token::{self, Token};
use crate::parse::unescape::{unescape_str, unescape_char, unescape_byte_str, unescape_byte};
use crate::print::pprust;
-use crate::symbol::{keywords, Symbol};
+use crate::symbol::{kw, Symbol};
use crate::tokenstream::{TokenStream, TokenTree};
use errors::{Applicability, Handler};
@@ -43,8 +43,8 @@ impl LitKind {
Some(match lit {
token::Bool(i) => {
- assert!(i == keywords::True.name() || i == keywords::False.name());
- LitKind::Bool(i == keywords::True.name())
+ assert!(i == kw::True || i == kw::False);
+ LitKind::Bool(i == kw::True)
}
token::Byte(i) => {
match unescape_byte(&i.as_str()) {
@@ -156,8 +156,8 @@ impl LitKind {
}
LitKind::FloatUnsuffixed(symbol) => (token::Lit::Float(symbol), None),
LitKind::Bool(value) => {
- let kw = if value { keywords::True } else { keywords::False };
- (token::Lit::Bool(kw.name()), None)
+ let kw = if value { kw::True } else { kw::False };
+ (token::Lit::Bool(kw), None)
}
LitKind::Err(val) => (token::Lit::Err(val), None),
}
@@ -175,8 +175,7 @@ impl Lit {
diag: Option<(Span, &Handler)>,
) -> Option<Lit> {
let (token, suffix) = match *token {
- token::Ident(ident, false) if ident.name == keywords::True.name() ||
- ident.name == keywords::False.name() =>
+ token::Ident(ident, false) if ident.name == kw::True || ident.name == kw::False =>
(token::Bool(ident.name), None),
token::Literal(token, suffix) =>
(token, suffix),
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 24d120376def1..6c1f1d51a0741 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -46,7 +46,7 @@ use crate::ptr::P;
use crate::parse::PResult;
use crate::ThinVec;
use crate::tokenstream::{self, DelimSpan, TokenTree, TokenStream, TreeAndJoint};
-use crate::symbol::{keywords, sym, Symbol};
+use crate::symbol::{kw, sym, Symbol};
use errors::{Applicability, DiagnosticBuilder, DiagnosticId, FatalError};
use rustc_target::spec::abi::{self, Abi};
@@ -379,7 +379,7 @@ impl TokenCursor {
#[derive(Clone, PartialEq)]
crate enum TokenType {
Token(token::Token),
- Keyword(keywords::Keyword),
+ Keyword(Symbol),
Operator,
Lifetime,
Ident,
@@ -392,7 +392,7 @@ impl TokenType {
crate fn to_string(&self) -> String {
match *self {
TokenType::Token(ref t) => format!("`{}`", pprust::token_to_string(t)),
- TokenType::Keyword(kw) => format!("`{}`", kw.name()),
+ TokenType::Keyword(kw) => format!("`{}`", kw),
TokenType::Operator => "an operator".to_string(),
TokenType::Lifetime => "lifetime".to_string(),
TokenType::Ident => "identifier".to_string(),
@@ -510,7 +510,7 @@ impl From<P<Expr>> for LhsExpr {
/// Creates a placeholder argument.
fn dummy_arg(span: Span) -> Arg {
- let ident = Ident::new(keywords::Invalid.name(), span);
+ let ident = Ident::new(kw::Invalid, span);
let pat = P(Pat {
id: ast::DUMMY_NODE_ID,
node: PatKind::Ident(BindingMode::ByValue(Mutability::Immutable), ident, None),
@@ -771,15 +771,15 @@ impl<'a> Parser<'a> {
TokenType::Token(token::Semi) => true, // we expect a `;` here
_ => false,
}) && ( // a `;` would be expected before the current keyword
- self.token.is_keyword(keywords::Break) ||
- self.token.is_keyword(keywords::Continue) ||
- self.token.is_keyword(keywords::For) ||
- self.token.is_keyword(keywords::If) ||
- self.token.is_keyword(keywords::Let) ||
- self.token.is_keyword(keywords::Loop) ||
- self.token.is_keyword(keywords::Match) ||
- self.token.is_keyword(keywords::Return) ||
- self.token.is_keyword(keywords::While)
+ self.token.is_keyword(kw::Break) ||
+ self.token.is_keyword(kw::Continue) ||
+ self.token.is_keyword(kw::For) ||
+ self.token.is_keyword(kw::If) ||
+ self.token.is_keyword(kw::Let) ||
+ self.token.is_keyword(kw::Loop) ||
+ self.token.is_keyword(kw::Match) ||
+ self.token.is_keyword(kw::Return) ||
+ self.token.is_keyword(kw::While)
);
let cm = self.sess.source_map();
match (cm.lookup_line(self.span.lo()), cm.lookup_line(sp.lo())) {
@@ -913,14 +913,14 @@ impl<'a> Parser<'a> {
is_present
}
- fn check_keyword(&mut self, kw: keywords::Keyword) -> bool {
+ fn check_keyword(&mut self, kw: Symbol) -> bool {
self.expected_tokens.push(TokenType::Keyword(kw));
self.token.is_keyword(kw)
}
/// If the next token is the given keyword, eats it and returns
/// `true`. Otherwise, returns `false`.
- pub fn eat_keyword(&mut self, kw: keywords::Keyword) -> bool {
+ pub fn eat_keyword(&mut self, kw: Symbol) -> bool {
if self.check_keyword(kw) {
self.bump();
true
@@ -929,7 +929,7 @@ impl<'a> Parser<'a> {
}
}
- fn eat_keyword_noexpect(&mut self, kw: keywords::Keyword) -> bool {
+ fn eat_keyword_noexpect(&mut self, kw: Symbol) -> bool {
if self.token.is_keyword(kw) {
self.bump();
true
@@ -941,7 +941,7 @@ impl<'a> Parser<'a> {
/// If the given word is not a keyword, signals an error.
/// If the next token is not the given word, signals an error.
/// Otherwise, eats it.
- fn expect_keyword(&mut self, kw: keywords::Keyword) -> PResult<'a, ()> {
+ fn expect_keyword(&mut self, kw: Symbol) -> PResult<'a, ()> {
if !self.eat_keyword(kw) {
self.unexpected()
} else {
@@ -1375,9 +1375,9 @@ impl<'a> Parser<'a> {
/// Is the current token one of the keywords that signals a bare function type?
fn token_is_bare_fn_keyword(&mut self) -> bool {
- self.check_keyword(keywords::Fn) ||
- self.check_keyword(keywords::Unsafe) ||
- self.check_keyword(keywords::Extern)
+ self.check_keyword(kw::Fn) ||
+ self.check_keyword(kw::Unsafe) ||
+ self.check_keyword(kw::Extern)
}
/// Parses a `TyKind::BareFn` type.
@@ -1395,13 +1395,13 @@ impl<'a> Parser<'a> {
*/
let unsafety = self.parse_unsafety();
- let abi = if self.eat_keyword(keywords::Extern) {
+ let abi = if self.eat_keyword(kw::Extern) {
self.parse_opt_abi()?.unwrap_or(Abi::C)
} else {
Abi::Rust
};
- self.expect_keyword(keywords::Fn)?;
+ self.expect_keyword(kw::Fn)?;
let (inputs, c_variadic) = self.parse_fn_args(false, true)?;
let ret_ty = self.parse_ret_ty(false)?;
let decl = P(FnDecl {
@@ -1419,7 +1419,7 @@ impl<'a> Parser<'a> {
/// Parses asyncness: `async` or nothing.
fn parse_asyncness(&mut self) -> IsAsync {
- if self.eat_keyword(keywords::Async) {
+ if self.eat_keyword(kw::Async) {
IsAsync::Async {
closure_id: ast::DUMMY_NODE_ID,
return_impl_trait_id: ast::DUMMY_NODE_ID,
@@ -1432,7 +1432,7 @@ impl<'a> Parser<'a> {
/// Parses unsafety: `unsafe` or nothing.
fn parse_unsafety(&mut self) -> Unsafety {
- if self.eat_keyword(keywords::Unsafe) {
+ if self.eat_keyword(kw::Unsafe) {
Unsafety::Unsafe
} else {
Unsafety::Normal
@@ -1462,10 +1462,10 @@ impl<'a> Parser<'a> {
mut attrs: Vec<Attribute>) -> PResult<'a, TraitItem> {
let lo = self.span;
self.eat_bad_pub();
- let (name, node, generics) = if self.eat_keyword(keywords::Type) {
+ let (name, node, generics) = if self.eat_keyword(kw::Type) {
self.parse_trait_item_assoc_ty()?
} else if self.is_const_item() {
- self.expect_keyword(keywords::Const)?;
+ self.expect_keyword(kw::Const)?;
let ident = self.parse_ident()?;
self.expect(&token::Colon)?;
let ty = self.parse_ty()?;
@@ -1480,7 +1480,7 @@ impl<'a> Parser<'a> {
(ident, TraitItemKind::Const(ty, default), ast::Generics::default())
} else if let Some(mac) = self.parse_assoc_macro_invoc("trait", None, &mut false)? {
// trait item macro.
- (keywords::Invalid.ident(), ast::TraitItemKind::Macro(mac), ast::Generics::default())
+ (Ident::invalid(), ast::TraitItemKind::Macro(mac), ast::Generics::default())
} else {
let (constness, unsafety, mut asyncness, abi) = self.parse_fn_front_matter()?;
@@ -1654,7 +1654,7 @@ impl<'a> Parser<'a> {
// Reference
self.expect_and()?;
self.parse_borrowed_pointee()?
- } else if self.eat_keyword_noexpect(keywords::Typeof) {
+ } else if self.eat_keyword_noexpect(kw::Typeof) {
// `typeof(EXPR)`
// In order to not be ambiguous, the type must be surrounded by parens.
self.expect(&token::OpenDelim(token::Paren))?;
@@ -1664,13 +1664,13 @@ impl<'a> Parser<'a> {
};
self.expect(&token::CloseDelim(token::Paren))?;
TyKind::Typeof(e)
- } else if self.eat_keyword(keywords::Underscore) {
+ } else if self.eat_keyword(kw::Underscore) {
// A type to be inferred `_`
TyKind::Infer
} else if self.token_is_bare_fn_keyword() {
// Function pointer type
self.parse_ty_bare_fn(Vec::new())?
- } else if self.check_keyword(keywords::For) {
+ } else if self.check_keyword(kw::For) {
// Function pointer type or bound list (trait object type) starting with a poly-trait.
// `for<'lt> [unsafe] [extern "ABI"] fn (&'lt S) -> T`
// `for<'lt> Trait1<'lt> + Trait2 + 'a`
@@ -1683,12 +1683,12 @@ impl<'a> Parser<'a> {
let parse_plus = allow_plus && self.check_plus();
self.parse_remaining_bounds(lifetime_defs, path, lo, parse_plus)?
}
- } else if self.eat_keyword(keywords::Impl) {
+ } else if self.eat_keyword(kw::Impl) {
// Always parse bounds greedily for better error recovery.
let bounds = self.parse_generic_bounds(None)?;
impl_dyn_multi = bounds.len() > 1 || self.prev_token_kind == PrevTokenKind::Plus;
TyKind::ImplTrait(ast::DUMMY_NODE_ID, bounds)
- } else if self.check_keyword(keywords::Dyn) &&
+ } else if self.check_keyword(kw::Dyn) &&
(self.span.rust_2018() ||
self.look_ahead(1, |t| t.can_begin_bound() &&
!can_continue_type_after_non_fn_ident(t))) {
@@ -1766,9 +1766,9 @@ impl<'a> Parser<'a> {
}
fn parse_ptr(&mut self) -> PResult<'a, MutTy> {
- let mutbl = if self.eat_keyword(keywords::Mut) {
+ let mutbl = if self.eat_keyword(kw::Mut) {
Mutability::Mutable
- } else if self.eat_keyword(keywords::Const) {
+ } else if self.eat_keyword(kw::Const) {
Mutability::Immutable
} else {
let span = self.prev_span;
@@ -1790,7 +1790,7 @@ impl<'a> Parser<'a> {
_ => 0,
}
token::BinOp(token::And) | token::AndAnd => 1,
- _ if self.token.is_keyword(keywords::Mut) => 1,
+ _ if self.token.is_keyword(kw::Mut) => 1,
_ => 0,
};
@@ -1891,7 +1891,7 @@ impl<'a> Parser<'a> {
}
match ty {
Ok(ty) => {
- let ident = Ident::new(keywords::Invalid.name(), self.prev_span);
+ let ident = Ident::new(kw::Invalid, self.prev_span);
let pat = P(Pat {
id: ast::DUMMY_NODE_ID,
node: PatKind::Ident(
@@ -2006,7 +2006,7 @@ impl<'a> Parser<'a> {
fn parse_ident_or_underscore(&mut self) -> PResult<'a, ast::Ident> {
match self.token {
- token::Ident(ident, false) if ident.name == keywords::Underscore.name() => {
+ token::Ident(ident, false) if ident.name == kw::Underscore => {
let span = self.span;
self.bump();
Ok(Ident::new(ident.name, span))
@@ -2034,7 +2034,7 @@ impl<'a> Parser<'a> {
// above). `path_span` has the span of that path, or an empty
// span in the case of something like `<T>::Bar`.
let (mut path, path_span);
- if self.eat_keyword(keywords::As) {
+ if self.eat_keyword(kw::As) {
let path_lo = self.span;
path = self.parse_path(PathStyle::Type)?;
path_span = path_lo.to(self.prev_span);
@@ -2233,7 +2233,7 @@ impl<'a> Parser<'a> {
/// Parses mutability (`mut` or nothing).
fn parse_mutability(&mut self) -> Mutability {
- if self.eat_keyword(keywords::Mut) {
+ if self.eat_keyword(kw::Mut) {
Mutability::Mutable
} else {
Mutability::Immutable
@@ -2465,37 +2465,37 @@ impl<'a> Parser<'a> {
hi = path.span;
return Ok(self.mk_expr(lo.to(hi), ExprKind::Path(Some(qself), path), attrs));
}
- if self.span.rust_2018() && self.check_keyword(keywords::Async) {
+ if self.span.rust_2018() && self.check_keyword(kw::Async) {
return if self.is_async_block() { // check for `async {` and `async move {`
self.parse_async_block(attrs)
} else {
self.parse_lambda_expr(attrs)
};
}
- if self.check_keyword(keywords::Move) || self.check_keyword(keywords::Static) {
+ if self.check_keyword(kw::Move) || self.check_keyword(kw::Static) {
return self.parse_lambda_expr(attrs);
}
- if self.eat_keyword(keywords::If) {
+ if self.eat_keyword(kw::If) {
return self.parse_if_expr(attrs);
}
- if self.eat_keyword(keywords::For) {
+ if self.eat_keyword(kw::For) {
let lo = self.prev_span;
return self.parse_for_expr(None, lo, attrs);
}
- if self.eat_keyword(keywords::While) {
+ if self.eat_keyword(kw::While) {
let lo = self.prev_span;
return self.parse_while_expr(None, lo, attrs);
}
if let Some(label) = self.eat_label() {
let lo = label.ident.span;
self.expect(&token::Colon)?;
- if self.eat_keyword(keywords::While) {
+ if self.eat_keyword(kw::While) {
return self.parse_while_expr(Some(label), lo, attrs)
}
- if self.eat_keyword(keywords::For) {
+ if self.eat_keyword(kw::For) {
return self.parse_for_expr(Some(label), lo, attrs)
}
- if self.eat_keyword(keywords::Loop) {
+ if self.eat_keyword(kw::Loop) {
return self.parse_loop_expr(Some(label), lo, attrs)
}
if self.token == token::OpenDelim(token::Brace) {
@@ -2509,24 +2509,24 @@ impl<'a> Parser<'a> {
err.span_label(self.span, msg);
return Err(err);
}
- if self.eat_keyword(keywords::Loop) {
+ if self.eat_keyword(kw::Loop) {
let lo = self.prev_span;
return self.parse_loop_expr(None, lo, attrs);
}
- if self.eat_keyword(keywords::Continue) {
+ if self.eat_keyword(kw::Continue) {
let label = self.eat_label();
let ex = ExprKind::Continue(label);
let hi = self.prev_span;
return Ok(self.mk_expr(lo.to(hi), ex, attrs));
}
- if self.eat_keyword(keywords::Match) {
+ if self.eat_keyword(kw::Match) {
let match_sp = self.prev_span;
return self.parse_match_expr(attrs).map_err(|mut err| {
err.span_label(match_sp, "while parsing this match expression");
err
});
}
- if self.eat_keyword(keywords::Unsafe) {
+ if self.eat_keyword(kw::Unsafe) {
return self.parse_block_expr(
None,
lo,
@@ -2540,10 +2540,10 @@ impl<'a> Parser<'a> {
}
if self.is_try_block() {
let lo = self.span;
- assert!(self.eat_keyword(keywords::Try));
+ assert!(self.eat_keyword(kw::Try));
return self.parse_try_block(lo, attrs);
}
- if self.eat_keyword(keywords::Return) {
+ if self.eat_keyword(kw::Return) {
if self.token.can_begin_expr() {
let e = self.parse_expr()?;
hi = e.span;
@@ -2551,7 +2551,7 @@ impl<'a> Parser<'a> {
} else {
ex = ExprKind::Ret(None);
}
- } else if self.eat_keyword(keywords::Break) {
+ } else if self.eat_keyword(kw::Break) {
let label = self.eat_label();
let e = if self.token.can_begin_expr()
&& !(self.token == token::OpenDelim(token::Brace)
@@ -2563,7 +2563,7 @@ impl<'a> Parser<'a> {
};
ex = ExprKind::Break(label, e);
hi = self.prev_span;
- } else if self.eat_keyword(keywords::Yield) {
+ } else if self.eat_keyword(kw::Yield) {
if self.token.can_begin_expr() {
let e = self.parse_expr()?;
hi = e.span;
@@ -2571,14 +2571,14 @@ impl<'a> Parser<'a> {
} else {
ex = ExprKind::Yield(None);
}
- } else if self.token.is_keyword(keywords::Let) {
+ } else if self.token.is_keyword(kw::Let) {
// Catch this syntax error here, instead of in `parse_ident`, so
// that we can explicitly mention that let is not to be used as an expression
let mut db = self.fatal("expected expression, found statement (`let`)");
db.span_label(self.span, "expected expression");
db.note("variable declaration using `let` is a statement");
return Err(db);
- } else if self.span.rust_2018() && self.eat_keyword(keywords::Await) {
+ } else if self.span.rust_2018() && self.eat_keyword(kw::Await) {
let (await_hi, e_kind) = self.parse_await_macro_or_alt(lo, self.prev_span)?;
hi = await_hi;
ex = e_kind;
@@ -2879,7 +2879,7 @@ impl<'a> Parser<'a> {
// Assuming we have just parsed `.`, continue parsing into an expression.
fn parse_dot_suffix(&mut self, self_arg: P<Expr>, lo: Span) -> PResult<'a, P<Expr>> {
- if self.span.rust_2018() && self.eat_keyword(keywords::Await) {
+ if self.span.rust_2018() && self.eat_keyword(kw::Await) {
let span = lo.to(self.prev_span);
let await_expr = self.mk_expr(
span,
@@ -3250,7 +3250,7 @@ impl<'a> Parser<'a> {
let (span, e) = self.interpolated_or_expr_span(e)?;
(lo.to(span), ExprKind::AddrOf(m, e))
}
- token::Ident(..) if self.token.is_keyword(keywords::In) => {
+ token::Ident(..) if self.token.is_keyword(kw::In) => {
self.bump();
let place = self.parse_expr_res(
Restrictions::NO_STRUCT_LITERAL,
@@ -3261,7 +3261,7 @@ impl<'a> Parser<'a> {
let blk_expr = self.mk_expr(span, ExprKind::Block(blk, None), ThinVec::new());
(lo.to(span), ExprKind::ObsoleteInPlace(place, blk_expr))
}
- token::Ident(..) if self.token.is_keyword(keywords::Box) => {
+ token::Ident(..) if self.token.is_keyword(kw::Box) => {
self.bump();
let e = self.parse_prefix_expr(None);
let (span, e) = self.interpolated_or_expr_span(e)?;
@@ -3683,7 +3683,7 @@ impl<'a> Parser<'a> {
/// Parses an `if` or `if let` expression (`if` token already eaten).
fn parse_if_expr(&mut self, attrs: ThinVec<Attribute>) -> PResult<'a, P<Expr>> {
- if self.check_keyword(keywords::Let) {
+ if self.check_keyword(kw::Let) {
return self.parse_if_let_expr(attrs);
}
let lo = self.prev_span;
@@ -3693,7 +3693,7 @@ impl<'a> Parser<'a> {
// verify that the last statement is either an implicit return (no `;`) or an explicit
// return. This won't catch blocks with an explicit `return`, but that would be caught by
// the dead code lint.
- if self.eat_keyword(keywords::Else) || !cond.returns() {
+ if self.eat_keyword(kw::Else) || !cond.returns() {
let sp = self.sess.source_map().next_point(lo);
let mut err = self.diagnostic()
.struct_span_err(sp, "missing condition for `if` statemement");
@@ -3709,7 +3709,7 @@ impl<'a> Parser<'a> {
})?;
let mut els: Option<P<Expr>> = None;
let mut hi = thn.span;
- if self.eat_keyword(keywords::Else) {
+ if self.eat_keyword(kw::Else) {
let elexpr = self.parse_else_expr()?;
hi = elexpr.span;
els = Some(elexpr);
@@ -3721,12 +3721,12 @@ impl<'a> Parser<'a> {
fn parse_if_let_expr(&mut self, attrs: ThinVec<Attribute>)
-> PResult<'a, P<Expr>> {
let lo = self.prev_span;
- self.expect_keyword(keywords::Let)?;
+ self.expect_keyword(kw::Let)?;
let pats = self.parse_pats()?;
self.expect(&token::Eq)?;
let expr = self.parse_expr_res(Restrictions::NO_STRUCT_LITERAL, None)?;
let thn = self.parse_block()?;
- let (hi, els) = if self.eat_keyword(keywords::Else) {
+ let (hi, els) = if self.eat_keyword(kw::Else) {
let expr = self.parse_else_expr()?;
(expr.span, Some(expr))
} else {
@@ -3741,7 +3741,7 @@ impl<'a> Parser<'a> {
-> PResult<'a, P<Expr>>
{
let lo = self.span;
- let movability = if self.eat_keyword(keywords::Static) {
+ let movability = if self.eat_keyword(kw::Static) {
Movability::Static
} else {
Movability::Movable
@@ -3751,7 +3751,7 @@ impl<'a> Parser<'a> {
} else {
IsAsync::NotAsync
};
- let capture_clause = if self.eat_keyword(keywords::Move) {
+ let capture_clause = if self.eat_keyword(kw::Move) {
CaptureBy::Value
} else {
CaptureBy::Ref
@@ -3779,7 +3779,7 @@ impl<'a> Parser<'a> {
// `else` token already eaten
fn parse_else_expr(&mut self) -> PResult<'a, P<Expr>> {
- if self.eat_keyword(keywords::If) {
+ if self.eat_keyword(kw::If) {
return self.parse_if_expr(ThinVec::new());
} else {
let blk = self.parse_block()?;
@@ -3794,7 +3794,7 @@ impl<'a> Parser<'a> {
// Parse: `for <src_pat> in <src_expr> <src_loop_block>`
let pat = self.parse_top_level_pat()?;
- if !self.eat_keyword(keywords::In) {
+ if !self.eat_keyword(kw::In) {
let in_span = self.prev_span.between(self.span);
let mut err = self.sess.span_diagnostic
.struct_span_err(in_span, "missing `in` in `for` loop");
@@ -3806,7 +3806,7 @@ impl<'a> Parser<'a> {
err.emit();
}
let in_span = self.prev_span;
- if self.eat_keyword(keywords::In) {
+ if self.eat_keyword(kw::In) {
// a common typo: `for _ in in bar {}`
let mut err = self.sess.span_diagnostic.struct_span_err(
self.prev_span,
@@ -3835,7 +3835,7 @@ impl<'a> Parser<'a> {
fn parse_while_expr(&mut self, opt_label: Option<Label>,
span_lo: Span,
mut attrs: ThinVec<Attribute>) -> PResult<'a, P<Expr>> {
- if self.token.is_keyword(keywords::Let) {
+ if self.token.is_keyword(kw::Let) {
return self.parse_while_let_expr(opt_label, span_lo, attrs);
}
let cond = self.parse_expr_res(Restrictions::NO_STRUCT_LITERAL, None)?;
@@ -3849,7 +3849,7 @@ impl<'a> Parser<'a> {
fn parse_while_let_expr(&mut self, opt_label: Option<Label>,
span_lo: Span,
mut attrs: ThinVec<Attribute>) -> PResult<'a, P<Expr>> {
- self.expect_keyword(keywords::Let)?;
+ self.expect_keyword(kw::Let)?;
let pats = self.parse_pats()?;
self.expect(&token::Eq)?;
let expr = self.parse_expr_res(Restrictions::NO_STRUCT_LITERAL, None)?;
@@ -3874,8 +3874,8 @@ impl<'a> Parser<'a> {
-> PResult<'a, P<Expr>>
{
let span_lo = self.span;
- self.expect_keyword(keywords::Async)?;
- let capture_clause = if self.eat_keyword(keywords::Move) {
+ self.expect_keyword(kw::Async)?;
+ let capture_clause = if self.eat_keyword(kw::Move) {
CaptureBy::Value
} else {
CaptureBy::Ref
@@ -3893,7 +3893,7 @@ impl<'a> Parser<'a> {
{
let (iattrs, body) = self.parse_inner_attrs_and_block()?;
attrs.extend(iattrs);
- if self.eat_keyword(keywords::Catch) {
+ if self.eat_keyword(kw::Catch) {
let mut error = self.struct_span_err(self.prev_span,
"keyword `catch` cannot follow a `try` block");
error.help("try using `match` on the result of the `try` block instead");
@@ -3947,7 +3947,7 @@ impl<'a> Parser<'a> {
crate fn parse_arm(&mut self) -> PResult<'a, Arm> {
let attrs = self.parse_outer_attributes()?;
let pats = self.parse_pats()?;
- let guard = if self.eat_keyword(keywords::If) {
+ let guard = if self.eat_keyword(kw::If) {
Some(Guard::If(self.parse_expr()?))
} else {
None
@@ -4211,10 +4211,10 @@ impl<'a> Parser<'a> {
(pat, fieldname, false)
} else {
// Parsing a pattern of the form "(box) (ref) (mut) fieldname"
- let is_box = self.eat_keyword(keywords::Box);
+ let is_box = self.eat_keyword(kw::Box);
let boxed_span = self.span;
- let is_ref = self.eat_keyword(keywords::Ref);
- let is_mut = self.eat_keyword(keywords::Mut);
+ let is_ref = self.eat_keyword(kw::Ref);
+ let is_mut = self.eat_keyword(kw::Mut);
let fieldname = self.parse_ident()?;
hi = self.prev_span;
@@ -4493,13 +4493,13 @@ impl<'a> Parser<'a> {
pat = PatKind::Slice(before, slice, after);
}
// At this point, token != &, &&, (, [
- _ => if self.eat_keyword(keywords::Underscore) {
+ _ => if self.eat_keyword(kw::Underscore) {
// Parse _
pat = PatKind::Wild;
- } else if self.eat_keyword(keywords::Mut) {
+ } else if self.eat_keyword(kw::Mut) {
// Parse mut ident @ pat / mut ref ident @ pat
let mutref_span = self.prev_span.to(self.span);
- let binding_mode = if self.eat_keyword(keywords::Ref) {
+ let binding_mode = if self.eat_keyword(kw::Ref) {
self.diagnostic()
.struct_span_err(mutref_span, "the order of `mut` and `ref` is incorrect")
.span_suggestion(
@@ -4513,11 +4513,11 @@ impl<'a> Parser<'a> {
BindingMode::ByValue(Mutability::Mutable)
};
pat = self.parse_pat_ident(binding_mode)?;
- } else if self.eat_keyword(keywords::Ref) {
+ } else if self.eat_keyword(kw::Ref) {
// Parse ref ident @ pat / ref mut ident @ pat
let mutbl = self.parse_mutability();
pat = self.parse_pat_ident(BindingMode::ByRef(mutbl))?;
- } else if self.eat_keyword(keywords::Box) {
+ } else if self.eat_keyword(kw::Box) {
// Parse box pat
let subpat = self.parse_pat_with_range_pat(false, None)?;
pat = PatKind::Box(subpat);
@@ -4816,10 +4816,10 @@ impl<'a> Parser<'a> {
}
fn is_async_block(&self) -> bool {
- self.token.is_keyword(keywords::Async) &&
+ self.token.is_keyword(kw::Async) &&
(
( // `async move {`
- self.look_ahead(1, |t| t.is_keyword(keywords::Move)) &&
+ self.look_ahead(1, |t| t.is_keyword(kw::Move)) &&
self.look_ahead(2, |t| *t == token::OpenDelim(token::Brace))
) || ( // `async {`
self.look_ahead(1, |t| *t == token::OpenDelim(token::Brace))
@@ -4828,19 +4828,19 @@ impl<'a> Parser<'a> {
}
fn is_async_fn(&self) -> bool {
- self.token.is_keyword(keywords::Async) &&
- self.look_ahead(1, |t| t.is_keyword(keywords::Fn))
+ self.token.is_keyword(kw::Async) &&
+ self.look_ahead(1, |t| t.is_keyword(kw::Fn))
}
fn is_do_catch_block(&self) -> bool {
- self.token.is_keyword(keywords::Do) &&
- self.look_ahead(1, |t| t.is_keyword(keywords::Catch)) &&
+ self.token.is_keyword(kw::Do) &&
+ self.look_ahead(1, |t| t.is_keyword(kw::Catch)) &&
self.look_ahead(2, |t| *t == token::OpenDelim(token::Brace)) &&
!self.restrictions.contains(Restrictions::NO_STRUCT_LITERAL)
}
fn is_try_block(&self) -> bool {
- self.token.is_keyword(keywords::Try) &&
+ self.token.is_keyword(kw::Try) &&
self.look_ahead(1, |t| *t == token::OpenDelim(token::Brace)) &&
self.span.rust_2018() &&
// prevent `while try {} {}`, `if try {} {} else {}`, etc.
@@ -4848,34 +4848,34 @@ impl<'a> Parser<'a> {
}
fn is_union_item(&self) -> bool {
- self.token.is_keyword(keywords::Union) &&
+ self.token.is_keyword(kw::Union) &&
self.look_ahead(1, |t| t.is_ident() && !t.is_reserved_ident())
}
fn is_crate_vis(&self) -> bool {
- self.token.is_keyword(keywords::Crate) && self.look_ahead(1, |t| t != &token::ModSep)
+ self.token.is_keyword(kw::Crate) && self.look_ahead(1, |t| t != &token::ModSep)
}
fn is_existential_type_decl(&self) -> bool {
- self.token.is_keyword(keywords::Existential) &&
- self.look_ahead(1, |t| t.is_keyword(keywords::Type))
+ self.token.is_keyword(kw::Existential) &&
+ self.look_ahead(1, |t| t.is_keyword(kw::Type))
}
fn is_auto_trait_item(&self) -> bool {
// auto trait
- (self.token.is_keyword(keywords::Auto)
- && self.look_ahead(1, |t| t.is_keyword(keywords::Trait)))
+ (self.token.is_keyword(kw::Auto)
+ && self.look_ahead(1, |t| t.is_keyword(kw::Trait)))
|| // unsafe auto trait
- (self.token.is_keyword(keywords::Unsafe) &&
- self.look_ahead(1, |t| t.is_keyword(keywords::Auto)) &&
- self.look_ahead(2, |t| t.is_keyword(keywords::Trait)))
+ (self.token.is_keyword(kw::Unsafe) &&
+ self.look_ahead(1, |t| t.is_keyword(kw::Auto)) &&
+ self.look_ahead(2, |t| t.is_keyword(kw::Trait)))
}
fn eat_macro_def(&mut self, attrs: &[Attribute], vis: &Visibility, lo: Span)
-> PResult<'a, Option<P<Item>>> {
let token_lo = self.span;
let (ident, def) = match self.token {
- token::Ident(ident, false) if ident.name == keywords::Macro.name() => {
+ token::Ident(ident, false) if ident.name == kw::Macro => {
self.bump();
let ident = self.parse_ident()?;
let tokens = if self.check(&token::OpenDelim(token::Brace)) {
@@ -4933,7 +4933,7 @@ impl<'a> Parser<'a> {
let attrs = self.parse_outer_attributes()?;
let lo = self.span;
- Ok(Some(if self.eat_keyword(keywords::Let) {
+ Ok(Some(if self.eat_keyword(kw::Let) {
Stmt {
id: ast::DUMMY_NODE_ID,
node: StmtKind::Local(self.parse_local(attrs.into())?),
@@ -4986,7 +4986,7 @@ impl<'a> Parser<'a> {
// it's a macro invocation
let id = match self.token {
- token::OpenDelim(_) => keywords::Invalid.ident(), // no special identifier
+ token::OpenDelim(_) => Ident::invalid(), // no special identifier
_ => self.parse_ident()?,
};
@@ -4998,7 +4998,7 @@ impl<'a> Parser<'a> {
_ => {
// we only expect an ident if we didn't parse one
// above.
- let ident_str = if id.name == keywords::Invalid.name() {
+ let ident_str = if id.name == kw::Invalid {
"identifier, "
} else {
""
@@ -5021,7 +5021,7 @@ impl<'a> Parser<'a> {
MacStmtStyle::NoBraces
};
- if id.name == keywords::Invalid.name() {
+ if id.name == kw::Invalid {
let mac = respan(lo.to(hi), Mac_ { path: pth, tts, delim });
let node = if delim == MacDelimiter::Brace ||
self.token == token::Semi || self.token == token::Eof {
@@ -5139,7 +5139,7 @@ impl<'a> Parser<'a> {
let tok = self.this_token_descr();
let mut e = self.span_fatal(sp, &format!("expected `{{`, found {}", tok));
let do_not_suggest_help =
- self.token.is_keyword(keywords::In) || self.token == token::Colon;
+ self.token.is_keyword(kw::In) || self.token == token::Colon;
if self.token.is_ident_named("and") {
e.span_suggestion_short(
@@ -5332,7 +5332,7 @@ impl<'a> Parser<'a> {
let is_bound_start = self.check_path() || self.check_lifetime() ||
self.check(&token::Not) || // used for error reporting only
self.check(&token::Question) ||
- self.check_keyword(keywords::For) ||
+ self.check_keyword(kw::For) ||
self.check(&token::OpenDelim(token::Paren));
if is_bound_start {
let lo = self.span;
@@ -5510,7 +5510,7 @@ impl<'a> Parser<'a> {
}
fn parse_const_param(&mut self, preceding_attrs: Vec<Attribute>) -> PResult<'a, GenericParam> {
- self.expect_keyword(keywords::Const)?;
+ self.expect_keyword(kw::Const)?;
let ident = self.parse_ident()?;
self.expect(&token::Colon)?;
let ty = self.parse_ty()?;
@@ -5547,7 +5547,7 @@ impl<'a> Parser<'a> {
bounds,
kind: ast::GenericParamKind::Lifetime,
});
- } else if self.check_keyword(keywords::Const) {
+ } else if self.check_keyword(kw::Const) {
// Parse const parameter.
params.push(self.parse_const_param(attrs)?);
} else if self.check_ident() {
@@ -5851,7 +5851,7 @@ impl<'a> Parser<'a> {
span: syntax_pos::DUMMY_SP,
};
- if !self.eat_keyword(keywords::Where) {
+ if !self.eat_keyword(kw::Where) {
return Ok(where_clause);
}
let lo = self.prev_span;
@@ -6017,7 +6017,7 @@ impl<'a> Parser<'a> {
_ => unreachable!()
};
let isolated_self = |this: &mut Self, n| {
- this.look_ahead(n, |t| t.is_keyword(keywords::SelfLower)) &&
+ this.look_ahead(n, |t| t.is_keyword(kw::SelfLower)) &&
this.look_ahead(n + 1, |t| t != &token::ModSep)
};
@@ -6035,7 +6035,7 @@ impl<'a> Parser<'a> {
(if isolated_self(self, 1) {
self.bump();
SelfKind::Region(None, Mutability::Immutable)
- } else if self.look_ahead(1, |t| t.is_keyword(keywords::Mut)) &&
+ } else if self.look_ahead(1, |t| t.is_keyword(kw::Mut)) &&
isolated_self(self, 2) {
self.bump();
self.bump();
@@ -6046,7 +6046,7 @@ impl<'a> Parser<'a> {
let lt = self.expect_lifetime();
SelfKind::Region(Some(lt), Mutability::Immutable)
} else if self.look_ahead(1, |t| t.is_lifetime()) &&
- self.look_ahead(2, |t| t.is_keyword(keywords::Mut)) &&
+ self.look_ahead(2, |t| t.is_keyword(kw::Mut)) &&
isolated_self(self, 3) {
self.bump();
let lt = self.expect_lifetime();
@@ -6093,7 +6093,7 @@ impl<'a> Parser<'a> {
} else {
SelfKind::Value(Mutability::Immutable)
}, eself_ident, eself_hi)
- } else if self.token.is_keyword(keywords::Mut) &&
+ } else if self.token.is_keyword(kw::Mut) &&
isolated_self(self, 1) {
// mut self
// mut self: TYPE
@@ -6224,9 +6224,9 @@ impl<'a> Parser<'a> {
/// Returns `true` if we are looking at `const ID`
/// (returns `false` for things like `const fn`, etc.).
fn is_const_item(&self) -> bool {
- self.token.is_keyword(keywords::Const) &&
- !self.look_ahead(1, |t| t.is_keyword(keywords::Fn)) &&
- !self.look_ahead(1, |t| t.is_keyword(keywords::Unsafe))
+ self.token.is_keyword(kw::Const) &&
+ !self.look_ahead(1, |t| t.is_keyword(kw::Fn)) &&
+ !self.look_ahead(1, |t| t.is_keyword(kw::Unsafe))
}
/// Parses all the "front matter" for a `fn` declaration, up to
@@ -6245,7 +6245,7 @@ impl<'a> Parser<'a> {
Abi
)>
{
- let is_const_fn = self.eat_keyword(keywords::Const);
+ let is_const_fn = self.eat_keyword(kw::Const);
let const_span = self.prev_span;
let unsafety = self.parse_unsafety();
let asyncness = self.parse_asyncness();
@@ -6253,14 +6253,14 @@ impl<'a> Parser<'a> {
let (constness, unsafety, abi) = if is_const_fn {
(respan(const_span, Constness::Const), unsafety, Abi::Rust)
} else {
- let abi = if self.eat_keyword(keywords::Extern) {
+ let abi = if self.eat_keyword(kw::Extern) {
self.parse_opt_abi()?.unwrap_or(Abi::C)
} else {
Abi::Rust
};
(respan(self.prev_span, Constness::NotConst), unsafety, abi)
};
- if !self.eat_keyword(keywords::Fn) {
+ if !self.eat_keyword(kw::Fn) {
// It is possible for `expect_one_of` to recover given the contents of
// `self.expected_tokens`, therefore, do not use `self.unexpected()` which doesn't
// account for this.
@@ -6304,7 +6304,7 @@ impl<'a> Parser<'a> {
} else if self.is_const_item() {
// This parses the grammar:
// ImplItemConst = "const" Ident ":" Ty "=" Expr ";"
- self.expect_keyword(keywords::Const)?;
+ self.expect_keyword(kw::Const)?;
let name = self.parse_ident()?;
self.expect(&token::Colon)?;
let typ = self.parse_ty()?;
@@ -6394,7 +6394,7 @@ impl<'a> Parser<'a> {
// code copied from parse_macro_use_or_failure... abstraction!
if let Some(mac) = self.parse_assoc_macro_invoc("impl", Some(vis), at_end)? {
// method macro
- Ok((keywords::Invalid.ident(), vec![], ast::Generics::default(),
+ Ok((Ident::invalid(), vec![], ast::Generics::default(),
ast::ImplItemKind::Macro(mac)))
} else {
let (constness, unsafety, mut asyncness, abi) = self.parse_fn_front_matter()?;
@@ -6502,7 +6502,7 @@ impl<'a> Parser<'a> {
self.look_ahead(1, |t| t.is_lifetime() || t.is_ident()) &&
self.look_ahead(2, |t| t == &token::Gt || t == &token::Comma ||
t == &token::Colon || t == &token::Eq) ||
- self.look_ahead(1, |t| t.is_keyword(keywords::Const)))
+ self.look_ahead(1, |t| t.is_keyword(kw::Const)))
}
fn parse_impl_body(&mut self) -> PResult<'a, (Vec<ImplItem>, Vec<Attribute>)> {
@@ -6552,8 +6552,8 @@ impl<'a> Parser<'a> {
};
// Parse both types and traits as a type, then reinterpret if necessary.
- let err_path = |span| ast::Path::from_ident(Ident::new(keywords::Invalid.name(), span));
- let ty_first = if self.token.is_keyword(keywords::For) &&
+ let err_path = |span| ast::Path::from_ident(Ident::new(kw::Invalid, span));
+ let ty_first = if self.token.is_keyword(kw::For) &&
self.look_ahead(1, |t| t != &token::Lt) {
let span = self.prev_span.between(self.span);
self.struct_span_err(span, "missing trait in a trait impl").emit();
@@ -6563,7 +6563,7 @@ impl<'a> Parser<'a> {
};
// If `for` is missing we try to recover.
- let has_for = self.eat_keyword(keywords::For);
+ let has_for = self.eat_keyword(kw::For);
let missing_for_span = self.prev_span.between(self.span);
let ty_second = if self.token == token::DotDot {
@@ -6614,11 +6614,11 @@ impl<'a> Parser<'a> {
}
};
- Ok((keywords::Invalid.ident(), item_kind, Some(attrs)))
+ Ok((Ident::invalid(), item_kind, Some(attrs)))
}
fn parse_late_bound_lifetime_defs(&mut self) -> PResult<'a, Vec<GenericParam>> {
- if self.eat_keyword(keywords::For) {
+ if self.eat_keyword(kw::For) {
self.expect_lt()?;
let params = self.parse_generic_params()?;
self.expect_gt()?;
@@ -6650,7 +6650,7 @@ impl<'a> Parser<'a> {
// Otherwise if we look ahead and see a paren we parse a tuple-style
// struct.
- let vdata = if self.token.is_keyword(keywords::Where) {
+ let vdata = if self.token.is_keyword(kw::Where) {
generics.where_clause = self.parse_where_clause()?;
if self.eat(&token::Semi) {
// If we see a: `struct Foo<T> where T: Copy;` style decl.
@@ -6692,7 +6692,7 @@ impl<'a> Parser<'a> {
let mut generics = self.parse_generics()?;
- let vdata = if self.token.is_keyword(keywords::Where) {
+ let vdata = if self.token.is_keyword(kw::Where) {
generics.where_clause = self.parse_where_clause()?;
let (fields, recovered) = self.parse_record_struct_body()?;
VariantData::Struct(fields, recovered)
@@ -6844,13 +6844,13 @@ impl<'a> Parser<'a> {
pub fn parse_visibility(&mut self, can_take_tuple: bool) -> PResult<'a, Visibility> {
maybe_whole!(self, NtVis, |x| x);
- self.expected_tokens.push(TokenType::Keyword(keywords::Crate));
+ self.expected_tokens.push(TokenType::Keyword(kw::Crate));
if self.is_crate_vis() {
self.bump(); // `crate`
return Ok(respan(self.prev_span, VisibilityKind::Crate(CrateSugar::JustCrate)));
}
- if !self.eat_keyword(keywords::Pub) {
+ if !self.eat_keyword(kw::Pub) {
// We need a span for our `Spanned<VisibilityKind>`, but there's inherently no
// keyword to grab a span from for inherited visibility; an empty span at the
// beginning of the current token would seem to be the "Schelling span".
@@ -6863,7 +6863,7 @@ impl<'a> Parser<'a> {
// `()` or a tuple might be allowed. For example, `struct Struct(pub (), pub (usize));`.
// Because of this, we only `bump` the `(` if we're assured it is appropriate to do so
// by the following tokens.
- if self.look_ahead(1, |t| t.is_keyword(keywords::Crate)) &&
+ if self.look_ahead(1, |t| t.is_keyword(kw::Crate)) &&
self.look_ahead(2, |t| t != &token::ModSep) // account for `pub(crate::foo)`
{
// `pub(crate)`
@@ -6875,7 +6875,7 @@ impl<'a> Parser<'a> {
VisibilityKind::Crate(CrateSugar::PubCrate),
);
return Ok(vis)
- } else if self.look_ahead(1, |t| t.is_keyword(keywords::In)) {
+ } else if self.look_ahead(1, |t| t.is_keyword(kw::In)) {
// `pub(in path)`
self.bump(); // `(`
self.bump(); // `in`
@@ -6887,8 +6887,8 @@ impl<'a> Parser<'a> {
});
return Ok(vis)
} else if self.look_ahead(2, |t| t == &token::CloseDelim(token::Paren)) &&
- self.look_ahead(1, |t| t.is_keyword(keywords::Super) ||
- t.is_keyword(keywords::SelfLower))
+ self.look_ahead(1, |t| t.is_keyword(kw::Super) ||
+ t.is_keyword(kw::SelfLower))
{
// `pub(self)` or `pub(super)`
self.bump(); // `(`
@@ -6926,14 +6926,14 @@ impl<'a> Parser<'a> {
/// Parses defaultness (i.e., `default` or nothing).
fn parse_defaultness(&mut self) -> Defaultness {
// `pub` is included for better error messages
- if self.check_keyword(keywords::Default) &&
- self.look_ahead(1, |t| t.is_keyword(keywords::Impl) ||
- t.is_keyword(keywords::Const) ||
- t.is_keyword(keywords::Fn) ||
- t.is_keyword(keywords::Unsafe) ||
- t.is_keyword(keywords::Extern) ||
- t.is_keyword(keywords::Type) ||
- t.is_keyword(keywords::Pub)) {
+ if self.check_keyword(kw::Default) &&
+ self.look_ahead(1, |t| t.is_keyword(kw::Impl) ||
+ t.is_keyword(kw::Const) ||
+ t.is_keyword(kw::Fn) ||
+ t.is_keyword(kw::Unsafe) ||
+ t.is_keyword(kw::Extern) ||
+ t.is_keyword(kw::Type) ||
+ t.is_keyword(kw::Pub)) {
self.bump(); // `default`
Defaultness::Default
} else {
@@ -7257,7 +7257,7 @@ impl<'a> Parser<'a> {
/// Parses a function declaration from a foreign module.
fn parse_item_foreign_fn(&mut self, vis: ast::Visibility, lo: Span, attrs: Vec<Attribute>)
-> PResult<'a, ForeignItem> {
- self.expect_keyword(keywords::Fn)?;
+ self.expect_keyword(kw::Fn)?;
let (ident, mut generics) = self.parse_fn_header()?;
let decl = self.parse_fn_decl(true)?;
@@ -7297,7 +7297,7 @@ impl<'a> Parser<'a> {
/// Parses a type from a foreign module.
fn parse_item_foreign_type(&mut self, vis: ast::Visibility, lo: Span, attrs: Vec<Attribute>)
-> PResult<'a, ForeignItem> {
- self.expect_keyword(keywords::Type)?;
+ self.expect_keyword(kw::Type)?;
let ident = self.parse_ident()?;
let hi = self.span;
@@ -7316,7 +7316,7 @@ impl<'a> Parser<'a> {
let error_msg = "crate name using dashes are not valid in `extern crate` statements";
let suggestion_msg = "if the original crate name uses dashes you need to use underscores \
in the code";
- let mut ident = if self.token.is_keyword(keywords::SelfLower) {
+ let mut ident = if self.token.is_keyword(kw::SelfLower) {
self.parse_path_segment_ident()
} else {
self.parse_ident()
@@ -7412,7 +7412,7 @@ impl<'a> Parser<'a> {
abi,
items: foreign_items
};
- let invalid = keywords::Invalid.ident();
+ let invalid = Ident::invalid();
Ok(self.mk_item(lo.to(prev_span), invalid, ItemKind::ForeignMod(m), visibility, attrs))
}
@@ -7425,11 +7425,11 @@ impl<'a> Parser<'a> {
fn eat_type(&mut self) -> Option<PResult<'a, (Ident, AliasKind, ast::Generics)>> {
// This parses the grammar:
// Ident ["<"...">"] ["where" ...] ("=" | ":") Ty ";"
- if self.check_keyword(keywords::Type) ||
- self.check_keyword(keywords::Existential) &&
- self.look_ahead(1, |t| t.is_keyword(keywords::Type)) {
- let existential = self.eat_keyword(keywords::Existential);
- assert!(self.eat_keyword(keywords::Type));
+ if self.check_keyword(kw::Type) ||
+ self.check_keyword(kw::Existential) &&
+ self.look_ahead(1, |t| t.is_keyword(kw::Type)) {
+ let existential = self.eat_keyword(kw::Existential);
+ assert!(self.eat_keyword(kw::Type));
Some(self.parse_existential_or_alias(existential))
} else {
None
@@ -7580,10 +7580,10 @@ impl<'a> Parser<'a> {
}
fn is_static_global(&mut self) -> bool {
- if self.check_keyword(keywords::Static) {
+ if self.check_keyword(kw::Static) {
// Check if this could be a closure
!self.look_ahead(1, |token| {
- if token.is_keyword(keywords::Move) {
+ if token.is_keyword(kw::Move) {
return true;
}
match *token {
@@ -7653,24 +7653,25 @@ impl<'a> Parser<'a> {
let visibility = self.parse_visibility(false)?;
- if self.eat_keyword(keywords::Use) {
+ if self.eat_keyword(kw::Use) {
// USE ITEM
let item_ = ItemKind::Use(P(self.parse_use_tree()?));
self.expect(&token::Semi)?;
let span = lo.to(self.prev_span);
- let item = self.mk_item(span, keywords::Invalid.ident(), item_, visibility, attrs);
+ let item =
+ self.mk_item(span, Ident::invalid(), item_, visibility, attrs);
return Ok(Some(item));
}
- if self.eat_keyword(keywords::Extern) {
- if self.eat_keyword(keywords::Crate) {
+ if self.eat_keyword(kw::Extern) {
+ if self.eat_keyword(kw::Crate) {
return Ok(Some(self.parse_item_extern_crate(lo, visibility, attrs)?));
}
let opt_abi = self.parse_opt_abi()?;
- if self.eat_keyword(keywords::Fn) {
+ if self.eat_keyword(kw::Fn) {
// EXTERN FUNCTION ITEM
let fn_span = self.prev_span;
let abi = opt_abi.unwrap_or(Abi::C);
@@ -7696,7 +7697,7 @@ impl<'a> Parser<'a> {
if self.is_static_global() {
self.bump();
// STATIC ITEM
- let m = if self.eat_keyword(keywords::Mut) {
+ let m = if self.eat_keyword(kw::Mut) {
Mutability::Mutable
} else {
Mutability::Immutable
@@ -7710,11 +7711,11 @@ impl<'a> Parser<'a> {
maybe_append(attrs, extra_attrs));
return Ok(Some(item));
}
- if self.eat_keyword(keywords::Const) {
+ if self.eat_keyword(kw::Const) {
let const_span = self.prev_span;
- if self.check_keyword(keywords::Fn)
- || (self.check_keyword(keywords::Unsafe)
- && self.look_ahead(1, |t| t.is_keyword(keywords::Fn))) {
+ if self.check_keyword(kw::Fn)
+ || (self.check_keyword(kw::Unsafe)
+ && self.look_ahead(1, |t| t.is_keyword(kw::Fn))) {
// CONST FUNCTION ITEM
let unsafety = self.parse_unsafety();
self.bump();
@@ -7733,7 +7734,7 @@ impl<'a> Parser<'a> {
}
// CONST ITEM
- if self.eat_keyword(keywords::Mut) {
+ if self.eat_keyword(kw::Mut) {
let prev_span = self.prev_span;
let mut err = self.diagnostic()
.struct_span_err(prev_span, "const globals cannot be mutable");
@@ -7758,18 +7759,18 @@ impl<'a> Parser<'a> {
// `unsafe async fn` or `async fn`
if (
- self.check_keyword(keywords::Unsafe) &&
- self.look_ahead(1, |t| t.is_keyword(keywords::Async))
+ self.check_keyword(kw::Unsafe) &&
+ self.look_ahead(1, |t| t.is_keyword(kw::Async))
) || (
- self.check_keyword(keywords::Async) &&
- self.look_ahead(1, |t| t.is_keyword(keywords::Fn))
+ self.check_keyword(kw::Async) &&
+ self.look_ahead(1, |t| t.is_keyword(kw::Fn))
)
{
// ASYNC FUNCTION ITEM
let unsafety = self.parse_unsafety();
- self.expect_keyword(keywords::Async)?;
+ self.expect_keyword(kw::Async)?;
let async_span = self.prev_span;
- self.expect_keyword(keywords::Fn)?;
+ self.expect_keyword(kw::Fn)?;
let fn_span = self.prev_span;
let (ident, item_, extra_attrs) =
self.parse_item_fn(unsafety,
@@ -7795,17 +7796,17 @@ impl<'a> Parser<'a> {
}
return Ok(Some(item));
}
- if self.check_keyword(keywords::Unsafe) &&
- (self.look_ahead(1, |t| t.is_keyword(keywords::Trait)) ||
- self.look_ahead(1, |t| t.is_keyword(keywords::Auto)))
+ if self.check_keyword(kw::Unsafe) &&
+ (self.look_ahead(1, |t| t.is_keyword(kw::Trait)) ||
+ self.look_ahead(1, |t| t.is_keyword(kw::Auto)))
{
// UNSAFE TRAIT ITEM
self.bump(); // `unsafe`
- let is_auto = if self.eat_keyword(keywords::Trait) {
+ let is_auto = if self.eat_keyword(kw::Trait) {
IsAuto::No
} else {
- self.expect_keyword(keywords::Auto)?;
- self.expect_keyword(keywords::Trait)?;
+ self.expect_keyword(kw::Auto)?;
+ self.expect_keyword(kw::Trait)?;
IsAuto::Yes
};
let (ident, item_, extra_attrs) =
@@ -7818,23 +7819,23 @@ impl<'a> Parser<'a> {
maybe_append(attrs, extra_attrs));
return Ok(Some(item));
}
- if self.check_keyword(keywords::Impl) ||
- self.check_keyword(keywords::Unsafe) &&
- self.look_ahead(1, |t| t.is_keyword(keywords::Impl)) ||
- self.check_keyword(keywords::Default) &&
- self.look_ahead(1, |t| t.is_keyword(keywords::Impl)) ||
- self.check_keyword(keywords::Default) &&
- self.look_ahead(1, |t| t.is_keyword(keywords::Unsafe)) {
+ if self.check_keyword(kw::Impl) ||
+ self.check_keyword(kw::Unsafe) &&
+ self.look_ahead(1, |t| t.is_keyword(kw::Impl)) ||
+ self.check_keyword(kw::Default) &&
+ self.look_ahead(1, |t| t.is_keyword(kw::Impl)) ||
+ self.check_keyword(kw::Default) &&
+ self.look_ahead(1, |t| t.is_keyword(kw::Unsafe)) {
// IMPL ITEM
let defaultness = self.parse_defaultness();
let unsafety = self.parse_unsafety();
- self.expect_keyword(keywords::Impl)?;
+ self.expect_keyword(kw::Impl)?;
let (ident, item, extra_attrs) = self.parse_item_impl(unsafety, defaultness)?;
let span = lo.to(self.prev_span);
return Ok(Some(self.mk_item(span, ident, item, visibility,
maybe_append(attrs, extra_attrs))));
}
- if self.check_keyword(keywords::Fn) {
+ if self.check_keyword(kw::Fn) {
// FUNCTION ITEM
self.bump();
let fn_span = self.prev_span;
@@ -7851,18 +7852,18 @@ impl<'a> Parser<'a> {
maybe_append(attrs, extra_attrs));
return Ok(Some(item));
}
- if self.check_keyword(keywords::Unsafe)
+ if self.check_keyword(kw::Unsafe)
&& self.look_ahead(1, |t| *t != token::OpenDelim(token::Brace)) {
// UNSAFE FUNCTION ITEM
self.bump(); // `unsafe`
// `{` is also expected after `unsafe`, in case of error, include it in the diagnostic
self.check(&token::OpenDelim(token::Brace));
- let abi = if self.eat_keyword(keywords::Extern) {
+ let abi = if self.eat_keyword(kw::Extern) {
self.parse_opt_abi()?.unwrap_or(Abi::C)
} else {
Abi::Rust
};
- self.expect_keyword(keywords::Fn)?;
+ self.expect_keyword(kw::Fn)?;
let fn_span = self.prev_span;
let (ident, item_, extra_attrs) =
self.parse_item_fn(Unsafety::Unsafe,
@@ -7877,7 +7878,7 @@ impl<'a> Parser<'a> {
maybe_append(attrs, extra_attrs));
return Ok(Some(item));
}
- if self.eat_keyword(keywords::Mod) {
+ if self.eat_keyword(kw::Mod) {
// MODULE ITEM
let (ident, item_, extra_attrs) =
self.parse_item_mod(&attrs[..])?;
@@ -7904,7 +7905,7 @@ impl<'a> Parser<'a> {
attrs);
return Ok(Some(item));
}
- if self.eat_keyword(keywords::Enum) {
+ if self.eat_keyword(kw::Enum) {
// ENUM ITEM
let (ident, item_, extra_attrs) = self.parse_item_enum()?;
let prev_span = self.prev_span;
@@ -7915,15 +7916,15 @@ impl<'a> Parser<'a> {
maybe_append(attrs, extra_attrs));
return Ok(Some(item));
}
- if self.check_keyword(keywords::Trait)
- || (self.check_keyword(keywords::Auto)
- && self.look_ahead(1, |t| t.is_keyword(keywords::Trait)))
+ if self.check_keyword(kw::Trait)
+ || (self.check_keyword(kw::Auto)
+ && self.look_ahead(1, |t| t.is_keyword(kw::Trait)))
{
- let is_auto = if self.eat_keyword(keywords::Trait) {
+ let is_auto = if self.eat_keyword(kw::Trait) {
IsAuto::No
} else {
- self.expect_keyword(keywords::Auto)?;
- self.expect_keyword(keywords::Trait)?;
+ self.expect_keyword(kw::Auto)?;
+ self.expect_keyword(kw::Trait)?;
IsAuto::Yes
};
// TRAIT ITEM
@@ -7937,7 +7938,7 @@ impl<'a> Parser<'a> {
maybe_append(attrs, extra_attrs));
return Ok(Some(item));
}
- if self.eat_keyword(keywords::Struct) {
+ if self.eat_keyword(kw::Struct) {
// STRUCT ITEM
let (ident, item_, extra_attrs) = self.parse_item_struct()?;
let prev_span = self.prev_span;
@@ -8078,8 +8079,8 @@ impl<'a> Parser<'a> {
// FOREIGN STATIC ITEM
// Treat `const` as `static` for error recovery, but don't add it to expected tokens.
- if self.check_keyword(keywords::Static) || self.token.is_keyword(keywords::Const) {
- if self.token.is_keyword(keywords::Const) {
+ if self.check_keyword(kw::Static) || self.token.is_keyword(kw::Const) {
+ if self.token.is_keyword(kw::Const) {
self.diagnostic()
.struct_span_err(self.span, "extern items cannot be `const`")
.span_suggestion(
@@ -8093,11 +8094,11 @@ impl<'a> Parser<'a> {
return Ok(self.parse_item_foreign_static(visibility, lo, attrs)?);
}
// FOREIGN FUNCTION ITEM
- if self.check_keyword(keywords::Fn) {
+ if self.check_keyword(kw::Fn) {
return Ok(self.parse_item_foreign_fn(visibility, lo, attrs)?);
}
// FOREIGN TYPE ITEM
- if self.check_keyword(keywords::Type) {
+ if self.check_keyword(kw::Type) {
return Ok(self.parse_item_foreign_type(visibility, lo, attrs)?);
}
@@ -8105,7 +8106,7 @@ impl<'a> Parser<'a> {
Some(mac) => {
Ok(
ForeignItem {
- ident: keywords::Invalid.ident(),
+ ident: Ident::invalid(),
span: lo.to(self.prev_span),
id: ast::DUMMY_NODE_ID,
attrs,
@@ -8152,7 +8153,7 @@ impl<'a> Parser<'a> {
let id = if self.token.is_ident() {
self.parse_ident()?
} else {
- keywords::Invalid.ident() // no special identifier
+ Ident::invalid() // no special identifier
};
// eat a matched-delimiter token tree:
let (delim, tts) = self.expect_delimited_token_tree()?;
@@ -8345,7 +8346,7 @@ impl<'a> Parser<'a> {
}
fn parse_rename(&mut self) -> PResult<'a, Option<Ident>> {
- if self.eat_keyword(keywords::As) {
+ if self.eat_keyword(kw::As) {
self.parse_ident_or_underscore().map(Some)
} else {
Ok(None)
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index 068fc41c87a0b..663eace6b6289 100644
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -8,7 +8,7 @@ use crate::ast::{self};
use crate::parse::ParseSess;
use crate::print::pprust;
use crate::ptr::P;
-use crate::symbol::keywords;
+use crate::symbol::kw;
use crate::syntax::parse::parse_stream_from_source_str;
use crate::tokenstream::{self, DelimSpan, TokenStream, TokenTree};
@@ -110,28 +110,28 @@ pub(crate) fn ident_can_begin_expr(ident: ast::Ident, is_raw: bool) -> bool {
!ident_token.is_reserved_ident() ||
ident_token.is_path_segment_keyword() ||
[
- keywords::Async.name(),
+ kw::Async,
// FIXME: remove when `await!(..)` syntax is removed
// https://github.com/rust-lang/rust/issues/60610
- keywords::Await.name(),
-
- keywords::Do.name(),
- keywords::Box.name(),
- keywords::Break.name(),
- keywords::Continue.name(),
- keywords::False.name(),
- keywords::For.name(),
- keywords::If.name(),
- keywords::Loop.name(),
- keywords::Match.name(),
- keywords::Move.name(),
- keywords::Return.name(),
- keywords::True.name(),
- keywords::Unsafe.name(),
- keywords::While.name(),
- keywords::Yield.name(),
- keywords::Static.name(),
+ kw::Await,
+
+ kw::Do,
+ kw::Box,
+ kw::Break,
+ kw::Continue,
+ kw::False,
+ kw::For,
+ kw::If,
+ kw::Loop,
+ kw::Match,
+ kw::Move,
+ kw::Return,
+ kw::True,
+ kw::Unsafe,
+ kw::While,
+ kw::Yield,
+ kw::Static,
].contains(&ident.name)
}
@@ -141,14 +141,14 @@ fn ident_can_begin_type(ident: ast::Ident, is_raw: bool) -> bool {
!ident_token.is_reserved_ident() ||
ident_token.is_path_segment_keyword() ||
[
- keywords::Underscore.name(),
- keywords::For.name(),
- keywords::Impl.name(),
- keywords::Fn.name(),
- keywords::Unsafe.name(),
- keywords::Extern.name(),
- keywords::Typeof.name(),
- keywords::Dyn.name(),
+ kw::Underscore,
+ kw::For,
+ kw::Impl,
+ kw::Fn,
+ kw::Unsafe,
+ kw::Extern,
+ kw::Typeof,
+ kw::Dyn,
].contains(&ident.name)
}
@@ -306,7 +306,7 @@ impl Token {
/// Returns `true` if the token can appear at the start of a generic bound.
crate fn can_begin_bound(&self) -> bool {
- self.is_path_start() || self.is_lifetime() || self.is_keyword(keywords::For) ||
+ self.is_path_start() || self.is_lifetime() || self.is_keyword(kw::For) ||
self == &Question || self == &OpenDelim(Paren)
}
@@ -324,8 +324,8 @@ impl Token {
match *self {
Literal(..) => true,
BinOp(Minus) => true,
- Ident(ident, false) if ident.name == keywords::True.name() => true,
- Ident(ident, false) if ident.name == keywords::False.name() => true,
+ Ident(ident, false) if ident.name == kw::True => true,
+ Ident(ident, false) if ident.name == kw::False => true,
Interpolated(ref nt) => match **nt {
NtLiteral(..) => true,
_ => false,
@@ -386,8 +386,8 @@ impl Token {
/// Returns `true` if the token is either the `mut` or `const` keyword.
crate fn is_mutability(&self) -> bool {
- self.is_keyword(keywords::Mut) ||
- self.is_keyword(keywords::Const)
+ self.is_keyword(kw::Mut) ||
+ self.is_keyword(kw::Const)
}
crate fn is_qpath_start(&self) -> bool {
@@ -400,8 +400,8 @@ impl Token {
}
/// Returns `true` if the token is a given keyword, `kw`.
- pub fn is_keyword(&self, kw: keywords::Keyword) -> bool {
- self.ident().map(|(ident, is_raw)| ident.name == kw.name() && !is_raw).unwrap_or(false)
+ pub fn is_keyword(&self, kw: Symbol) -> bool {
+ self.ident().map(|(ident, is_raw)| ident.name == kw && !is_raw).unwrap_or(false)
}
pub fn is_path_segment_keyword(&self) -> bool {
@@ -566,8 +566,8 @@ impl Token {
(&Lifetime(a), &Lifetime(b)) => a.name == b.name,
(&Ident(a, b), &Ident(c, d)) => b == d && (a.name == c.name ||
- a.name == keywords::DollarCrate.name() ||
- c.name == keywords::DollarCrate.name()),
+ a.name == kw::DollarCrate ||
+ c.name == kw::DollarCrate),
(&Literal(ref a, b), &Literal(ref c, d)) => {
b == d && a.probably_equal_for_proc_macro(c)
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index ac240359b56b6..2e072522d24a4 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -13,7 +13,7 @@ use crate::print::pp::{self, Breaks};
use crate::print::pp::Breaks::{Consistent, Inconsistent};
use crate::ptr::P;
use crate::std_inject;
-use crate::symbol::{keywords, sym};
+use crate::symbol::{kw, sym};
use crate::tokenstream::{self, TokenStream, TokenTree};
use rustc_target::spec::abi::{self, Abi};
@@ -641,8 +641,8 @@ pub trait PrintState<'a> {
if i > 0 {
self.writer().word("::")?
}
- if segment.ident.name != keywords::PathRoot.name() {
- if segment.ident.name == keywords::DollarCrate.name() {
+ if segment.ident.name != kw::PathRoot {
+ if segment.ident.name == kw::DollarCrate {
self.print_dollar_crate(segment.ident)?;
} else {
self.writer().word(segment.ident.as_str().to_string())?;
@@ -1340,7 +1340,7 @@ impl<'a> State<'a> {
self.s.word(";")?;
}
ast::ItemKind::Mac(ref mac) => {
- if item.ident.name == keywords::Invalid.name() {
+ if item.ident.name == kw::Invalid {
self.print_mac(mac)?;
match mac.node.delim {
MacDelimiter::Brace => {}
@@ -2400,8 +2400,8 @@ impl<'a> State<'a> {
colons_before_params: bool)
-> io::Result<()>
{
- if segment.ident.name != keywords::PathRoot.name() {
- if segment.ident.name == keywords::DollarCrate.name() {
+ if segment.ident.name != kw::PathRoot {
+ if segment.ident.name == kw::DollarCrate {
self.print_dollar_crate(segment.ident)?;
} else {
self.print_ident(segment.ident)?;
@@ -2984,7 +2984,7 @@ impl<'a> State<'a> {
self.print_explicit_self(&eself)?;
} else {
let invalid = if let PatKind::Ident(_, ident, _) = input.pat.node {
- ident.name == keywords::Invalid.name()
+ ident.name == kw::Invalid
} else {
false
};
diff --git a/src/libsyntax/std_inject.rs b/src/libsyntax/std_inject.rs
index e01a3260d4993..398705857bb7e 100644
--- a/src/libsyntax/std_inject.rs
+++ b/src/libsyntax/std_inject.rs
@@ -2,7 +2,7 @@ use crate::ast;
use crate::attr;
use crate::edition::Edition;
use crate::ext::hygiene::{Mark, SyntaxContext};
-use crate::symbol::{Ident, Symbol, keywords, sym};
+use crate::symbol::{Ident, Symbol, kw, sym};
use crate::source_map::{ExpnInfo, MacroAttribute, dummy_spanned, respan};
use crate::ptr::P;
use crate::tokenstream::TokenStream;
@@ -107,7 +107,7 @@ pub fn maybe_inject_crates_ref(
vis: respan(span.shrink_to_lo(), ast::VisibilityKind::Inherited),
node: ast::ItemKind::Use(P(ast::UseTree {
prefix: ast::Path {
- segments: iter::once(keywords::PathRoot.ident())
+ segments: iter::once(ast::Ident::with_empty_ctxt(kw::PathRoot))
.chain(
[name, "prelude", "v1"].iter().cloned()
.map(ast::Ident::from_str)
@@ -118,7 +118,7 @@ pub fn maybe_inject_crates_ref(
span,
})),
id: ast::DUMMY_NODE_ID,
- ident: keywords::Invalid.ident(),
+ ident: ast::Ident::invalid(),
span,
tokens: None,
}));
diff --git a/src/libsyntax/test.rs b/src/libsyntax/test.rs
index 7cd83f3e495be..d1e11da4e7cc2 100644
--- a/src/libsyntax/test.rs
+++ b/src/libsyntax/test.rs
@@ -29,7 +29,7 @@ use crate::parse::{token, ParseSess};
use crate::print::pprust;
use crate::ast::{self, Ident};
use crate::ptr::P;
-use crate::symbol::{self, Symbol, keywords, sym};
+use crate::symbol::{self, Symbol, kw, sym};
use crate::ThinVec;
struct Test {
@@ -100,7 +100,7 @@ impl<'a> MutVisitor for TestHarnessGenerator<'a> {
fn flat_map_item(&mut self, i: P<ast::Item>) -> SmallVec<[P<ast::Item>; 1]> {
let ident = i.ident;
- if ident.name != keywords::Invalid.name() {
+ if ident.name != kw::Invalid {
self.cx.path.push(ident);
}
debug!("current path: {}", path_name_i(&self.cx.path));
@@ -139,7 +139,7 @@ impl<'a> MutVisitor for TestHarnessGenerator<'a> {
}
item.node = ast::ItemKind::Mod(module);
}
- if ident.name != keywords::Invalid.name() {
+ if ident.name != kw::Invalid {
self.cx.path.pop();
}
smallvec![P(item)]
@@ -215,7 +215,7 @@ fn mk_reexport_mod(cx: &mut TestCtxt<'_>,
tests: Vec<Ident>,
tested_submods: Vec<(Ident, Ident)>)
-> (P<ast::Item>, Ident) {
- let super_ = Ident::with_empty_ctxt(keywords::Super.name());
+ let super_ = Ident::with_empty_ctxt(kw::Super);
let items = tests.into_iter().map(|r| {
cx.ext_cx.item_use_simple(DUMMY_SP, dummy_spanned(ast::VisibilityKind::Public),
diff --git a/src/libsyntax/util/parser.rs b/src/libsyntax/util/parser.rs
index 86e89945afe06..6789fea28cad6 100644
--- a/src/libsyntax/util/parser.rs
+++ b/src/libsyntax/util/parser.rs
@@ -1,5 +1,5 @@
use crate::parse::token::{Token, BinOpToken};
-use crate::symbol::keywords;
+use crate::symbol::kw;
use crate::ast::{self, BinOpKind};
/// Associative operator with precedence.
@@ -100,7 +100,7 @@ impl AssocOp {
// DotDotDot is no longer supported, but we need some way to display the error
Token::DotDotDot => Some(DotDotEq),
Token::Colon => Some(Colon),
- _ if t.is_keyword(keywords::As) => Some(As),
+ _ if t.is_keyword(kw::As) => Some(As),
_ => None
}
}
diff --git a/src/libsyntax_ext/deriving/clone.rs b/src/libsyntax_ext/deriving/clone.rs
index 1b0d572324a79..a39e0a6e97303 100644
--- a/src/libsyntax_ext/deriving/clone.rs
+++ b/src/libsyntax_ext/deriving/clone.rs
@@ -7,7 +7,7 @@ use syntax::attr;
use syntax::ext::base::{Annotatable, ExtCtxt};
use syntax::ext::build::AstBuilder;
use syntax::ptr::P;
-use syntax::symbol::{Symbol, keywords, sym};
+use syntax::symbol::{Symbol, kw, sym};
use syntax_pos::Span;
pub fn expand_deriving_clone(cx: &mut ExtCtxt<'_>,
@@ -129,7 +129,8 @@ fn cs_clone_shallow(name: &str,
let mut stmts = Vec::new();
if is_union {
// let _: AssertParamIsCopy<Self>;
- let self_ty = cx.ty_path(cx.path_ident(trait_span, keywords::SelfUpper.ident()));
+ let self_ty =
+ cx.ty_path(cx.path_ident(trait_span, ast::Ident::with_empty_ctxt(kw::SelfUpper)));
assert_ty_bounds(cx, &mut stmts, self_ty, trait_span, "AssertParamIsCopy");
} else {
match *substr.fields {
diff --git a/src/libsyntax_ext/deriving/generic/mod.rs b/src/libsyntax_ext/deriving/generic/mod.rs
index a13dc07085f80..0689eb50f9ca2 100644
--- a/src/libsyntax_ext/deriving/generic/mod.rs
+++ b/src/libsyntax_ext/deriving/generic/mod.rs
@@ -191,7 +191,7 @@ use syntax::ext::build::AstBuilder;
use syntax::source_map::{self, respan};
use syntax::util::map_in_place::MapInPlace;
use syntax::ptr::P;
-use syntax::symbol::{Symbol, keywords, sym};
+use syntax::symbol::{Symbol, kw, sym};
use syntax::parse::ParseSess;
use syntax_pos::{DUMMY_SP, Span};
@@ -686,7 +686,7 @@ impl<'a> TraitDef<'a> {
};
cx.item(self.span,
- keywords::Invalid.ident(),
+ Ident::invalid(),
a,
ast::ItemKind::Impl(unsafety,
ast::ImplPolarity::Positive,
@@ -929,8 +929,8 @@ impl<'a> MethodDef<'a> {
let args = {
let self_args = explicit_self.map(|explicit_self| {
- ast::Arg::from_self(explicit_self,
- keywords::SelfLower.ident().with_span_pos(trait_.span))
+ let ident = Ident::with_empty_ctxt(kw::SelfLower).with_span_pos(trait_.span);
+ ast::Arg::from_self(explicit_self, ident)
});
let nonself_args = arg_types.into_iter()
.map(|(name, ty)| cx.arg(trait_.span, name, ty));
diff --git a/src/libsyntax_ext/deriving/generic/ty.rs b/src/libsyntax_ext/deriving/generic/ty.rs
index 100ec0057ee02..362ea9ed2291f 100644
--- a/src/libsyntax_ext/deriving/generic/ty.rs
+++ b/src/libsyntax_ext/deriving/generic/ty.rs
@@ -10,7 +10,7 @@ use syntax::ext::build::AstBuilder;
use syntax::source_map::{respan, DUMMY_SP};
use syntax::ptr::P;
use syntax_pos::Span;
-use syntax_pos::symbol::keywords;
+use syntax_pos::symbol::kw;
/// The types of pointers
#[derive(Clone)]
@@ -86,7 +86,7 @@ impl<'a> Path<'a> {
PathKind::Local => cx.path_all(span, false, idents, params, Vec::new()),
PathKind::Std => {
let def_site = DUMMY_SP.apply_mark(cx.current_expansion.mark);
- idents.insert(0, Ident::new(keywords::DollarCrate.name(), def_site));
+ idents.insert(0, Ident::new(kw::DollarCrate, def_site));
cx.path_all(span, false, idents, params, Vec::new())
}
}
diff --git a/src/libsyntax_ext/env.rs b/src/libsyntax_ext/env.rs
index 2127179eecb5a..72a66ae3845d0 100644
--- a/src/libsyntax_ext/env.rs
+++ b/src/libsyntax_ext/env.rs
@@ -6,7 +6,7 @@
use syntax::ast::{self, Ident, GenericArg};
use syntax::ext::base::{self, *};
use syntax::ext::build::AstBuilder;
-use syntax::symbol::{keywords, Symbol, sym};
+use syntax::symbol::{kw, sym, Symbol};
use syntax_pos::Span;
use syntax::tokenstream;
@@ -24,7 +24,7 @@ pub fn expand_option_env<'cx>(cx: &'cx mut ExtCtxt<'_>,
let sp = sp.apply_mark(cx.current_expansion.mark);
let e = match env::var(&*var.as_str()) {
Err(..) => {
- let lt = cx.lifetime(sp, keywords::StaticLifetime.ident());
+ let lt = cx.lifetime(sp, Ident::with_empty_ctxt(kw::StaticLifetime));
cx.expr_path(cx.path_all(sp,
true,
cx.std_path(&["option", "Option", "None"]),
diff --git a/src/libsyntax_ext/global_asm.rs b/src/libsyntax_ext/global_asm.rs
index 3f2853e4b0e20..5220143a3cc46 100644
--- a/src/libsyntax_ext/global_asm.rs
+++ b/src/libsyntax_ext/global_asm.rs
@@ -37,7 +37,7 @@ pub fn expand_global_asm<'cx>(cx: &'cx mut ExtCtxt<'_>,
match parse_global_asm(cx, sp, tts) {
Ok(Some(global_asm)) => {
MacEager::items(smallvec![P(ast::Item {
- ident: ast::Ident::with_empty_ctxt(Symbol::intern("")),
+ ident: ast::Ident::invalid(),
attrs: Vec::new(),
id: ast::DUMMY_NODE_ID,
node: ast::ItemKind::GlobalAsm(P(global_asm)),
diff --git a/src/libsyntax_ext/proc_macro_decls.rs b/src/libsyntax_ext/proc_macro_decls.rs
index a13fe65ca0ddf..a485bb19808db 100644
--- a/src/libsyntax_ext/proc_macro_decls.rs
+++ b/src/libsyntax_ext/proc_macro_decls.rs
@@ -13,7 +13,7 @@ use syntax::mut_visit::MutVisitor;
use syntax::parse::ParseSess;
use syntax::ptr::P;
use syntax::symbol::Symbol;
-use syntax::symbol::{keywords, sym};
+use syntax::symbol::{kw, sym};
use syntax::visit::{self, Visitor};
use syntax_pos::{Span, DUMMY_SP};
@@ -378,7 +378,7 @@ fn mk_decls(
let custom_derive = Ident::from_str("custom_derive");
let attr = Ident::from_str("attr");
let bang = Ident::from_str("bang");
- let crate_kw = Ident::with_empty_ctxt(keywords::Crate.name());
+ let crate_kw = Ident::with_empty_ctxt(kw::Crate);
let decls = {
let local_path = |sp: Span, name| {
diff --git a/src/libsyntax_ext/proc_macro_server.rs b/src/libsyntax_ext/proc_macro_server.rs
index 09dce77579001..69e83f5a84ced 100644
--- a/src/libsyntax_ext/proc_macro_server.rs
+++ b/src/libsyntax_ext/proc_macro_server.rs
@@ -14,7 +14,7 @@ use syntax::parse::lexer::comments;
use syntax::parse::{self, token, ParseSess};
use syntax::tokenstream::{self, DelimSpan, IsJoint::*, TokenStream, TreeAndJoint};
use syntax_pos::hygiene::{SyntaxContext, Transparency};
-use syntax_pos::symbol::{keywords, Symbol};
+use syntax_pos::symbol::{kw, Symbol};
use syntax_pos::{BytePos, FileName, MultiSpan, Pos, SourceFile, Span};
trait FromInternal<T> {
@@ -142,7 +142,7 @@ impl FromInternal<(TreeAndJoint, &'_ ParseSess, &'_ mut Vec<Self>)>
Question => op!('?'),
SingleQuote => op!('\''),
- Ident(ident, false) if ident.name == keywords::DollarCrate.name() =>
+ Ident(ident, false) if ident.name == kw::DollarCrate =>
tt!(Ident::dollar_crate()),
Ident(ident, is_raw) => tt!(Ident::new(ident.name, is_raw)),
Lifetime(ident) => {
@@ -347,7 +347,7 @@ impl Ident {
}
fn dollar_crate(span: Span) -> Ident {
// `$crate` is accepted as an ident only if it comes from the compiler.
- Ident { sym: keywords::DollarCrate.name(), is_raw: false, span }
+ Ident { sym: kw::DollarCrate, is_raw: false, span }
}
}
diff --git a/src/libsyntax_ext/trace_macros.rs b/src/libsyntax_ext/trace_macros.rs
index eca658cb5473e..61ef94560ccb9 100644
--- a/src/libsyntax_ext/trace_macros.rs
+++ b/src/libsyntax_ext/trace_macros.rs
@@ -1,6 +1,6 @@
use syntax::ext::base::{self, ExtCtxt};
use syntax::feature_gate;
-use syntax::symbol::{keywords, sym};
+use syntax::symbol::{kw, sym};
use syntax_pos::Span;
use syntax::tokenstream::TokenTree;
@@ -17,10 +17,10 @@ pub fn expand_trace_macros(cx: &mut ExtCtxt<'_>,
}
match (tt.len(), tt.first()) {
- (1, Some(&TokenTree::Token(_, ref tok))) if tok.is_keyword(keywords::True) => {
+ (1, Some(&TokenTree::Token(_, ref tok))) if tok.is_keyword(kw::True) => {
cx.set_trace_macros(true);
}
- (1, Some(&TokenTree::Token(_, ref tok))) if tok.is_keyword(keywords::False) => {
+ (1, Some(&TokenTree::Token(_, ref tok))) if tok.is_keyword(kw::False) => {
cx.set_trace_macros(false);
}
_ => cx.span_err(sp, "trace_macros! accepts only `true` or `false`"),
diff --git a/src/libsyntax_pos/hygiene.rs b/src/libsyntax_pos/hygiene.rs
index 6e787c08504f3..e8dcd8171c91f 100644
--- a/src/libsyntax_pos/hygiene.rs
+++ b/src/libsyntax_pos/hygiene.rs
@@ -8,7 +8,7 @@
use crate::GLOBALS;
use crate::Span;
use crate::edition::Edition;
-use crate::symbol::{keywords, Symbol};
+use crate::symbol::{kw, Symbol};
use serialize::{Encodable, Decodable, Encoder, Decoder};
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
@@ -192,7 +192,7 @@ impl HygieneData {
prev_ctxt: SyntaxContext(0),
opaque: SyntaxContext(0),
opaque_and_semitransparent: SyntaxContext(0),
- dollar_crate_name: keywords::DollarCrate.name(),
+ dollar_crate_name: kw::DollarCrate,
}],
markings: FxHashMap::default(),
}
@@ -245,7 +245,7 @@ impl SyntaxContext {
prev_ctxt: SyntaxContext::empty(),
opaque: SyntaxContext::empty(),
opaque_and_semitransparent: SyntaxContext::empty(),
- dollar_crate_name: keywords::DollarCrate.name(),
+ dollar_crate_name: kw::DollarCrate,
});
SyntaxContext(data.syntax_contexts.len() as u32 - 1)
})
@@ -312,7 +312,7 @@ impl SyntaxContext {
prev_ctxt,
opaque: new_opaque,
opaque_and_semitransparent: new_opaque,
- dollar_crate_name: keywords::DollarCrate.name(),
+ dollar_crate_name: kw::DollarCrate,
});
new_opaque
});
@@ -330,7 +330,7 @@ impl SyntaxContext {
prev_ctxt,
opaque,
opaque_and_semitransparent: new_opaque_and_semitransparent,
- dollar_crate_name: keywords::DollarCrate.name(),
+ dollar_crate_name: kw::DollarCrate,
});
new_opaque_and_semitransparent
});
@@ -346,7 +346,7 @@ impl SyntaxContext {
prev_ctxt,
opaque,
opaque_and_semitransparent,
- dollar_crate_name: keywords::DollarCrate.name(),
+ dollar_crate_name: kw::DollarCrate,
});
new_opaque_and_semitransparent_and_transparent
})
@@ -512,7 +512,7 @@ impl SyntaxContext {
&mut data.syntax_contexts[self.0 as usize].dollar_crate_name, dollar_crate_name
);
assert!(dollar_crate_name == prev_dollar_crate_name ||
- prev_dollar_crate_name == keywords::DollarCrate.name(),
+ prev_dollar_crate_name == kw::DollarCrate,
"$crate name is reset for a syntax context");
})
}
diff --git a/src/libsyntax_pos/symbol.rs b/src/libsyntax_pos/symbol.rs
index 8b07e81e58637..070bb1d8ef704 100644
--- a/src/libsyntax_pos/symbol.rs
+++ b/src/libsyntax_pos/symbol.rs
@@ -641,6 +641,11 @@ impl Ident {
Ident::new(name, DUMMY_SP)
}
+ #[inline]
+ pub fn invalid() -> Ident {
+ Ident::with_empty_ctxt(kw::Invalid)
+ }
+
/// Maps an interned string to an identifier with an empty syntax context.
pub fn from_interned_str(string: InternedString) -> Ident {
Ident::with_empty_ctxt(string.as_symbol())
@@ -692,7 +697,7 @@ impl Ident {
/// Transforms an underscore identifier into one with the same name, but
/// gensymed. Leaves non-underscore identifiers unchanged.
pub fn gensym_if_underscore(self) -> Ident {
- if self.name == keywords::Underscore.name() { self.gensym() } else { self }
+ if self.name == kw::Underscore { self.gensym() } else { self }
}
// WARNING: this function is deprecated and will be removed in the future.
@@ -864,8 +869,8 @@ impl Interner {
this.strings.reserve(init.len());
// We can't allocate empty strings in the arena, so handle this here.
- assert!(keywords::Invalid.name().as_u32() == 0 && init[0].is_empty());
- this.names.insert("", keywords::Invalid.name());
+ assert!(kw::Invalid.as_u32() == 0 && init[0].is_empty());
+ this.names.insert("", kw::Invalid);
this.strings.push("");
for string in &init[1..] {
@@ -926,26 +931,9 @@ impl Interner {
}
}
-pub mod keywords {
- use super::{Symbol, Ident};
-
- #[derive(Clone, Copy, PartialEq, Eq)]
- pub struct Keyword {
- ident: Ident,
- }
-
- impl Keyword {
- #[inline]
- pub fn ident(self) -> Ident {
- self.ident
- }
-
- #[inline]
- pub fn name(self) -> Symbol {
- self.ident.name
- }
- }
-
+// This module has a very short name because it's used a lot.
+pub mod kw {
+ use super::Symbol;
keywords!();
}
@@ -957,11 +945,16 @@ pub mod sym {
impl Symbol {
fn is_used_keyword_2018(self) -> bool {
- self == keywords::Dyn.name()
+ self == kw::Dyn
}
fn is_unused_keyword_2018(self) -> bool {
- self >= keywords::Async.name() && self <= keywords::Try.name()
+ self >= kw::Async && self <= kw::Try
+ }
+
+ /// Used for sanity checking rustdoc keyword sections.
+ pub fn is_doc_keyword(self) -> bool {
+ self <= kw::Union
}
}
@@ -969,20 +962,20 @@ impl Ident {
// Returns `true` for reserved identifiers used internally for elided lifetimes,
// unnamed method parameters, crate root module, error recovery etc.
pub fn is_special(self) -> bool {
- self.name <= keywords::Underscore.name()
+ self.name <= kw::Underscore
}
/// Returns `true` if the token is a keyword used in the language.
pub fn is_used_keyword(self) -> bool {
// Note: `span.edition()` is relatively expensive, don't call it unless necessary.
- self.name >= keywords::As.name() && self.name <= keywords::While.name() ||
+ self.name >= kw::As && self.name <= kw::While ||
self.name.is_used_keyword_2018() && self.span.rust_2018()
}
/// Returns `true` if the token is a keyword reserved for possible future use.
pub fn is_unused_keyword(self) -> bool {
// Note: `span.edition()` is relatively expensive, don't call it unless necessary.
- self.name >= keywords::Abstract.name() && self.name <= keywords::Yield.name() ||
+ self.name >= kw::Abstract && self.name <= kw::Yield ||
self.name.is_unused_keyword_2018() && self.span.rust_2018()
}
@@ -993,17 +986,17 @@ impl Ident {
/// A keyword or reserved identifier that can be used as a path segment.
pub fn is_path_segment_keyword(self) -> bool {
- self.name == keywords::Super.name() ||
- self.name == keywords::SelfLower.name() ||
- self.name == keywords::SelfUpper.name() ||
- self.name == keywords::Crate.name() ||
- self.name == keywords::PathRoot.name() ||
- self.name == keywords::DollarCrate.name()
+ self.name == kw::Super ||
+ self.name == kw::SelfLower ||
+ self.name == kw::SelfUpper ||
+ self.name == kw::Crate ||
+ self.name == kw::PathRoot ||
+ self.name == kw::DollarCrate
}
/// This identifier can be a raw identifier.
pub fn can_be_raw(self) -> bool {
- self.name != keywords::Invalid.name() && self.name != keywords::Underscore.name() &&
+ self.name != kw::Invalid && self.name != kw::Underscore &&
!self.is_path_segment_keyword()
}
@@ -1267,7 +1260,7 @@ mod tests {
fn without_first_quote_test() {
GLOBALS.set(&Globals::new(edition::DEFAULT_EDITION), || {
let i = Ident::from_str("'break");
- assert_eq!(i.without_first_quote().name, keywords::Break.name());
+ assert_eq!(i.without_first_quote().name, kw::Break);
});
}
}