tree-sitter-extractor: Move final aliases into sibling module

The split between private, non-final Impl classes and public final classes ultimately prevented the facade AST from instrumenting base classes like 'Expr' and have its subclasses actually inherit those members.

This commit takes a step towards fixing that by moving the final aliases into a separate module and making the other classes public and stripping their Impl suffix. It is up to each language to avoid leaking the non-final classes (which Ruby and QL4QL don't do anyway).

Author: asgerf

shared/tree-sitter-extractor/src/generator/mod.rs

@@ -135,17 +135,16 @@ pub fn generate(
             alias: Some("F"),
         }));
 
-        for c in ql_gen::create_ast_node_class(
+        body.push(ql::TopLevel::Class(ql_gen::create_ast_node_class(
             &ast_node_name,
             &node_location_table_name,
             &node_parent_table_name,
-        ) {
-            body.push(ql::TopLevel::Class(c));
-        }
+        )));
 
-        for c in ql_gen::create_token_class(&token_name, &tokeninfo_name) {
-            body.push(ql::TopLevel::Class(c));
-        }
+        body.push(ql::TopLevel::Class(ql_gen::create_token_class(
+            &token_name,
+            &tokeninfo_name,
+        )));
 
         if has_trivia_tokens {
             body.push(ql::TopLevel::Class(ql_gen::create_trivia_token_class(
@@ -179,14 +178,53 @@ pub fn generate(
 
         body.append(&mut ql_gen::convert_nodes(&nodes));
         body.push(ql_gen::create_print_ast_module(&nodes));
+        let mut final_body = vec![
+            ql::TopLevel::Import(ql::Import {
+                is_private: true,
+                module: &facade_import_name,
+                alias: Some("F"),
+            }),
+            ql::TopLevel::Import(ql::Import {
+                is_private: false,
+                module: "F",
+                alias: None,
+            }),
+        ];
+        let final_aliases = body
+            .iter()
+            .filter_map(|decl| match decl {
+                ql::TopLevel::Class(c) => Some(ql::TopLevel::Class(ql::Class {
+                    qldoc: None,
+                    name: c.name,
+                    is_abstract: false,
+                    is_final: true,
+                    is_private: false,
+                    supertypes: Set::new(),
+                    characteristic_predicate: None,
+                    predicates: vec![],
+                    alias: Some(format!("F::{}", c.name)),
+                })),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+        final_body.extend(final_aliases);
+        let final_module_name = format!("{}Final", language.name);
         ql::write(
             &mut ql_writer,
-            &[ql::TopLevel::Module(ql::Module {
-                qldoc: None,
-                name: &language.name,
-                body,
-                overlay: Some(ql::OverlayAnnotation::Local),
-            })],
+            &[
+                ql::TopLevel::Module(ql::Module {
+                    qldoc: None,
+                    name: &language.name,
+                    body,
+                    overlay: Some(ql::OverlayAnnotation::Local),
+                }),
+                ql::TopLevel::Module(ql::Module {
+                    qldoc: None,
+                    name: &final_module_name,
+                    body: final_body,
+                    overlay: None,
+                }),
+            ],
         )?;
     }
     Ok(())

shared/tree-sitter-extractor/src/generator/ql_gen.rs

@@ -8,7 +8,7 @@ pub fn create_ast_node_class<'a>(
     ast_node: &'a str,
     node_location_table: &'a str,
     node_parent_table: &'a str,
-) -> [ql::Class<'a>; 2] {
+) -> ql::Class<'a> {
     // Default implementation of `toString` calls `this.getAPrimaryQlClass()`
     let to_string = ql::Predicate {
         qldoc: Some(String::from(
@@ -132,41 +132,28 @@ pub fn create_ast_node_class<'a>(
         ),
         overlay: None,
     };
-    [
-        ql::Class {
-            qldoc: Some(String::from("The base class for all AST nodes")),
-            name: "AstNodeImpl",
-            is_abstract: false,
-            is_final: false,
-            is_private: true,
-            alias: None,
-            supertypes: vec![ql::Type::At(ast_node)].into_iter().collect(),
-            characteristic_predicate: None,
-            predicates: vec![
-                to_string,
-                get_location,
-                get_parent,
-                get_parent_index,
-                get_a_field_or_child,
-                get_a_primary_ql_class,
-                get_primary_ql_classes,
-            ],
-        },
-        ql::Class {
-            qldoc: None,
-            name: "AstNode",
-            is_abstract: false,
-            is_final: true,
-            is_private: false,
-            alias: Some("AstNodeImpl".to_string()),
-            supertypes: vec![].into_iter().collect(),
-            characteristic_predicate: None,
-            predicates: vec![],
-        },
-    ]
+    ql::Class {
+        qldoc: Some(String::from("The base class for all AST nodes")),
+        name: "AstNode",
+        is_abstract: false,
+        is_final: false,
+        is_private: false,
+        alias: None,
+        supertypes: vec![ql::Type::At(ast_node)].into_iter().collect(),
+        characteristic_predicate: None,
+        predicates: vec![
+            to_string,
+            get_location,
+            get_parent,
+            get_parent_index,
+            get_a_field_or_child,
+            get_a_primary_ql_class,
+            get_primary_ql_classes,
+        ],
+    }
 }
 
-pub fn create_token_class<'a>(token_type: &'a str, tokeninfo: &'a str) -> [ql::Class<'a>; 2] {
+pub fn create_token_class<'a>(token_type: &'a str, tokeninfo: &'a str) -> ql::Class<'a> {
     let tokeninfo_arity = 3; // id, kind, value
     let get_value = ql::Predicate {
         qldoc: Some(String::from("Gets the value of this token.")),
@@ -199,36 +186,23 @@ pub fn create_token_class<'a>(token_type: &'a str, tokeninfo: &'a str) -> [ql::C
         ),
         overlay: None,
     };
-    [
-        ql::Class {
-            qldoc: Some(String::from("A token.")),
-            name: "TokenImpl",
-            is_abstract: false,
-            is_final: false,
-            is_private: true,
-            alias: None,
-            supertypes: vec![ql::Type::At(token_type), ql::Type::Normal("AstNodeImpl")]
-                .into_iter()
-                .collect(),
-            characteristic_predicate: None,
-            predicates: vec![
-                get_value,
-                to_string,
-                create_get_a_primary_ql_class("Token", false),
-            ],
-        },
-        ql::Class {
-            qldoc: None,
-            name: "Token",
-            is_abstract: false,
-            is_final: true,
-            is_private: false,
-            alias: Some("TokenImpl".to_string()),
-            supertypes: vec![].into_iter().collect(),
-            characteristic_predicate: None,
-            predicates: vec![],
-        },
-    ]
+    ql::Class {
+        qldoc: Some(String::from("A token.")),
+        name: "Token",
+        is_abstract: false,
+        is_final: false,
+        is_private: false,
+        alias: None,
+        supertypes: vec![ql::Type::At(token_type), ql::Type::Normal("AstNode")]
+            .into_iter()
+            .collect(),
+        characteristic_predicate: None,
+        predicates: vec![
+            get_value,
+            to_string,
+            create_get_a_primary_ql_class("Token", false),
+        ],
+    }
 }
 
 /// Creates the `TriviaToken` class. Trivia tokens (e.g. comments) are
@@ -283,12 +257,12 @@ pub fn create_trivia_token_class<'a>(
         )),
         name: "TriviaToken",
         is_abstract: false,
-        is_final: true,
+        is_final: false,
         is_private: false,
         alias: None,
         supertypes: vec![
             ql::Type::At(trivia_token_type),
-            ql::Type::Normal("AstNodeImpl"),
+            ql::Type::Normal("AstNode"),
         ]
         .into_iter()
         .collect(),
@@ -309,10 +283,10 @@ pub fn create_reserved_word_class(db_name: &str) -> ql::Class<'_> {
         qldoc: Some(String::from("A reserved word.")),
         name: class_name,
         is_abstract: false,
-        is_final: true,
+        is_final: false,
         is_private: false,
         alias: None,
-        supertypes: vec![ql::Type::At(db_name), ql::Type::Normal("TokenImpl")]
+        supertypes: vec![ql::Type::At(db_name), ql::Type::Normal("Token")]
             .into_iter()
             .collect(),
         characteristic_predicate: None,
@@ -816,12 +790,12 @@ pub fn convert_nodes(nodes: &node_types::NodeTypeMap) -> Vec<ql::TopLevel<'_>> {
                         create_get_a_primary_ql_class(&node.ql_class_name, true);
                     let mut supertypes: BTreeSet<ql::Type> = BTreeSet::new();
                     supertypes.insert(ql::Type::At(&node.dbscheme_name));
-                    supertypes.insert(ql::Type::Normal("TokenImpl"));
+                    supertypes.insert(ql::Type::Normal("Token"));
                     classes.push(ql::TopLevel::Class(ql::Class {
                         qldoc: Some(format!("A class representing `{}` tokens.", type_name.kind)),
                         name: &node.ql_class_name,
                         is_abstract: false,
-                        is_final: true,
+                        is_final: false,
                         is_private: false,
                         alias: None,
                         supertypes,
@@ -837,12 +811,12 @@ pub fn convert_nodes(nodes: &node_types::NodeTypeMap) -> Vec<ql::TopLevel<'_>> {
                     qldoc: None,
                     name: &node.ql_class_name,
                     is_abstract: false,
-                    is_final: true,
+                    is_final: false,
                     is_private: false,
                     alias: None,
                     supertypes: vec![
                         ql::Type::At(&node.dbscheme_name),
-                        ql::Type::Normal("AstNodeImpl"),
+                        ql::Type::Normal("AstNode"),
                     ]
                     .into_iter()
                     .collect(),
@@ -871,12 +845,12 @@ pub fn convert_nodes(nodes: &node_types::NodeTypeMap) -> Vec<ql::TopLevel<'_>> {
                     qldoc: Some(format!("A class representing `{}` nodes.", type_name.kind)),
                     name: main_class_name,
                     is_abstract: false,
-                    is_final: true,
+                    is_final: false,
                     is_private: false,
                     alias: None,
                     supertypes: vec![
                         ql::Type::At(&node.dbscheme_name),
-                        ql::Type::Normal("AstNodeImpl"),
+                        ql::Type::Normal("AstNode"),
                     ]
                     .into_iter()
                     .collect(),