nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-05-14 02:49:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

syntax: Make static/super/self/Self keywords + special ident cleanup

Browse Source
This commit is contained in:
Vadim Petrochenkov 2016-04-16 18:05:06 +03:00
parent 546c052d22
commit e2c821d35e
28 changed files with 138 additions and 188 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/librustc/hir/fold.rs
View File

@ -867,7 +867,7 @@ pub fn noop_fold_crate<T: Folder>(Crate { module, attrs, config, span,
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,

2
src/librustc/hir/print.rs
View File

@ -2211,7 +2211,7 @@ impl<'a> State<'a> {
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.
}
_ => {

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

@ -125,7 +125,7 @@ use std::io;
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;
@ -1578,7 +1578,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
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);

5
src/librustc/middle/resolve_lifetime.rs
View File

@ -245,7 +245,7 @@ impl<'a, 'v> Visitor<'v> for LifetimeContext<'a> {
}
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;
}
@ -672,9 +672,8 @@ impl<'a> LifetimeContext<'a> {
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);
}

4
src/librustc/ty/context.rs
View File

@ -44,7 +44,7 @@ use std::hash::{Hash, Hasher};
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;
@ -1069,7 +1069,7 @@ impl<'tcx> TyCtxt<'tcx> {
}
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> {

4
src/librustc/ty/sty.rs
View File

@ -24,7 +24,7 @@ use std::ops;
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};
@ -533,7 +533,7 @@ impl ParamTy {
}
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 {

15
src/librustc_resolve/lib.rs
View File

@ -62,7 +62,7 @@ use syntax::ast::{CRATE_NODE_ID, Name, NodeId, CrateNum, IntTy, UintTy};
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};
@ -1954,8 +1954,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
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 {
@ -2195,11 +2194,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
"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,
@ -2643,7 +2641,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
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));
}
@ -3074,7 +3072,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
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);
@ -3612,7 +3611,7 @@ fn module_to_string(module: Module) -> String {
}
BlockParentLink(ref module, _) => {
// danger, shouldn't be ident?
names.push(special_idents::opaque.name);
names.push(token::intern("<opaque>"));
collect_mod(names, module);
}
}

4
src/librustc_save_analysis/dump_visitor.rs
View File

@ -1011,7 +1011,7 @@ impl<'v, 'l, 'tcx: 'l, 'll, D: Dump +'ll> Visitor<'v> for DumpVisitor<'l, 'tcx,
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));
}
@ -1075,7 +1075,7 @@ impl<'v, 'l, 'tcx: 'l, 'll, D: Dump +'ll> Visitor<'v> for DumpVisitor<'l, '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"),

2
src/librustc_trans/mir/mod.rs
View File

@ -286,7 +286,7 @@ fn arg_value_refs<'bcx, 'tcx>(bcx: &BlockAndBuilder<'bcx, 'tcx>,
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));

2
src/librustc_typeck/astconv.rs
View File

@ -1313,7 +1313,7 @@ fn associated_path_def_to_ty<'tcx>(this: &AstConv<'tcx>,
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,

6
src/librustc_typeck/check/mod.rs
View File

@ -2851,7 +2851,7 @@ fn check_expr_with_expectation_and_lvalue_pref<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
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);
}
@ -2990,7 +2990,7 @@ fn check_expr_with_expectation_and_lvalue_pref<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
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,
@ -3780,7 +3780,7 @@ pub fn resolve_ty_and_def_ufcs<'a, 'b, 'tcx>(fcx: &FnCtxt<'b, 'tcx>,
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

4
src/librustc_typeck/check/wfcheck.rs
View File

@ -24,7 +24,7 @@ use std::collections::HashSet;
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;
@ -472,7 +472,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> {
{
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?"),
};

4
src/librustc_typeck/collect.rs
View File

@ -93,7 +93,7 @@ use syntax::abi;
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;
@ -1655,7 +1655,7 @@ fn ty_generics_for_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
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,

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

@ -31,7 +31,7 @@ use syntax::attr;
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;
@ -2666,7 +2666,7 @@ fn resolve_type(cx: &DocContext,
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,

2
src/libsyntax/ast.rs
View File

@ -93,7 +93,7 @@ impl Ident {
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}
}
}

6
src/libsyntax/ext/build.rs
View File

@ -13,7 +13,7 @@ use ast::{self, Ident, Generics, Expr, BlockCheckMode, UnOp, PatKind};
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;
@ -602,7 +602,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, special_idents::self_)
self.expr_ident(span, keywords::SelfValue.ident)
}
fn expr_binary(&self, sp: Span, op: ast::BinOpKind,
@ -1132,7 +1132,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
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,

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

@ -380,7 +380,7 @@ pub fn expand_item_mac(it: P<ast::Item>,
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 '{}'",
@ -401,7 +401,7 @@ pub fn expand_item_mac(it: P<ast::Item>,
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));
@ -420,7 +420,7 @@ pub fn expand_item_mac(it: P<ast::Item>,
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();
}
@ -893,7 +893,7 @@ fn expand_annotatable(a: Annotatable,
}
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);
@ -1807,7 +1807,7 @@ mod tests {
// 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)
};

6
src/libsyntax/ext/tt/macro_rules.rs
View File

@ -17,7 +17,7 @@ use ext::tt::macro_parser::{MatchedSeq, MatchedNonterminal};
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;
@ -244,8 +244,8 @@ pub fn compile<'cx>(cx: &'cx mut ExtCtxt,
// $( $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 {

2
src/libsyntax/fold.rs
View File

@ -1015,7 +1015,7 @@ pub fn noop_fold_crate<T: Folder>(Crate {module, attrs, config, mut exported_mac
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,

1
src/libsyntax/lib.rs
View File

@ -25,6 +25,7 @@
#![cfg_attr(not(stage0), deny(warnings))]
#![feature(associated_consts)]
#![feature(const_fn)]
#![feature(filling_drop)]
#![feature(libc)]
#![feature(rustc_private)]

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

@ -292,7 +292,7 @@ impl TokenType {
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),
}
}
}
@ -562,9 +562,7 @@ impl<'a> Parser<'a> {
}
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) => {
@ -658,8 +656,8 @@ impl<'a> Parser<'a> {
}
/// 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,
@ -1553,7 +1551,7 @@ impl<'a> Parser<'a> {
} 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),
@ -2335,7 +2333,7 @@ impl<'a> Parser<'a> {
}
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");
@ -2618,7 +2616,7 @@ impl<'a> Parser<'a> {
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)?;
}
@ -2696,7 +2694,7 @@ impl<'a> Parser<'a> {
};
// 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);
@ -3942,7 +3940,7 @@ impl<'a> Parser<'a> {
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()?,
};
@ -3954,7 +3952,7 @@ impl<'a> Parser<'a> {
_ => {
// 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 {
""
@ -3980,7 +3978,7 @@ impl<'a> Parser<'a> {
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)
@ -4610,8 +4608,10 @@ impl<'a> Parser<'a> {
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)
},
_ => {
@ -4696,7 +4696,7 @@ impl<'a> Parser<'a> {
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) {
@ -4971,7 +4971,7 @@ impl<'a> Parser<'a> {
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()?;
@ -5066,7 +5066,7 @@ impl<'a> Parser<'a> {
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() {
@ -5082,7 +5082,7 @@ impl<'a> Parser<'a> {
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)))
}
@ -5260,7 +5260,7 @@ impl<'a> Parser<'a> {
/// 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)
@ -5588,7 +5588,7 @@ impl<'a> Parser<'a> {
};
Ok(self.mk_item(lo,
last_span.hi,
special_idents::invalid,
special_idents::Invalid,
ItemKind::ForeignMod(m),
visibility,
attrs))
@ -5727,7 +5727,7 @@ impl<'a> Parser<'a> {
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);
@ -6018,7 +6018,7 @@ impl<'a> Parser<'a> {
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()?;

159
src/libsyntax/parse/token.rs
View File

@ -271,47 +271,39 @@ impl Token {
/// 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 &&
@ -378,7 +370,6 @@ impl fmt::Debug for Nonterminal {
}
}
// Get the first "argument"
macro_rules! first {
( $first:expr, $( $remainder:expr, )* ) => ( $first )
@ -392,122 +383,85 @@ macro_rules! last {
// 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");
@ -529,12 +483,7 @@ declare_special_idents_and_keywords! {
(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");

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

@ -2959,7 +2959,7 @@ impl<'a> State<'a> {
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.
}
_ => {

6
src/libsyntax/std_inject.rs
View File

@ -148,7 +148,7 @@ impl fold::Folder for PreludeInjector {
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,
@ -157,7 +157,9 @@ impl fold::Folder for PreludeInjector {
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,
},

10
src/libsyntax/test.rs
View File

@ -116,7 +116,7 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> {
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));
@ -160,7 +160,7 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> {
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
@ -453,7 +453,7 @@ fn mk_std(cx: &TestCtxt) -> P<ast::Item> {
(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)
};
@ -545,7 +545,7 @@ fn mk_test_module(cx: &mut TestCtxt) -> (P<ast::Item>, Option<P<ast::Item>>) {
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,
@ -590,7 +590,7 @@ fn mk_tests(cx: &TestCtxt) -> P<ast::Item> {
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)),

6
src/libsyntax_ext/deriving/generic/mod.rs
View File

@ -202,7 +202,7 @@ use syntax::codemap::Span;
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};
@ -635,7 +635,7 @@ impl<'a> TraitDef<'a> {
cx.item(
self.span,
special_idents::invalid,
special_idents::Invalid,
a,
ast::ItemKind::Impl(unsafety,
ast::ImplPolarity::Positive,
@ -866,7 +866,7 @@ impl<'a> MethodDef<'a> {
// 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)| {

6
src/libsyntax_ext/deriving/generic/ty.rs
View File

@ -19,7 +19,7 @@ use syntax::ast::{Expr,Generics,Ident};
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
@ -264,7 +264,7 @@ pub fn get_explicit_self(cx: &ExtCtxt, span: Span, self_ptr: &Option<PtrTy>)
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(
@ -272,7 +272,7 @@ pub fn get_explicit_self(cx: &ExtCtxt, span: Span, self_ptr: &Option<PtrTy>)
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")
});

4
src/libsyntax_ext/format.rs
View File

@ -449,7 +449,7 @@ impl<'a, 'b> Context<'a, 'b> {
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
@ -475,7 +475,7 @@ impl<'a, 'b> Context<'a, 'b> {
// 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")),