Rust: rename several entities to their more natural names

.pre-commit-config.yaml

@@ -72,7 +72,7 @@ repos:
 
       - id: rust-codegen
         name: Run Rust checked in code generation
-        files: ^misc/codegen/|^rust/(prefix\.dbscheme|schema/|codegen/|.*/generated/|ql/lib/(rust\.dbscheme$|codeql/rust/elements)|\.generated.list)
+        files: ^misc/codegen/|^rust/(prefix\.dbscheme|schema/|codegen/|.*/generated/|ql/lib/(rust\.dbscheme$|codeql/rust/elements)|\.generated.list|ast-generator/)
         language: system
         entry: bazel run //rust/codegen -- --quiet
         pass_filenames: false

rust/ast-generator/src/main.rs

@@ -23,9 +23,7 @@ fn class_name(type_name: &str) -> String {
         "Literal" => "LiteralExpr".to_owned(),
         "ArrayExpr" => "ArrayExprInternal".to_owned(),
         "AsmOptions" => "AsmOptionsList".to_owned(),
-        _ if type_name.starts_with("Record") && type_name != "RecordFieldList" => {
-            type_name.replacen("Record", "Struct", 1)
-        }
+        _ if type_name.starts_with("Record") => type_name.replacen("Record", "Struct", 1),
         _ if type_name.ends_with("Type") => format!("{}Repr", type_name),
         _ => type_name.to_owned(),
     }
@@ -36,10 +34,14 @@ fn property_name(type_name: &str, field_name: &str) -> String {
         ("CallExpr", "expr") => "function",
         ("LetExpr", "expr") => "scrutinee",
         ("MatchExpr", "expr") => "scrutinee",
+        ("Variant", "expr") => "discriminant",
+        ("FieldExpr", "expr") => "container",
+        (_, "name_ref") => "identifier",
         (_, "then_branch") => "then",
         (_, "else_branch") => "else_",
-        ("ArrayType", "ty") => "element_type_repr",
+        ("ArrayTypeRepr", "ty") => "element_type_repr",
         ("SelfParam", "is_amp") => "is_ref",
+        ("StructField", "expr") => "default",
         ("UseTree", "is_star") => "is_glob",
         (_, "ty") => "type_repr",
         _ if field_name.contains("record") => &field_name.replacen("record", "struct", 1),
@@ -103,25 +105,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(),
     }
 }
 
@@ -428,6 +432,7 @@ fn get_fields(node: &AstNodeSrc) -> Vec<FieldInfo> {
 struct EnumVariantInfo {
     name: String,
     snake_case_name: String,
+    variant_ast_name: String,
 }
 
 #[derive(Serialize)]
@@ -476,16 +481,21 @@ fn enum_to_extractor_info(node: &AstEnumSrc) -> Option<ExtractorEnumInfo> {
         variants: node
             .variants
             .iter()
-            .map(|v| EnumVariantInfo {
-                name: v.clone(),
-                snake_case_name: to_lower_snake_case(v),
+            .map(|v| {
+                let name = class_name(v);
+                let snake_case_name = to_lower_snake_case(v);
+                EnumVariantInfo {
+                    name,
+                    snake_case_name,
+                    variant_ast_name: v.clone(),
+                }
             })
             .collect(),
     })
 }
 
-fn field_info_to_extractor_info(node: &AstNodeSrc, field: &FieldInfo) -> ExtractorNodeFieldInfo {
-    let name = property_name(&node.name, &field.name);
+fn field_info_to_extractor_info(name: &str, field: &FieldInfo) -> ExtractorNodeFieldInfo {
+    let name = property_name(name, &field.name);
     match &field.ty {
         FieldType::String => ExtractorNodeFieldInfo {
             name,
@@ -517,14 +527,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
-            .iter()
-            .map(|f| field_info_to_extractor_info(node, f))
-            .collect(),
+        fields,
         has_attrs,
     }
 }

rust/ast-generator/src/templates/extractor.mustache

@@ -25,7 +25,7 @@ impl Translator<'_> {
     pub(crate) fn emit_{{snake_case_name}}(&mut self, node: ast::{{ast_name}}) -> Option<Label<generated::{{name}}>> {
         match node {
             {{#variants}}
-            ast::{{ast_name}}::{{name}}(inner) => self.emit_{{snake_case_name}}(inner).map(Into::into),
+            ast::{{ast_name}}::{{variant_ast_name}}(inner) => self.emit_{{snake_case_name}}(inner).map(Into::into),
             {{/variants}}
         }
     }

rust/extractor/src/crate_graph.rs

@@ -476,7 +476,7 @@ fn emit_adt(
                         name,
                         field_list,
                         attrs: vec![],
-                        expr: None,
+                        discriminant: None,
                         visibility,
                     })
                 })
@@ -1000,14 +1000,14 @@ fn make_qualified_path(
         qualifier: Option<trap::Label<generated::Path>>,
         name: String,
     ) -> trap::Label<generated::Path> {
-        let name_ref = Some(trap.emit(generated::NameRef {
+        let identifier = Some(trap.emit(generated::NameRef {
             id: trap::TrapId::Star,
             text: Some(name),
         }));
         let segment = Some(trap.emit(generated::PathSegment {
             id: trap::TrapId::Star,
             generic_arg_list: None,
-            name_ref,
+            identifier,
             parenthesized_arg_list: None,
             ret_type: None,
             return_type_syntax: None,
@@ -1253,11 +1253,11 @@ fn emit_hir_ty(
 
 enum Variant {
     Unit,
-    Record(trap::Label<generated::RecordFieldList>),
+    Record(trap::Label<generated::StructFieldList>),
     Tuple(trap::Label<generated::TupleFieldList>),
 }
 
-impl From<Variant> for Option<trap::Label<generated::RecordFieldList>> {
+impl From<Variant> for Option<trap::Label<generated::StructFieldList>> {
     fn from(val: Variant) -> Self {
         match val {
             Variant::Record(label) => Some(label),
@@ -1305,11 +1305,11 @@ fn emit_variant_data(trap: &mut TrapFile, db: &dyn HirDatabase, variant_id: Vari
                         name,
                         type_repr,
                         visibility,
-                        expr: None,
+                        default: None,
                     })
                 })
                 .collect();
-            Variant::Record(trap.emit(generated::RecordFieldList {
+            Variant::Record(trap.emit(generated::StructFieldList {
                 id: trap::TrapId::Star,
                 fields,
             }))