Merge pull request github#7880 from github/nickrolfe/locations_column_ql

QL for QL: sync changes from Ruby

Author: nickrolfe

ql/extractor/src/extractor.rs

@@ -402,11 +402,12 @@ impl Visitor<'_> {
         match &table.kind {
             EntryKind::Token { kind_id, .. } => {
                 self.trap_writer.add_tuple(
-                    &format!("{}_ast_node_parent", self.language_prefix),
+                    &format!("{}_ast_node_info", self.language_prefix),
                     vec![
                         Arg::Label(id),
                         Arg::Label(parent_id),
                         Arg::Int(parent_index),
+                        Arg::Label(loc),
                     ],
                 );
                 self.trap_writer.add_tuple(
@@ -415,7 +416,6 @@ impl Visitor<'_> {
                         Arg::Label(id),
                         Arg::Int(*kind_id),
                         sliced_source_arg(self.source, node),
-                        Arg::Label(loc),
                     ],
                 );
             }
@@ -425,16 +425,16 @@ impl Visitor<'_> {
             } => {
                 if let Some(args) = self.complex_node(&node, fields, &child_nodes, id) {
                     self.trap_writer.add_tuple(
-                        &format!("{}_ast_node_parent", self.language_prefix),
+                        &format!("{}_ast_node_info", self.language_prefix),
                         vec![
                             Arg::Label(id),
                             Arg::Label(parent_id),
                             Arg::Int(parent_index),
+                            Arg::Label(loc),
                         ],
                     );
                     let mut all_args = vec![Arg::Label(id)];
                     all_args.extend(args);
-                    all_args.push(Arg::Label(loc));
                     self.trap_writer.add_tuple(table_name, all_args);
                 }
             }

ql/generator/src/main.rs

@@ -232,15 +232,6 @@ fn convert_nodes(
                     });
                 }
 
-                // Finally, the type's defining table also includes the location.
-                main_table.columns.push(dbscheme::Column {
-                    unique: false,
-                    db_type: dbscheme::DbColumnType::Int,
-                    name: "loc",
-                    ql_type: ql::Type::At("location"),
-                    ql_type_is_ref: true,
-                });
-
                 entries.push(dbscheme::Entry::Table(main_table));
             }
             node_types::EntryKind::Token { .. } => {}
@@ -250,18 +241,24 @@ fn convert_nodes(
     (entries, ast_node_members, token_kinds)
 }
 
-/// Creates a dbscheme table entry representing the parent relation for AST nodes.
+/// Creates a dbscheme table specifying the parent node and location for each
+/// AST node.
 ///
 /// # Arguments
-/// - `name` - the name of both the table to create and the node parent type.
+/// - `name` - the name of the table to create.
+/// - `parent_name` - the name of the parent type.
 /// - `ast_node_name` - the name of the node child type.
-fn create_ast_node_parent_table<'a>(name: &'a str, ast_node_name: &'a str) -> dbscheme::Table<'a> {
+fn create_ast_node_info_table<'a>(
+    name: &'a str,
+    parent_name: &'a str,
+    ast_node_name: &'a str,
+) -> dbscheme::Table<'a> {
     dbscheme::Table {
         name,
         columns: vec![
             dbscheme::Column {
                 db_type: dbscheme::DbColumnType::Int,
-                name: "child",
+                name: "node",
                 unique: false,
                 ql_type: ql::Type::At(ast_node_name),
                 ql_type_is_ref: true,
@@ -270,7 +267,7 @@ fn create_ast_node_parent_table<'a>(name: &'a str, ast_node_name: &'a str) -> db
                 db_type: dbscheme::DbColumnType::Int,
                 name: "parent",
                 unique: false,
-                ql_type: ql::Type::At(name),
+                ql_type: ql::Type::At(parent_name),
                 ql_type_is_ref: true,
             },
             dbscheme::Column {
@@ -280,6 +277,13 @@ fn create_ast_node_parent_table<'a>(name: &'a str, ast_node_name: &'a str) -> db
                 ql_type: ql::Type::Int,
                 ql_type_is_ref: true,
             },
+            dbscheme::Column {
+                unique: false,
+                db_type: dbscheme::DbColumnType::Int,
+                name: "loc",
+                ql_type: ql::Type::At("location"),
+                ql_type_is_ref: true,
+            },
         ],
         keysets: Some(vec!["parent", "parent_index"]),
     }
@@ -311,13 +315,6 @@ fn create_tokeninfo<'a>(name: &'a str, type_name: &'a str) -> dbscheme::Table<'a
                 ql_type: ql::Type::String,
                 ql_type_is_ref: true,
             },
-            dbscheme::Column {
-                unique: false,
-                db_type: dbscheme::DbColumnType::Int,
-                name: "loc",
-                ql_type: ql::Type::At("location"),
-                ql_type_is_ref: true,
-            },
         ],
     }
 }
@@ -605,15 +602,16 @@ fn main() -> std::io::Result<()> {
     )?;
     ql::write(
         &mut ql_writer,
-        &[
-            ql::TopLevel::Import("codeql.files.FileSystem"),
-            ql::TopLevel::Import("codeql.Locations"),
-        ],
+        &[ql::TopLevel::Import(ql::Import {
+            module: "codeql.Locations",
+            alias: Some("L"),
+        })],
     )?;
 
     for language in languages {
         let prefix = node_types::to_snake_case(&language.name);
         let ast_node_name = format!("{}_ast_node", &prefix);
+        let node_info_table_name = format!("{}_ast_node_info", &prefix);
         let ast_node_parent_name = format!("{}_ast_node_parent", &prefix);
         let token_name = format!("{}_token", &prefix);
         let tokeninfo_name = format!("{}_tokeninfo", &prefix);
@@ -636,7 +634,8 @@ fn main() -> std::io::Result<()> {
                     name: &ast_node_parent_name,
                     members: [&ast_node_name, "file"].iter().cloned().collect(),
                 }),
-                dbscheme::Entry::Table(create_ast_node_parent_table(
+                dbscheme::Entry::Table(create_ast_node_info_table(
+                    &node_info_table_name,
                     &ast_node_parent_name,
                     &ast_node_name,
                 )),
@@ -646,7 +645,7 @@ fn main() -> std::io::Result<()> {
         let mut body = vec![
             ql::TopLevel::Class(ql_gen::create_ast_node_class(
                 &ast_node_name,
-                &ast_node_parent_name,
+                &node_info_table_name,
             )),
             ql::TopLevel::Class(ql_gen::create_token_class(&token_name, &tokeninfo_name)),
             ql::TopLevel::Class(ql_gen::create_reserved_word_class(&reserved_word_name)),

ql/generator/src/ql.rs

@@ -4,20 +4,35 @@ use std::fmt;
 #[derive(Clone, Eq, PartialEq, Hash)]
 pub enum TopLevel<'a> {
     Class(Class<'a>),
-    Import(&'a str),
+    Import(Import<'a>),
     Module(Module<'a>),
 }
 
 impl<'a> fmt::Display for TopLevel<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            TopLevel::Import(x) => write!(f, "private import {}", x),
+            TopLevel::Import(imp) => write!(f, "{}", imp),
             TopLevel::Class(cls) => write!(f, "{}", cls),
             TopLevel::Module(m) => write!(f, "{}", m),
         }
     }
 }
 
+#[derive(Clone, Eq, PartialEq, Hash)]
+pub struct Import<'a> {
+    pub module: &'a str,
+    pub alias: Option<&'a str>,
+}
+
+impl<'a> fmt::Display for Import<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "import {}", &self.module)?;
+        if let Some(name) = &self.alias {
+            write!(f, " as {}", name)?;
+        }
+        Ok(())
+    }
+}
 #[derive(Clone, Eq, PartialEq, Hash)]
 pub struct Class<'a> {
     pub qldoc: Option<String>,
@@ -53,6 +68,7 @@ impl<'a> fmt::Display for Class<'a> {
                     qldoc: None,
                     name: self.name,
                     overridden: false,
+                    is_final: false,
                     return_type: None,
                     formal_parameters: vec![],
                     body: charpred.clone(),
@@ -224,6 +240,7 @@ pub struct Predicate<'a> {
     pub qldoc: Option<String>,
     pub name: &'a str,
     pub overridden: bool,
+    pub is_final: bool,
     pub return_type: Option<Type<'a>>,
     pub formal_parameters: Vec<FormalParameter<'a>>,
     pub body: Expression<'a>,
@@ -234,6 +251,9 @@ impl<'a> fmt::Display for Predicate<'a> {
         if let Some(qldoc) = &self.qldoc {
             write!(f, "/** {} */", qldoc)?;
         }
+        if self.is_final {
+            write!(f, "final ")?;
+        }
         if self.overridden {
             write!(f, "override ")?;
         }