let config = folder.fold_meta_items(config);
let crate_mod = folder.fold_item(hir::Item {
- name: token::special_idents::invalid.name,
+ name: token::special_idents::Invalid.name,
attrs: attrs,
id: DUMMY_NODE_ID,
vis: hir::Public,
match input.pat.node {
PatKind::Ident(_, ref path1, _) if
path1.node.name ==
- parse::token::special_idents::invalid.name => {
+ parse::token::special_idents::Invalid.name => {
// Do nothing.
}
_ => {
use std::rc::Rc;
use syntax::ast::{self, NodeId};
use syntax::codemap::{BytePos, original_sp, Span};
-use syntax::parse::token::special_idents;
+use syntax::parse::token::keywords;
use syntax::ptr::P;
use hir::Expr;
let var = self.variable(p_id, sp);
// Ignore unused self.
let name = path1.node;
- if name != special_idents::self_.name {
+ if name != keywords::SelfValue.ident.name {
if !self.warn_about_unused(sp, p_id, entry_ln, var) {
if self.live_on_entry(entry_ln, var).is_none() {
self.report_dead_assign(p_id, sp, var, true);
}
fn visit_lifetime(&mut self, lifetime_ref: &hir::Lifetime) {
- if lifetime_ref.name == special_idents::static_lifetime.name {
+ if lifetime_ref.name == special_idents::StaticLifetime.name {
self.insert_lifetime(lifetime_ref, DefStaticRegion);
return;
}
for i in 0..lifetimes.len() {
let lifetime_i = &lifetimes[i];
- let special_idents = [special_idents::static_lifetime];
for lifetime in lifetimes {
- if special_idents.iter().any(|&i| i.name == lifetime.lifetime.name) {
+ if lifetime.lifetime.name == special_idents::StaticLifetime.name {
span_err!(self.sess, lifetime.lifetime.span, E0262,
"invalid lifetime parameter name: `{}`", lifetime.lifetime.name);
}
use std::rc::Rc;
use syntax::ast::{self, Name, NodeId};
use syntax::attr;
-use syntax::parse::token::{self, special_idents};
+use syntax::parse::token::{self, keywords};
use hir;
}
pub fn mk_self_type(&self) -> Ty<'tcx> {
- self.mk_param(subst::SelfSpace, 0, special_idents::type_self.name)
+ self.mk_param(subst::SelfSpace, 0, keywords::SelfType.ident.name)
}
pub fn mk_param_from_def(&self, def: &ty::TypeParameterDef) -> Ty<'tcx> {
use std::mem;
use syntax::abi;
use syntax::ast::{self, Name};
-use syntax::parse::token::special_idents;
+use syntax::parse::token::keywords;
use serialize::{Decodable, Decoder};
}
pub fn for_self() -> ParamTy {
- ParamTy::new(subst::SelfSpace, 0, special_idents::type_self.name)
+ ParamTy::new(subst::SelfSpace, 0, keywords::SelfType.ident.name)
}
pub fn for_def(def: &ty::TypeParameterDef) -> ParamTy {
use syntax::attr::AttrMetaMethods;
use syntax::codemap::{self, Span, Pos};
use syntax::errors::DiagnosticBuilder;
-use syntax::parse::token::{self, special_names, special_idents};
+use syntax::parse::token::{self, keywords, special_idents};
use syntax::util::lev_distance::find_best_match_for_name;
use rustc::hir::intravisit::{self, FnKind, Visitor};
let mut self_type_rib = Rib::new(NormalRibKind);
// plain insert (no renaming, types are not currently hygienic....)
- let name = special_names::type_self;
- self_type_rib.bindings.insert(name, self_def);
+ self_type_rib.bindings.insert(keywords::SelfType.ident.name, self_def);
self.type_ribs.push(self_type_rib);
f(self);
if !self.resolved {
"type name"
};
- let self_type_name = special_idents::type_self.name;
let is_invalid_self_type_name = path.segments.len() > 0 &&
maybe_qself.is_none() &&
path.segments[0].identifier.name ==
- self_type_name;
+ keywords::SelfType.ident.name;
if is_invalid_self_type_name {
resolve_error(self,
ty.span,
namespace: Namespace,
record_used: bool)
-> Option<LocalDef> {
- if identifier.name == special_idents::invalid.name {
+ if identifier.name == special_idents::Invalid.name {
return Some(LocalDef::from_def(Def::Err));
}
false // Stop advancing
});
- if method_scope && special_names::self_.as_str() == &path_name[..] {
+ if method_scope &&
+ &path_name[..] == keywords::SelfValue.ident.name.as_str() {
resolve_error(self,
expr.span,
ResolutionError::SelfNotAvailableInStaticMethod);
}
BlockParentLink(ref module, _) => {
// danger, shouldn't be ident?
- names.push(special_idents::opaque.name);
+ names.push(token::intern("<opaque>"));
collect_mod(names, module);
}
}
span: sub_span.expect("No span found for use"),
id: item.id,
mod_id: mod_id,
- name: ident.name.to_string(),
+ name: ident.to_string(),
scope: self.cur_scope
}.normalize(&self.tcx));
}
if !self.span.filter_generated(alias_span, item.span) {
self.dumper.extern_crate(item.span, ExternCrateData {
id: item.id,
- name: item.ident.name.to_string(),
+ name: item.ident.to_string(),
crate_num: cnum,
location: location,
span: alias_span.expect("No span found for extern crate"),
alloca: lltemp,
address_operations: &ops
};
- declare_local(bcx, token::special_idents::invalid.name,
+ declare_local(bcx, token::special_idents::Invalid.name,
tupled_arg_ty, scope, variable_access,
VariableKind::ArgumentVariable(arg_index + i + 1),
bcx.fcx().span.unwrap_or(DUMMY_SP));
let trait_node_id = tcx.map.as_local_node_id(trait_did).unwrap();
match find_bound_for_assoc_item(this,
trait_node_id,
- token::special_idents::type_self.name,
+ token::keywords::SelfType.ident.name,
assoc_name,
span) {
Ok(bound) => bound,
method_ty
}
Err(error) => {
- if method_name.node != special_idents::invalid.name {
+ if method_name.node != special_idents::Invalid.name {
method::report_error(fcx, method_name.span, expr_t,
method_name.node, Some(rcvr), error);
}
let msg = format!("field `{}` of struct `{}` is private", field.node, struct_path);
fcx.tcx().sess.span_err(expr.span, &msg);
fcx.write_ty(expr.id, field_ty);
- } else if field.node == special_idents::invalid.name {
+ } else if field.node == special_idents::Invalid.name {
fcx.write_error(expr.id);
} else if method::exists(fcx, field.span, field.node, expr_t, expr.id) {
fcx.type_error_struct(field.span,
method::MethodError::PrivateMatch(def) => Some(def),
_ => None,
};
- if item_name != special_idents::invalid.name {
+ if item_name != special_idents::Invalid.name {
method::report_error(fcx, span, ty, item_name, None, error);
}
def
use syntax::ast;
use syntax::codemap::{Span};
use syntax::errors::DiagnosticBuilder;
-use syntax::parse::token::{special_idents};
+use syntax::parse::token::keywords;
use rustc::hir::intravisit::{self, Visitor};
use rustc::hir;
{
let name = match space {
TypeSpace => ast_generics.ty_params[index].name,
- SelfSpace => special_idents::type_self.name,
+ SelfSpace => keywords::SelfType.ident.name,
FnSpace => bug!("Fn space occupied?"),
};
use syntax::ast;
use syntax::attr;
use syntax::codemap::Span;
-use syntax::parse::token::special_idents;
+use syntax::parse::token::keywords;
use syntax::ptr::P;
use rustc::hir::{self, PatKind};
use rustc::hir::intravisit;
let def = ty::TypeParameterDef {
space: SelfSpace,
index: 0,
- name: special_idents::type_self.name,
+ name: keywords::SelfType.ident.name,
def_id: ccx.tcx.map.local_def_id(param_id),
default_def_id: ccx.tcx.map.local_def_id(parent),
default: None,
use syntax::attr::{AttributeMethods, AttrMetaMethods};
use syntax::codemap;
use syntax::codemap::{DUMMY_SP, Pos, Spanned};
-use syntax::parse::token::{self, InternedString, special_idents};
+use syntax::parse::token::{self, InternedString, keywords};
use syntax::ptr::P;
use rustc_trans::back::link;
hir::TyFloat(ast::FloatTy::F64) => return Primitive(F64),
},
Def::SelfTy(..) if path.segments.len() == 1 => {
- return Generic(special_idents::type_self.name.to_string());
+ return Generic(keywords::SelfType.ident.to_string());
}
Def::SelfTy(..) | Def::TyParam(..) => true,
_ => false,
pub fn new(name: Name, ctxt: SyntaxContext) -> Ident {
Ident {name: name, ctxt: ctxt}
}
- pub fn with_empty_ctxt(name: Name) -> Ident {
+ pub const fn with_empty_ctxt(name: Name) -> Ident {
Ident {name: name, ctxt: EMPTY_CTXT}
}
}
use attr;
use codemap::{Span, respan, Spanned, DUMMY_SP, Pos};
use ext::base::ExtCtxt;
-use parse::token::special_idents;
+use parse::token::{keywords, special_idents};
use parse::token::InternedString;
use parse::token;
use ptr::P;
self.expr_path(self.path_ident(span, id))
}
fn expr_self(&self, span: Span) -> P<ast::Expr> {
- self.expr_ident(span, special_idents::self_)
+ self.expr_ident(span, keywords::SelfValue.ident)
}
fn expr_binary(&self, sp: Span, op: ast::BinOpKind,
vis: ast::Visibility, vp: P<ast::ViewPath>) -> P<ast::Item> {
P(ast::Item {
id: ast::DUMMY_NODE_ID,
- ident: special_idents::invalid,
+ ident: special_idents::Invalid,
attrs: vec![],
node: ast::ItemKind::Use(vp),
vis: vis,
Some(rc) => match *rc {
NormalTT(ref expander, tt_span, allow_internal_unstable) => {
- if ident.name != parse::token::special_idents::invalid.name {
+ if ident.name != parse::token::special_idents::Invalid.name {
fld.cx
.span_err(path_span,
&format!("macro {}! expects no ident argument, given '{}'",
expander.expand(fld.cx, span, &marked_before[..])
}
IdentTT(ref expander, tt_span, allow_internal_unstable) => {
- if ident.name == parse::token::special_idents::invalid.name {
+ if ident.name == parse::token::special_idents::Invalid.name {
fld.cx.span_err(path_span,
&format!("macro {}! expects an ident argument",
extname));
expander.expand(fld.cx, span, ident, marked_tts)
}
MacroRulesTT => {
- if ident.name == parse::token::special_idents::invalid.name {
+ if ident.name == parse::token::special_idents::Invalid.name {
fld.cx.span_err(path_span, "macro_rules! expects an ident argument");
return SmallVector::zero();
}
}
ast::ItemKind::Mod(_) | ast::ItemKind::ForeignMod(_) => {
let valid_ident =
- it.ident.name != parse::token::special_idents::invalid.name;
+ it.ident.name != parse::token::special_idents::Invalid.name;
if valid_ident {
fld.cx.mod_push(it.ident);
// run one of the renaming tests
fn run_renaming_test(t: &RenamingTest, test_idx: usize) {
- let invalid_name = token::special_idents::invalid.name;
+ let invalid_name = token::special_idents::Invalid.name;
let (teststr, bound_connections, bound_ident_check) = match *t {
(ref str,ref conns, bic) => (str.to_string(), conns.clone(), bic)
};
use ext::tt::macro_parser::parse;
use parse::lexer::new_tt_reader;
use parse::parser::{Parser, Restrictions};
-use parse::token::{self, special_idents, gensym_ident, NtTT, Token};
+use parse::token::{self, gensym_ident, NtTT, Token};
use parse::token::Token::*;
use print;
use ptr::P;
// $( $lhs:tt => $rhs:tt );+
// ...quasiquoting this would be nice.
// These spans won't matter, anyways
- let match_lhs_tok = MatchNt(lhs_nm, special_idents::tt);
- let match_rhs_tok = MatchNt(rhs_nm, special_idents::tt);
+ let match_lhs_tok = MatchNt(lhs_nm, token::str_to_ident("tt"));
+ let match_rhs_tok = MatchNt(rhs_nm, token::str_to_ident("tt"));
let argument_gram = vec!(
TokenTree::Sequence(DUMMY_SP,
Rc::new(ast::SequenceRepetition {
let config = folder.fold_meta_items(config);
let mut items = folder.fold_item(P(ast::Item {
- ident: token::special_idents::invalid,
+ ident: token::special_idents::Invalid,
attrs: attrs,
id: ast::DUMMY_NODE_ID,
vis: ast::Visibility::Public,
#![cfg_attr(not(stage0), deny(warnings))]
#![feature(associated_consts)]
+#![feature(const_fn)]
#![feature(filling_drop)]
#![feature(libc)]
#![feature(rustc_private)]
match *self {
TokenType::Token(ref t) => format!("`{}`", Parser::token_to_string(t)),
TokenType::Operator => "an operator".to_string(),
- TokenType::Keyword(kw) => format!("`{}`", kw.to_name()),
+ TokenType::Keyword(kw) => format!("`{}`", kw.ident.name),
}
}
}
}
pub fn parse_ident(&mut self) -> PResult<'a, ast::Ident> {
- if !self.restrictions.contains(Restrictions::ALLOW_MODULE_PATHS) {
- self.check_strict_keywords();
- }
+ self.check_used_keywords();
self.check_reserved_keywords();
match self.token {
token::Ident(i) => {
}
/// Signal an error if the given string is a strict keyword
- pub fn check_strict_keywords(&mut self) {
- if self.token.is_strict_keyword() {
+ pub fn check_used_keywords(&mut self) {
+ if self.token.is_used_keyword() {
let token_str = self.this_token_to_string();
let span = self.span;
self.span_err(span,
} else {
debug!("parse_arg_general ident_to_pat");
let sp = self.last_span;
- let spanned = Spanned { span: sp, node: special_idents::invalid };
+ let spanned = Spanned { span: sp, node: special_idents::Invalid };
P(Pat {
id: ast::DUMMY_NODE_ID,
node: PatKind::Ident(BindingMode::ByValue(Mutability::Immutable),
}
hi = self.last_span.hi;
} else if self.token.is_keyword(keywords::Let) {
- // Catch this syntax error here, instead of in `check_strict_keywords`, so
+ // Catch this syntax error here, instead of in `check_used_keywords`, 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.note("variable declaration using `let` is a statement");
self.span_err(self.span, &format!("unexpected token: `{}`", actual));
let dot_pos = self.last_span.hi;
- e = self.parse_dot_suffix(special_idents::invalid,
+ e = self.parse_dot_suffix(special_idents::Invalid,
mk_sp(dot_pos, dot_pos),
e, lo)?;
}
};
// continue by trying to parse the `:ident` after `$name`
if self.token == token::Colon && self.look_ahead(1, |t| t.is_ident() &&
- !t.is_strict_keyword() &&
+ !t.is_used_keyword() &&
!t.is_reserved_keyword()) {
self.bump();
sp = mk_sp(sp.lo, self.span.hi);
self.bump();
let id = match self.token {
- token::OpenDelim(_) => token::special_idents::invalid, // no special identifier
+ token::OpenDelim(_) => token::special_idents::Invalid, // no special identifier
_ => self.parse_ident()?,
};
_ => {
// we only expect an ident if we didn't parse one
// above.
- let ident_str = if id.name == token::special_idents::invalid.name {
+ let ident_str = if id.name == token::special_idents::Invalid.name {
"identifier, "
} else {
""
MacStmtStyle::NoBraces
};
- if id.name == token::special_idents::invalid.name {
+ if id.name == token::special_idents::Invalid.name {
let mac = P(spanned(lo, hi, Mac_ { path: pth, tts: tts, ctxt: EMPTY_CTXT }));
let stmt = StmtKind::Mac(mac, style, attrs.into_thin_attrs());
spanned(lo, hi, stmt)
fn expect_self_ident(&mut self) -> PResult<'a, ast::Ident> {
match self.token {
- token::Ident(id) if id.name == special_idents::self_.name => {
+ token::Ident(id) if id.name == keywords::SelfValue.ident.name => {
self.bump();
+ // The hygiene context of `id` needs to be preserved here,
+ // so we can't just return `SelfValue.ident`.
Ok(id)
},
_ => {
self.bump();
}
// error case, making bogus self ident:
- SelfKind::Value(special_idents::self_)
+ SelfKind::Value(keywords::SelfValue.ident)
}
token::Ident(..) => {
if self.token.is_keyword(keywords::SelfValue) {
if delim != token::Brace {
self.expect(&token::Semi)?
}
- Ok((token::special_idents::invalid, vec![], ast::ImplItemKind::Macro(m)))
+ Ok((token::special_idents::Invalid, vec![], ast::ImplItemKind::Macro(m)))
} else {
let (constness, unsafety, abi) = self.parse_fn_front_matter()?;
let ident = self.parse_ident()?;
self.expect(&token::OpenDelim(token::Brace))?;
self.expect(&token::CloseDelim(token::Brace))?;
- Ok((special_idents::invalid,
+ Ok((special_idents::Invalid,
ItemKind::DefaultImpl(unsafety, opt_trait.unwrap()), None))
} else {
if opt_trait.is_some() {
impl_items.push(self.parse_impl_item()?);
}
- Ok((special_idents::invalid,
+ Ok((special_idents::Invalid,
ItemKind::Impl(unsafety, polarity, generics, opt_trait, ty, impl_items),
Some(attrs)))
}
/// Parse defaultness: DEFAULT or nothing
fn parse_defaultness(&mut self) -> PResult<'a, Defaultness> {
- if self.eat_contextual_keyword(special_idents::DEFAULT) {
+ if self.eat_contextual_keyword(special_idents::Default) {
Ok(Defaultness::Default)
} else {
Ok(Defaultness::Final)
};
Ok(self.mk_item(lo,
last_span.hi,
- special_idents::invalid,
+ special_idents::Invalid,
ItemKind::ForeignMod(m),
visibility,
attrs))
let last_span = self.last_span;
let item = self.mk_item(lo,
last_span.hi,
- token::special_idents::invalid,
+ token::special_idents::Invalid,
item_,
visibility,
attrs);
let id = if self.token.is_ident() {
self.parse_ident()?
} else {
- token::special_idents::invalid // no special identifier
+ token::special_idents::Invalid // no special identifier
};
// eat a matched-delimiter token tree:
let delim = self.expect_open_delim()?;
/// Returns `true` if the token is a given keyword, `kw`.
pub fn is_keyword(&self, kw: keywords::Keyword) -> bool {
match *self {
- Ident(id) => id.name == kw.to_name(),
+ Ident(id) => id.name == kw.ident.name,
_ => false,
}
}
pub fn is_path_segment_keyword(&self) -> bool {
match *self {
- Ident(id) => id.name == SUPER_KEYWORD_NAME ||
- id.name == SELF_KEYWORD_NAME ||
- id.name == SELF_TYPE_KEYWORD_NAME,
+ Ident(id) => id.name == keywords::Super.ident.name ||
+ id.name == keywords::SelfValue.ident.name ||
+ id.name == keywords::SelfType.ident.name,
_ => false,
}
}
- /// Returns `true` if the token is either a strict or reserved keyword.
+ /// Returns `true` if the token is either a used or reserved keyword.
pub fn is_any_keyword(&self) -> bool {
match *self {
- Ident(id) => id.name == SELF_KEYWORD_NAME ||
- id.name == STATIC_KEYWORD_NAME ||
- id.name == SUPER_KEYWORD_NAME ||
- id.name == SELF_TYPE_KEYWORD_NAME ||
- id.name >= STRICT_KEYWORD_START &&
+ Ident(id) => id.name >= USED_KEYWORD_START &&
id.name <= RESERVED_KEYWORD_FINAL,
_ => false
}
}
- /// Returns `true` if the token is either a strict keyword.
- pub fn is_strict_keyword(&self) -> bool {
+ /// Returns `true` if the token is a used keyword.
+ pub fn is_used_keyword(&self) -> bool {
match *self {
- Ident(id) => id.name == SELF_KEYWORD_NAME ||
- id.name == STATIC_KEYWORD_NAME ||
- id.name == SUPER_KEYWORD_NAME ||
- id.name == SELF_TYPE_KEYWORD_NAME ||
- id.name >= STRICT_KEYWORD_START &&
- id.name <= STRICT_KEYWORD_FINAL,
+ Ident(id) => id.name >= USED_KEYWORD_START &&
+ id.name <= USED_KEYWORD_FINAL,
_ => false,
}
}
- /// Returns `true` if the token is either a keyword reserved for possible future use.
+ /// Returns `true` if the token is a keyword reserved for possible future use.
pub fn is_reserved_keyword(&self) -> bool {
match *self {
Ident(id) => id.name >= RESERVED_KEYWORD_START &&
}
}
-
// Get the first "argument"
macro_rules! first {
( $first:expr, $( $remainder:expr, )* ) => ( $first )
// In this macro, there is the requirement that the name (the number) must be monotonically
// increasing by one in the special identifiers, starting at 0; the same holds for the keywords,
-// except starting from the next number instead of zero, and with the additional exception that
-// special identifiers are *also* allowed (they are deduplicated in the important place, the
-// interner), an exception which is demonstrated by "static" and "self".
+// except starting from the next number instead of zero.
macro_rules! declare_special_idents_and_keywords {(
// So now, in these rules, why is each definition parenthesised?
// Answer: otherwise we get a spurious local ambiguity bug on the "}"
pub mod special_idents {
- $( ($si_name:expr, $si_static:ident, $si_str:expr); )*
+ $( ($si_index: expr, $si_const: ident, $si_str: expr); )*
}
pub mod keywords {
- 'strict:
- $( ($sk_name:expr, $sk_variant:ident, $sk_str:expr); )*
+ 'used:
+ $( ($ukw_index: expr, $ukw_const: ident, $ukw_str: expr); )*
'reserved:
- $( ($rk_name:expr, $rk_variant:ident, $rk_str:expr); )*
+ $( ($rkw_index: expr, $rkw_const: ident, $rkw_str: expr); )*
}
) => {
- const STRICT_KEYWORD_START: ast::Name = first!($( ast::Name($sk_name), )*);
- const STRICT_KEYWORD_FINAL: ast::Name = last!($( ast::Name($sk_name), )*);
- const RESERVED_KEYWORD_START: ast::Name = first!($( ast::Name($rk_name), )*);
- const RESERVED_KEYWORD_FINAL: ast::Name = last!($( ast::Name($rk_name), )*);
+ const USED_KEYWORD_START: ast::Name = first!($( ast::Name($ukw_index), )*);
+ const USED_KEYWORD_FINAL: ast::Name = last!($( ast::Name($ukw_index), )*);
+ const RESERVED_KEYWORD_START: ast::Name = first!($( ast::Name($rkw_index), )*);
+ const RESERVED_KEYWORD_FINAL: ast::Name = last!($( ast::Name($rkw_index), )*);
pub mod special_idents {
use ast;
$(
#[allow(non_upper_case_globals)]
- pub const $si_static: ast::Ident = ast::Ident {
- name: ast::Name($si_name),
- ctxt: ast::EMPTY_CTXT,
- };
- )*
- }
-
- pub mod special_names {
- use ast;
- $(
- #[allow(non_upper_case_globals)]
- pub const $si_static: ast::Name = ast::Name($si_name);
+ pub const $si_const: ast::Ident = ast::Ident::with_empty_ctxt(ast::Name($si_index));
)*
}
- /// All the valid words that have meaning in the Rust language.
- ///
- /// Rust keywords are either 'strict' or 'reserved'. Strict keywords may not
- /// appear as identifiers at all. Reserved keywords are not used anywhere in
- /// the language and may not appear as identifiers.
+ /// Rust keywords are either 'used' in the language or 'reserved' for future use.
pub mod keywords {
- pub use self::Keyword::*;
use ast;
-
- #[derive(Copy, Clone, PartialEq, Eq)]
- pub enum Keyword {
- $( $sk_variant, )*
- $( $rk_variant, )*
- }
-
- impl Keyword {
- pub fn to_name(&self) -> ast::Name {
- match *self {
- $( $sk_variant => ast::Name($sk_name), )*
- $( $rk_variant => ast::Name($rk_name), )*
- }
- }
+ #[derive(Clone, Copy, PartialEq, Eq)]
+ pub struct Keyword {
+ pub ident: ast::Ident,
}
+ $(
+ #[allow(non_upper_case_globals)]
+ pub const $ukw_const: Keyword = Keyword {
+ ident: ast::Ident::with_empty_ctxt(ast::Name($ukw_index))
+ };
+ )*
+ $(
+ #[allow(non_upper_case_globals)]
+ pub const $rkw_const: Keyword = Keyword {
+ ident: ast::Ident::with_empty_ctxt(ast::Name($rkw_index))
+ };
+ )*
}
fn mk_fresh_ident_interner() -> IdentInterner {
- let mut init_vec = Vec::new();
- $(init_vec.push($si_str);)*
- $(init_vec.push($sk_str);)*
- $(init_vec.push($rk_str);)*
- interner::StrInterner::prefill(&init_vec[..])
+ interner::StrInterner::prefill(&[$($si_str,)* $($ukw_str,)* $($rkw_str,)*])
}
}}
-// If the special idents get renumbered, remember to modify these two as appropriate
-pub const SELF_KEYWORD_NAME: ast::Name = ast::Name(SELF_KEYWORD_NAME_NUM);
-const STATIC_KEYWORD_NAME: ast::Name = ast::Name(STATIC_KEYWORD_NAME_NUM);
-pub const SUPER_KEYWORD_NAME: ast::Name = ast::Name(SUPER_KEYWORD_NAME_NUM);
-const SELF_TYPE_KEYWORD_NAME: ast::Name = ast::Name(SELF_TYPE_KEYWORD_NAME_NUM);
-
-pub const SELF_KEYWORD_NAME_NUM: u32 = 1;
-const STATIC_KEYWORD_NAME_NUM: u32 = 2;
-const SUPER_KEYWORD_NAME_NUM: u32 = 3;
-const SELF_TYPE_KEYWORD_NAME_NUM: u32 = 10;
-
// NB: leaving holes in the ident table is bad! a different ident will get
// interned with the id from the hole, but it will be between the min and max
// of the reserved words, and thus tagged as "reserved".
declare_special_idents_and_keywords! {
pub mod special_idents {
- // These ones are statics
- (0, invalid, "");
- (super::SELF_KEYWORD_NAME_NUM, self_, "self");
- (super::STATIC_KEYWORD_NAME_NUM, statik, "static");
- (super::SUPER_KEYWORD_NAME_NUM, super_, "super");
- (4, static_lifetime, "'static");
-
- // for matcher NTs
- (5, tt, "tt");
- (6, matchers, "matchers");
-
- // outside of libsyntax
- (7, clownshoe_abi, "__rust_abi");
- (8, opaque, "<opaque>");
- (9, __unused1, "<__unused1>");
- (super::SELF_TYPE_KEYWORD_NAME_NUM, type_self, "Self");
- (11, prelude_import, "prelude_import");
- (12, DEFAULT, "default");
+ // Special identifiers
+ (0, Invalid, "");
+ (1, __Unused1, "<__unused1>");
+ (2, __Unused2, "<__unused2>");
+ (3, __Unused3, "<__unused3>");
+ (4, __Unused4, "<__unused4>");
+ (5, __Unused5, "<__unused5>");
+ (6, Union, "union");
+ (7, Default, "default");
+ (8, StaticLifetime, "'static");
}
pub mod keywords {
- // These ones are variants of the Keyword enum
-
- 'strict:
+ // Keywords
+ 'used:
+ (9, Static, "static");
+ (10, Super, "super");
+ (11, SelfValue, "self");
+ (12, SelfType, "Self");
(13, As, "as");
(14, Break, "break");
(15, Crate, "crate");
(31, Pub, "pub");
(32, Ref, "ref");
(33, Return, "return");
- // Static and Self are also special idents (prefill de-dupes)
- (super::STATIC_KEYWORD_NAME_NUM, Static, "static");
- (super::SELF_KEYWORD_NAME_NUM, SelfValue, "self");
- (super::SELF_TYPE_KEYWORD_NAME_NUM, SelfType, "Self");
(34, Struct, "struct");
- (super::SUPER_KEYWORD_NAME_NUM, Super, "super");
(35, True, "true");
(36, Trait, "trait");
(37, Type, "type");
match input.pat.node {
PatKind::Ident(_, ref path1, _) if
path1.node.name ==
- parse::token::special_idents::invalid.name => {
+ parse::token::special_idents::Invalid.name => {
// Do nothing.
}
_ => {
let vp = P(codemap::dummy_spanned(ast::ViewPathGlob(prelude_path)));
mod_.items.insert(0, P(ast::Item {
id: ast::DUMMY_NODE_ID,
- ident: special_idents::invalid,
+ ident: special_idents::Invalid,
node: ast::ItemKind::Use(vp),
attrs: vec![ast::Attribute {
span: self.span,
style: ast::AttrStyle::Outer,
value: P(ast::MetaItem {
span: self.span,
- node: ast::MetaItemKind::Word(special_idents::prelude_import.name.as_str()),
+ node: ast::MetaItemKind::Word(
+ token::intern_and_get_ident("prelude_import")
+ ),
}),
is_sugared_doc: false,
},
fn fold_item(&mut self, i: P<ast::Item>) -> SmallVector<P<ast::Item>> {
let ident = i.ident;
- if ident.name != token::special_idents::invalid.name {
+ if ident.name != token::special_idents::Invalid.name {
self.cx.path.push(ident);
}
debug!("current path: {}", path_name_i(&self.cx.path));
ast::ItemKind::Mod(..) => fold::noop_fold_item(i, self),
_ => SmallVector::one(i),
};
- if ident.name != token::special_idents::invalid.name {
+ if ident.name != token::special_idents::Invalid.name {
self.cx.path.pop();
}
res
(ast::ItemKind::Use(
P(nospan(ast::ViewPathSimple(id_test,
path_node(vec!(id_test)))))),
- ast::Visibility::Public, token::special_idents::invalid)
+ ast::Visibility::Public, token::special_idents::Invalid)
} else {
(ast::ItemKind::ExternCrate(None), ast::Visibility::Inherited, id_test)
};
P(ast::Item {
id: ast::DUMMY_NODE_ID,
- ident: token::special_idents::invalid,
+ ident: token::special_idents::Invalid,
attrs: vec![],
node: ast::ItemKind::Use(P(use_path)),
vis: ast::Visibility::Inherited,
let struct_type = ecx.ty_path(ecx.path(sp, vec![ecx.ident_of("self"),
ecx.ident_of("test"),
ecx.ident_of("TestDescAndFn")]));
- let static_lt = ecx.lifetime(sp, token::special_idents::static_lifetime.name);
+ let static_lt = ecx.lifetime(sp, token::special_idents::StaticLifetime.name);
// &'static [self::test::TestDescAndFn]
let static_type = ecx.ty_rptr(sp,
ecx.ty(sp, ast::TyKind::Vec(struct_type)),
use syntax::errors::Handler;
use syntax::util::move_map::MoveMap;
use syntax::parse::token::{intern, InternedString};
-use syntax::parse::token::special_idents;
+use syntax::parse::token::{keywords, special_idents};
use syntax::ptr::P;
use self::ty::{LifetimeBounds, Path, Ptr, PtrTy, Self_, Ty};
cx.item(
self.span,
- special_idents::invalid,
+ special_idents::Invalid,
a,
ast::ItemKind::Impl(unsafety,
ast::ImplPolarity::Positive,
// creating fresh self id
_ => Some(ast::Arg::new_self(trait_.span,
ast::Mutability::Immutable,
- special_idents::self_))
+ keywords::SelfValue.ident))
};
let args = {
let args = arg_types.into_iter().map(|(name, ty)| {
use syntax::ext::base::ExtCtxt;
use syntax::ext::build::AstBuilder;
use syntax::codemap::{Span,respan};
-use syntax::parse::token::special_idents;
+use syntax::parse::token::keywords;
use syntax::ptr::P;
/// The types of pointers
let self_path = cx.expr_self(span);
match *self_ptr {
None => {
- (self_path, respan(span, ast::SelfKind::Value(special_idents::self_)))
+ (self_path, respan(span, ast::SelfKind::Value(keywords::SelfValue.ident)))
}
Some(ref ptr) => {
let self_ty = respan(
match *ptr {
Borrowed(ref lt, mutbl) => {
let lt = lt.map(|s| cx.lifetime(span, cx.ident_of(s).name));
- ast::SelfKind::Region(lt, mutbl, special_idents::self_)
+ ast::SelfKind::Region(lt, mutbl, keywords::SelfValue.ident)
}
Raw(_) => cx.span_bug(span, "attempted to use *self in deriving definition")
});
let sp = piece_ty.span;
let ty = ecx.ty_rptr(sp,
ecx.ty(sp, ast::TyKind::Vec(piece_ty)),
- Some(ecx.lifetime(sp, special_idents::static_lifetime.name)),
+ Some(ecx.lifetime(sp, special_idents::StaticLifetime.name)),
ast::Mutability::Immutable);
let slice = ecx.expr_vec_slice(sp, pieces);
// static instead of const to speed up codegen by not requiring this to be inlined
// First, build up the static array which will become our precompiled
// format "string"
- let static_lifetime = self.ecx.lifetime(self.fmtsp, special_idents::static_lifetime.name);
+ let static_lifetime = self.ecx.lifetime(self.fmtsp, special_idents::StaticLifetime.name);
let piece_ty = self.ecx.ty_rptr(
self.fmtsp,
self.ecx.ty_ident(self.fmtsp, self.ecx.ident_of("str")),
projects / rust.git / commitdiff