Rust: make property_name work on post-processed class names

rust/ast-generator/src/main.rs

@@ -32,7 +32,6 @@ fn class_name(type_name: &str) -> String {
 }
 
 fn property_name(type_name: &str, field_name: &str) -> String {
-    // N.B.: type names here are before any manipulation done by class_name
     let name = match (type_name, field_name) {
         ("CallExpr", "expr") => "function",
         ("LetExpr", "expr") => "scrutinee",
@@ -42,9 +41,9 @@ fn property_name(type_name: &str, field_name: &str) -> String {
         (_, "name_ref") => "identifier",
         (_, "then_branch") => "then",
         (_, "else_branch") => "else_",
-        ("ArrayType", "ty") => "element_type_repr",
+        ("ArrayTypeRepr", "ty") => "element_type_repr",
         ("SelfParam", "is_amp") => "is_ref",
-        ("RecordField", "expr") => "default",
+        ("StructField", "expr") => "default",
         ("UseTree", "is_star") => "is_glob",
         (_, "ty") => "type_repr",
         _ if field_name.contains("record") => &field_name.replacen("record", "struct", 1),
@@ -108,25 +107,27 @@ fn node_src_to_schema_class(
     node: &AstNodeSrc,
     super_types: &BTreeMap<String, BTreeSet<String>>,
 ) -> SchemaClass {
+    let name = class_name(&node.name);
+    let   fields = get_fields(node)
+    .iter()
+        .map(|f| {
+            let (ty, child) = match &f.ty {
+                FieldType::String => ("optional[string]".to_string(), false),
+                FieldType::Predicate => ("predicate".to_string(), false),
+                FieldType::Optional(ty) => (format!("optional[\"{}\"]", class_name(ty)), true),
+                FieldType::List(ty) => (format!("list[\"{}\"]", class_name(ty)), true),
+            };
+            SchemaField {
+                name: property_name(&name, &f.name),
+                ty,
+                child,
+            }
+        })
+        .collect();
     SchemaClass {
-        name: class_name(&node.name),
+        name,
+        fields,
         bases: get_bases(&node.name, super_types),
-        fields: get_fields(node)
-            .iter()
-            .map(|f| {
-                let (ty, child) = match &f.ty {
-                    FieldType::String => ("optional[string]".to_string(), false),
-                    FieldType::Predicate => ("predicate".to_string(), false),
-                    FieldType::Optional(ty) => (format!("optional[\"{}\"]", class_name(ty)), true),
-                    FieldType::List(ty) => (format!("list[\"{}\"]", class_name(ty)), true),
-                };
-                SchemaField {
-                    name: property_name(&node.name, &f.name),
-                    ty,
-                    child,
-                }
-            })
-            .collect(),
     }
 }
 
@@ -489,8 +490,8 @@ fn enum_to_extractor_info(node: &AstEnumSrc) -> Option<ExtractorEnumInfo> {
     })
 }
 
-fn field_info_to_extractor_info(node: &AstNodeSrc, field: &FieldInfo) -> ExtractorNodeFieldInfo {
+fn field_info_to_extractor_info(name: &str, field: &FieldInfo) -> ExtractorNodeFieldInfo {
-    let name = property_name(&node.name, &field.name);
+    let name = property_name(name, &field.name);
     match &field.ty {
         FieldType::String => ExtractorNodeFieldInfo {
             name,
@@ -522,14 +523,16 @@ fn field_info_to_extractor_info(node: &AstNodeSrc, field: &FieldInfo) -> Extract
 fn node_to_extractor_info(node: &AstNodeSrc) -> ExtractorNodeInfo {
     let fields = get_fields(node);
     let has_attrs = fields.iter().any(|f| f.name == "attrs");
+    let name = class_name(&node.name);
+    let fields = fields
+        .iter()
+        .map(|f| field_info_to_extractor_info(&name, f))
+        .collect();
     ExtractorNodeInfo {
-        name: class_name(&node.name),
+        name,
         snake_case_name: to_lower_snake_case(&node.name),
         ast_name: node.name.clone(),
-        fields: fields
+        fields,
-            .iter()
-            .map(|f| field_info_to_extractor_info(node, f))
-            .collect(),
         has_attrs,
     }
 }