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

petrochenkov · petrochenkov · commit e2c821d35ee5 · 2016-04-24T20:59:44.000+03:00
diff --git a/src/librustc/hir/fold.rs b/src/librustc/hir/fold.rs
@@ -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,
diff --git a/src/librustc/hir/print.rs b/src/librustc/hir/print.rs
@@ -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.
                     }
                     _ => {
diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs
@@ -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);
diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs
@@ -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);
                 }
diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs
@@ -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> {
diff --git a/src/librustc/ty/sty.rs b/src/librustc/ty/sty.rs
@@ -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 {
diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
@@ -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);
             }
         }
diff --git a/src/librustc_save_analysis/dump_visitor.rs b/src/librustc_save_analysis/dump_visitor.rs
@@ -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"),
diff --git a/src/librustc_trans/mir/mod.rs b/src/librustc_trans/mir/mod.rs
@@ -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));
diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs
@@ -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,
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
@@ -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
diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs
@@ -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?"),
         };
 
diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs
@@ -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,
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
@@ -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,
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
@@ -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}
     }
 }
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
@@ -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,
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
@@ -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)
         };
diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs
@@ -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 {
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
@@ -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,
diff --git a/src/libsyntax/lib.rs b/src/libsyntax/lib.rs
@@ -25,6 +25,7 @@
 #![cfg_attr(not(stage0), deny(warnings))]
 
 #![feature(associated_consts)]
+#![feature(const_fn)]
 #![feature(filling_drop)]
 #![feature(libc)]
 #![feature(rustc_private)]
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
diff --git a/src/libsyntax/std_inject.rs b/src/libsyntax/std_inject.rs
diff --git a/src/libsyntax/test.rs b/src/libsyntax/test.rs
diff --git a/src/libsyntax_ext/deriving/generic/mod.rs b/src/libsyntax_ext/deriving/generic/mod.rs
diff --git a/src/libsyntax_ext/deriving/generic/ty.rs b/src/libsyntax_ext/deriving/generic/ty.rs
diff --git a/src/libsyntax_ext/format.rs b/src/libsyntax_ext/format.rs

Original file line number	Diff line number	Diff line change
`@@ -2211,7 +2211,7 @@ impl<'a> State<'a> {`
`2211`	`2211`	`match input.pat.node {`
`2212`	`2212`	`PatKind::Ident(_, ref path1, _) if`
`2213`	`2213`	`path1.node.name ==`
`2214`		`- parse::token::special_idents::invalid.name => {`
	`2214`	`+ parse::token::special_idents::Invalid.name => {`
`2215`	`2215`	`// Do nothing.`
`2216`	`2216`	`}`
`2217`	`2217`	`_ => {`
Original file line number	Diff line number	Diff line change
`@@ -245,7 +245,7 @@ impl<'a, 'v> Visitor<'v> for LifetimeContext<'a> {`
`245`	`245`	`}`
`246`	`246`
`247`	`247`	`fn visit_lifetime(&mut self, lifetime_ref: &hir::Lifetime) {`
`248`		`- if lifetime_ref.name == special_idents::static_lifetime.name {`
	`248`	`+ if lifetime_ref.name == special_idents::StaticLifetime.name {`
`249`	`249`	`self.insert_lifetime(lifetime_ref, DefStaticRegion);`
`250`	`250`	`return;`
`251`	`251`	`}`
`@@ -672,9 +672,8 @@ impl<'a> LifetimeContext<'a> {`
`672`	`672`	`for i in 0..lifetimes.len() {`
`673`	`673`	`let lifetime_i = &lifetimes[i];`
`674`	`674`
`675`		`- let special_idents = [special_idents::static_lifetime];`
`676`	`675`	`for lifetime in lifetimes {`
`677`		`- if special_idents.iter().any(\|&i\| i.name == lifetime.lifetime.name) {`
	`676`	`+ if lifetime.lifetime.name == special_idents::StaticLifetime.name {`
`678`	`677`	`span_err!(self.sess, lifetime.lifetime.span, E0262,`
`679`	`678`	"invalid lifetime parameter name: `{}`", lifetime.lifetime.name);
`680`	`679`	`}`
Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ use std::hash::{Hash, Hasher};`
`44`	`44`	`use std::rc::Rc;`
`45`	`45`	`use syntax::ast::{self, Name, NodeId};`
`46`	`46`	`use syntax::attr;`
`47`		`-use syntax::parse::token::{self, special_idents};`
	`47`	`+use syntax::parse::token::{self, keywords};`
`48`	`48`
`49`	`49`	`use hir;`
`50`	`50`
`@@ -1069,7 +1069,7 @@ impl<'tcx> TyCtxt<'tcx> {`
`1069`	`1069`	`}`
`1070`	`1070`
`1071`	`1071`	`pub fn mk_self_type(&self) -> Ty<'tcx> {`
`1072`		`- self.mk_param(subst::SelfSpace, 0, special_idents::type_self.name)`
	`1072`	`+ self.mk_param(subst::SelfSpace, 0, keywords::SelfType.ident.name)`
`1073`	`1073`	`}`
`1074`	`1074`
`1075`	`1075`	`pub fn mk_param_from_def(&self, def: &ty::TypeParameterDef) -> Ty<'tcx> {`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ use std::ops;`
`24`	`24`	`use std::mem;`
`25`	`25`	`use syntax::abi;`
`26`	`26`	`use syntax::ast::{self, Name};`
`27`		`-use syntax::parse::token::special_idents;`
	`27`	`+use syntax::parse::token::keywords;`
`28`	`28`
`29`	`29`	`use serialize::{Decodable, Decoder};`
`30`	`30`
`@@ -533,7 +533,7 @@ impl ParamTy {`
`533`	`533`	`}`
`534`	`534`
`535`	`535`	`pub fn for_self() -> ParamTy {`
`536`		`- ParamTy::new(subst::SelfSpace, 0, special_idents::type_self.name)`
	`536`	`+ ParamTy::new(subst::SelfSpace, 0, keywords::SelfType.ident.name)`
`537`	`537`	`}`
`538`	`538`
`539`	`539`	`pub fn for_def(def: &ty::TypeParameterDef) -> ParamTy {`