ident->name cleanup

diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs
index debbc7591d4a4ca9ecec41494f5755f98c610de0..87108530c757e2a74a348693cc6107477a8a9439 100644 (file)
--- a/src/librustc/metadata/decoder.rs
+++ b/src/librustc/metadata/decoder.rs
@@ -1202,10 +1202,11 @@ pub fn get_struct_fields(intr: @ident_interner, cdata: Cmd, id: ast::NodeId)
     do reader::tagged_docs(item, tag_item_field) |an_item| {
         let f = item_family(an_item);
         if f == PublicField || f == PrivateField || f == InheritedField {
+            // FIXME #6993: name should be of type Name, not Ident
             let name = item_name(intr, an_item);
             let did = item_def_id(an_item, cdata);
             result.push(ty::field_ty {
-                ident: name,
+                name: name.name,
                 id: did, vis:
                 struct_field_family_to_visibility(f),
             });
@@ -1215,7 +1216,7 @@ pub fn get_struct_fields(intr: @ident_interner, cdata: Cmd, id: ast::NodeId)
     do reader::tagged_docs(item, tag_item_unnamed_field) |an_item| {
         let did = item_def_id(an_item, cdata);
         result.push(ty::field_ty {
-            ident: special_idents::unnamed_field,
+            name: special_idents::unnamed_field.name,
             id: did,
             vis: ast::inherited,
         });

diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs
index 16338b25bf49aa73a8c36c63fc3f2b8956349cd6..2a38492a6e58626800a41bd765f0e380c509aa68 100644 (file)
--- a/src/librustc/middle/check_match.rs
+++ b/src/librustc/middle/check_match.rs
@@ -700,7 +700,7 @@ pub fn specialize(cx: &MatchCheckCtxt,
                         }
                         let args = class_fields.iter().map(|class_field| {
                             match flds.iter().find(|f|
-                                            f.ident == class_field.ident) {
+                                            f.ident.name == class_field.name) {
                                 Some(f) => f.pat,
                                 _ => wild()
                             }

diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs
index 63b63d8d69142403bb8be776c55cdd74a3d5e8ff..0e3c10ef21471c00fd990b6cb22aa2165c760e39 100644 (file)
--- a/src/librustc/middle/mem_categorization.rs
+++ b/src/librustc/middle/mem_categorization.rs
@@ -1059,6 +1059,7 @@ pub fn region_to_str(&self, r: ty::Region) -> ~str {
 /// an enum to determine which variant is in use.
 pub fn field_mutbl(tcx: ty::ctxt,
                    base_ty: ty::t,
+                   // FIXME #6993: change type to Name
                    f_name: ast::Ident,
                    node_id: ast::NodeId)
                 -> Option<ast::Mutability> {
@@ -1067,7 +1068,7 @@ pub fn field_mutbl(tcx: ty::ctxt,
       ty::ty_struct(did, _) => {
         let r = ty::lookup_struct_fields(tcx, did);
         for fld in r.iter() {
-            if fld.ident == f_name {
+            if fld.name == f_name.name {
                 return Some(ast::MutImmutable);
             }
         }
@@ -1077,7 +1078,7 @@ pub fn field_mutbl(tcx: ty::ctxt,
           ast::DefVariant(_, variant_id, _) => {
             let r = ty::lookup_struct_fields(tcx, variant_id);
             for fld in r.iter() {
-                if fld.ident == f_name {
+                if fld.name == f_name.name {
                     return Some(ast::MutImmutable);
                 }
             }

diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs
index 085925f97a46be8ffb4a526e98a3bb6a377d597f..b6b03d8369a44528d60c4c62888437272729a016 100644 (file)
--- a/src/librustc/middle/privacy.rs
+++ b/src/librustc/middle/privacy.rs
@@ -203,10 +203,11 @@ fn local_item_is_private(&mut self, span: Span, item_id: NodeId) -> bool {
     }
 
     // Checks that a private field is in scope.
+    // FIXME #6993: change type (and name) from Ident to Name
     fn check_field(&mut self, span: Span, id: ast::DefId, ident: ast::Ident) {
         let fields = ty::lookup_struct_fields(self.tcx, id);
         for field in fields.iter() {
-            if field.ident.name != ident.name { loop; }
+            if field.name != ident.name { loop; }
             if field.vis == private {
                 self.tcx.sess.span_err(span, fmt!("field `%s` is private",
                                              token::ident_to_str(&ident)));

diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs
index 244e0e6e85d48c9c3f85f96aef7e69b54fe28d14..62fbdc41b0e7046f34187a15e71b725ce7fd1d2d 100644 (file)
--- a/src/librustc/middle/trans/_match.rs
+++ b/src/librustc/middle/trans/_match.rs
@@ -672,7 +672,7 @@ fn enter_opt<'r>(bcx: @mut Block,
                     let r = ty::lookup_struct_fields(tcx, struct_id);
                     for field in r.iter() {
                             match field_pats.iter().find(|p| p.ident.name
-                                                         == field.ident.name) {
+                                                         == field.name) {
                                 None => reordered_patterns.push(dummy),
                                 Some(fp) => reordered_patterns.push(fp.pat)
                             }

diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
index 7281daf6877096b15362eacfae08c73e3f421bd5..33870ed6acb06597e41ff094aa949db0b8816ab2 100644 (file)
--- a/src/librustc/middle/ty.rs
+++ b/src/librustc/middle/ty.rs
@@ -156,7 +156,7 @@ pub enum SelfMode {
 }
 
 pub struct field_ty {
-    ident: Ident,
+    name: Name,
     id: DefId,
     vis: ast::visibility,
 }
@@ -4227,15 +4227,15 @@ fn struct_field_tys(fields: &[@struct_field]) -> ~[field_ty] {
         match field.node.kind {
             named_field(ident, visibility) => {
                 field_ty {
-                    ident: ident,
+                    name: ident.name,
                     id: ast_util::local_def(field.node.id),
                     vis: visibility,
                 }
             }
             unnamed_field => {
                 field_ty {
-                    ident:
-                        syntax::parse::token::special_idents::unnamed_field,
+                    name:
+                        syntax::parse::token::special_idents::unnamed_field.name,
                     id: ast_util::local_def(field.node.id),
                     vis: ast::public,
                 }
@@ -4250,7 +4250,8 @@ pub fn struct_fields(cx: ctxt, did: ast::DefId, substs: &substs)
                      -> ~[field] {
     do lookup_struct_fields(cx, did).map |f| {
        field {
-            ident: f.ident,
+            // FIXME #6993: change type of field to Name and get rid of new()
+            ident: ast::Ident::new(f.name),
             mt: mt {
                 ty: lookup_field_type(cx, did, f.id, substs),
                 mutbl: MutImmutable

diff --git a/src/librustc/middle/typeck/check/_match.rs b/src/librustc/middle/typeck/check/_match.rs
index 4c5ee1ca2174143c5cb6339caf4a0de381c49a0a..196057e09f762d84fc7f26f15e6a19dad971500c 100644 (file)
--- a/src/librustc/middle/typeck/check/_match.rs
+++ b/src/librustc/middle/typeck/check/_match.rs
@@ -21,6 +21,7 @@
 use std::hashmap::{HashMap, HashSet};
 use syntax::ast;
 use syntax::ast_util;
+use syntax::parse::token;
 use syntax::codemap::Span;
 use syntax::print::pprust;
 
@@ -296,7 +297,7 @@ pub fn check_struct_pat_fields(pcx: &pat_ctxt,
     // Index the class fields.
     let mut field_map = HashMap::new();
     for (i, class_field) in class_fields.iter().enumerate() {
-        field_map.insert(class_field.ident.name, i);
+        field_map.insert(class_field.name, i);
     }
 
     // Typecheck each field.
@@ -333,7 +334,7 @@ pub fn check_struct_pat_fields(pcx: &pat_ctxt,
             }
             tcx.sess.span_err(span,
                               fmt!("pattern does not mention field `%s`",
-                                   tcx.sess.str_of(field.ident)));
+                                   token::interner_get(field.name)));
         }
     }
 }

diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs
index 265e19fdaa730214a03bc87554628619056e3082..b689090d3fd3e659a44ee8bd7fffa8d166a65db9 100644 (file)
--- a/src/librustc/middle/typeck/check/mod.rs
+++ b/src/librustc/middle/typeck/check/mod.rs
@@ -1120,7 +1120,7 @@ pub fn lookup_field_ty(tcx: ty::ctxt,
                        fieldname: ast::Name,
                        substs: &ty::substs) -> Option<ty::t> {
 
-    let o_field = items.iter().find(|f| f.ident.name == fieldname);
+    let o_field = items.iter().find(|f| f.name == fieldname);
     do o_field.map() |f| {
         ty::lookup_field_type(tcx, class_id, f.id, substs)
     }
@@ -2018,7 +2018,7 @@ fn check_struct_or_variant_fields(fcx: @mut FnCtxt,
         let mut class_field_map = HashMap::new();
         let mut fields_found = 0;
         for field in field_types.iter() {
-            class_field_map.insert(field.ident.name, (field.id, false));
+            class_field_map.insert(field.name, (field.id, false));
         }
 
         let mut error_happened = false;
@@ -2070,7 +2070,7 @@ fn check_struct_or_variant_fields(fcx: @mut FnCtxt,
             if fields_found < field_types.len() {
                 let mut missing_fields = ~[];
                 for class_field in field_types.iter() {
-                    let name = class_field.ident.name;
+                    let name = class_field.name;
                     let (_, seen) = *class_field_map.get(&name);
                     if !seen {
                         missing_fields.push(