Move EnumData to the API.

src/librustc_trans/save/dump_csv.rs

@@ -604,65 +604,60 @@ fn process_enum(&mut self,
                     item: &ast::Item,
                     enum_definition: &ast::EnumDef,
                     ty_params: &ast::Generics) {
-        let enum_name = format!("::{}", self.analysis.ty_cx.map.path_to_string(item.id));
-        let val = self.span.snippet(item.span);
-        match self.span.sub_span_after_keyword(item.span, keywords::Enum) {
-            Some(sub_span) => self.fmt.enum_str(item.span,
-                                                Some(sub_span),
-                                                item.id,
-                                                &enum_name[..],
-                                                self.cur_scope,
-                                                &val[..]),
-            None => self.sess.span_bug(item.span,
-                                       &format!("Could not find subspan for enum {}",
-                                               enum_name)),
-        }
-        for variant in &enum_definition.variants {
-            let name = get_ident(variant.node.name);
-            let name = &name;
-            let mut qualname = enum_name.clone();
-            qualname.push_str("::");
-            qualname.push_str(name);
-            let val = self.span.snippet(variant.span);
-            match variant.node.kind {
-                ast::TupleVariantKind(ref args) => {
-                    // first ident in span is the variant's name
-                    self.fmt.tuple_variant_str(variant.span,
-                                               self.span.span_for_first_ident(variant.span),
-                                               variant.node.id,
-                                               name,
-                                               &qualname[..],
-                                               &enum_name[..],
-                                               &val[..],
-                                               item.id);
-                    for arg in args {
-                        self.visit_ty(&*arg.ty);
+        let enum_data = self.save_ctxt.get_item_data(item);
+        if let super::Data::EnumData(enum_data) = enum_data {
+            self.fmt.enum_str(item.span,
+                              Some(enum_data.span),
+                              enum_data.id,
+                              &enum_data.qualname,
+                              self.cur_scope,
+                              &enum_data.value);
+            for variant in &enum_definition.variants {
+                let name = &get_ident(variant.node.name);
+                let mut qualname = enum_data.qualname.clone();
+                qualname.push_str("::");
+                qualname.push_str(name);
+                let val = self.span.snippet(variant.span);
+                match variant.node.kind {
+                    ast::TupleVariantKind(ref args) => {
+                        // first ident in span is the variant's name
+                        self.fmt.tuple_variant_str(variant.span,
+                                                   self.span.span_for_first_ident(variant.span),
+                                                   variant.node.id,
+                                                   name,
+                                                   &qualname,
+                                                   &enum_data.qualname,
+                                                   &val,
+                                                   item.id);
+                        for arg in args {
+                            self.visit_ty(&*arg.ty);
+                        }
                     }
-                }
-                ast::StructVariantKind(ref struct_def) => {
-                    let ctor_id = match struct_def.ctor_id {
-                        Some(node_id) => node_id,
-                        None => -1,
-                    };
-                    self.fmt.struct_variant_str(
-                        variant.span,
-                        self.span.span_for_first_ident(variant.span),
-                        variant.node.id,
-                        ctor_id,
-                        &qualname[..],
-                        &enum_name[..],
-                        &val[..],
-                        item.id);
-
-                    for field in &struct_def.fields {
-                        self.process_struct_field_def(field, &qualname, variant.node.id);
-                        self.visit_ty(&*field.node.ty);
+                    ast::StructVariantKind(ref struct_def) => {
+                        let ctor_id = match struct_def.ctor_id {
+                            Some(node_id) => node_id,
+                            None => -1,
+                        };
+                        self.fmt.struct_variant_str(variant.span,
+                                                    self.span.span_for_first_ident(variant.span),
+                                                    variant.node.id,
+                                                    ctor_id,
+                                                    &qualname,
+                                                    &enum_data.qualname,
+                                                    &val,
+                                                    item.id);
+
+                        for field in &struct_def.fields {
+                            self.process_struct_field_def(field, &qualname, variant.node.id);
+                            self.visit_ty(&*field.node.ty);
+                        }
                     }
                 }
             }
+            self.process_generic_params(ty_params, item.span, &enum_data.qualname, item.id);
+        } else {
+            self.sess.span_bug(item.span, "expected EnumData");
         }
-
-        self.process_generic_params(ty_params, item.span, &enum_name[..], item.id);
     }
 
     fn process_impl(&mut self,

src/librustc_trans/save/mod.rs

@@ -51,6 +51,8 @@ pub enum Data {
     VariableData(VariableData),
     /// Data for modules.
     ModData(ModData),
+    /// Data for Enums.
+    EnumData(EnumData),
 
     /// Data for the use of some variable (e.g., the use of a local variable, which
     /// will refere to that variables declaration).
@@ -88,6 +90,14 @@ pub struct ModData {
     pub filename: String,
 }
 
+/// Data for enum declarations.
+pub struct EnumData {
+    pub id: NodeId,
+    pub value: String,
+    pub qualname: String,
+    pub span: Span,
+}
+
 /// Data for the use of some item (e.g., the use of a local variable, which
 /// will refere to that variables declaration (by ref_id)).
 pub struct VariableRefData {
@@ -188,7 +198,19 @@ pub fn get_item_data(&self, item: &ast::Item) -> Data {
                     scope: self.analysis.ty_cx.map.get_parent(item.id),
                     filename: filename,
                 })
-            }
+            },
+            ast::ItemEnum(..) => {
+                let enum_name = format!("::{}", self.analysis.ty_cx.map.path_to_string(item.id));
+                let val = self.span_utils.snippet(item.span);
+                let sub_span = self.span_utils.sub_span_after_keyword(item.span, keywords::Enum);
+
+                Data::EnumData(EnumData {
+                    id: item.id,
+                    value: val,
+                    span: sub_span.unwrap(),
+                    qualname: enum_name,
+                })
+            },
             _ => {
                 // FIXME
                 unimplemented!();