Shared: Generate final tree-sitter classes

Author: hvitved

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

@@ -120,14 +120,20 @@ pub fn generate(
         )));
         dbscheme::write(&mut dbscheme_writer, &dbscheme_tail)?;
 
-        let mut body = vec![
-            ql::TopLevel::Class(ql_gen::create_ast_node_class(
-                &ast_node_name,
-                &node_location_table_name,
-                &node_parent_table_name,
-            )),
-            ql::TopLevel::Class(ql_gen::create_token_class(&token_name, &tokeninfo_name)),
-        ];
+        let mut body = vec![];
+
+        for c in 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));
+        }
+
         if has_trivia_tokens {
             body.push(ql::TopLevel::Class(ql_gen::create_trivia_token_class(
                 &trivia_token_name,

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

@@ -40,16 +40,29 @@ pub struct Class<'a> {
     pub qldoc: Option<String>,
     pub name: &'a str,
     pub is_abstract: bool,
+    pub is_final: bool,
+    pub is_private: bool,
     pub supertypes: BTreeSet<Type<'a>>,
     pub characteristic_predicate: Option<Expression<'a>>,
     pub predicates: Vec<Predicate<'a>>,
+    pub alias: Option<String>,
 }
 
 impl fmt::Display for Class<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if let Some(qldoc) = &self.qldoc {
             write!(f, "/** {qldoc} */")?;
         }
+        if self.is_final {
+            write!(f, "final ")?;
+        }
+        if self.is_private {
+            write!(f, "private ")?;
+        }
+        if let Some(alias) = &self.alias {
+            write!(f, "class {} = {alias} ;", &self.name)?;
+            return Ok(());
+        }
         if self.is_abstract {
             write!(f, "abstract ")?;
         }

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> {
+) -> [ql::Class<'a>; 2] {
     // Default implementation of `toString` calls `this.getAPrimaryQlClass()`
     let to_string = ql::Predicate {
         qldoc: Some(String::from(
@@ -132,25 +132,41 @@ pub fn create_ast_node_class<'a>(
         ),
         overlay: None,
     };
-    ql::Class {
-        qldoc: Some(String::from("The base class for all AST nodes")),
-        name: "AstNode",
-        is_abstract: false,
-        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: 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![],
+        },
+    ]
 }
 
-pub fn create_token_class<'a>(token_type: &'a str, tokeninfo: &'a str) -> ql::Class<'a> {
+pub fn create_token_class<'a>(token_type: &'a str, tokeninfo: &'a str) -> [ql::Class<'a>; 2] {
     let tokeninfo_arity = 3; // id, kind, value
     let get_value = ql::Predicate {
         qldoc: Some(String::from("Gets the value of this token.")),
@@ -183,20 +199,36 @@ pub fn create_token_class<'a>(token_type: &'a str, tokeninfo: &'a str) -> ql::Cl
         ),
         overlay: None,
     };
-    ql::Class {
-        qldoc: Some(String::from("A token.")),
-        name: "Token",
-        is_abstract: false,
-        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),
-        ],
-    }
+    [
+        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![],
+        },
+    ]
 }
 
 /// Creates the `TriviaToken` class. Trivia tokens (e.g. comments) are
@@ -251,9 +283,15 @@ pub fn create_trivia_token_class<'a>(
         )),
         name: "TriviaToken",
         is_abstract: false,
-        supertypes: vec![ql::Type::At(trivia_token_type), ql::Type::Normal("AstNode")]
-            .into_iter()
-            .collect(),
+        is_final: true,
+        is_private: false,
+        alias: None,
+        supertypes: vec![
+            ql::Type::At(trivia_token_type),
+            ql::Type::Normal("AstNodeImpl"),
+        ]
+        .into_iter()
+        .collect(),
         characteristic_predicate: None,
         predicates: vec![
             get_value,
@@ -271,7 +309,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,
-        supertypes: vec![ql::Type::At(db_name), ql::Type::Normal("Token")]
+        is_final: true,
+        is_private: false,
+        alias: None,
+        supertypes: vec![ql::Type::At(db_name), ql::Type::Normal("TokenImpl")]
             .into_iter()
             .collect(),
         characteristic_predicate: None,
@@ -775,11 +816,14 @@ 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("Token"));
+                    supertypes.insert(ql::Type::Normal("TokenImpl"));
                     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_private: false,
+                        alias: None,
                         supertypes,
                         characteristic_predicate: None,
                         predicates: vec![get_a_primary_ql_class],
@@ -793,9 +837,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_private: false,
+                    alias: None,
                     supertypes: vec![
                         ql::Type::At(&node.dbscheme_name),
-                        ql::Type::Normal("AstNode"),
+                        ql::Type::Normal("AstNodeImpl"),
                     ]
                     .into_iter()
                     .collect(),
@@ -824,9 +871,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_private: false,
+                    alias: None,
                     supertypes: vec![
                         ql::Type::At(&node.dbscheme_name),
-                        ql::Type::Normal("AstNode"),
+                        ql::Type::Normal("AstNodeImpl"),
                     ]
                     .into_iter()
                     .collect(),