Update to latest generator

Includes better QLDoc generation and better escaping in the generated
files (the latter has changed the dbscheme, so rebuilding databases will
be required).

Author: tausbn

extractor/src/extractor.rs

@@ -560,6 +560,7 @@ impl Visitor<'_> {
                 Storage::Table {
                     name: table_name,
                     has_index,
+                    column_name: _,
                 } => {
                     for (index, child_value) in child_values.iter().enumerate() {
                         if !*has_index && index > 0 {

generator/src/main.rs

@@ -66,6 +66,7 @@ fn make_field_type<'a>(
 fn add_field_for_table_storage<'a>(
     field: &'a node_types::Field,
     table_name: &'a str,
+    column_name: &'a str,
     has_index: bool,
     nodes: &'a node_types::NodeTypeMap,
 ) -> (dbscheme::Table<'a>, Option<dbscheme::Entry<'a>>) {
@@ -90,10 +91,7 @@ fn add_field_for_table_storage<'a>(
     let field_column = dbscheme::Column {
         unique: true,
         db_type: dbscheme::DbColumnType::Int,
-        name: match &field.name {
-            None => "child",
-            Some(name) => name,
-        },
+        name: column_name,
         ql_type: field_ql_type,
         ql_type_is_ref: true,
     };
@@ -205,9 +203,18 @@ fn convert_nodes<'a>(nodes: &'a node_types::NodeTypeMap) -> Vec<dbscheme::Entry<
                             }
                             main_table.columns.push(field_column);
                         }
-                        node_types::Storage::Table { name, has_index } => {
-                            let (field_table, field_type_entry) =
-                                add_field_for_table_storage(field, name, *has_index, nodes);
+                        node_types::Storage::Table {
+                            name,
+                            has_index,
+                            column_name,
+                        } => {
+                            let (field_table, field_type_entry) = add_field_for_table_storage(
+                                field,
+                                name,
+                                column_name,
+                                *has_index,
+                                nodes,
+                            );
                             if let Some(field_type_entry) = field_type_entry {
                                 entries.push(field_type_entry);
                             }

generator/src/ql_gen.rs

@@ -398,6 +398,7 @@ fn create_field_getters<'a>(
         node_types::Storage::Table {
             name: field_table_name,
             has_index,
+            column_name: _,
         } => (
             create_get_field_expr_for_table_storage(
                 get_value_result_var_name,
@@ -450,12 +451,21 @@ fn create_field_getters<'a>(
             (get_value, Some(get_value_any_index))
         }
     };
+    let qldoc = match &field.name {
+        Some(name) => {
+            format!("Gets the node corresponding to the field `{}`.", name)
+        }
+        None => {
+            if formal_parameters.len() == 0 {
+                "Gets the child of this node.".to_owned()
+            } else {
+                "Gets the `i`th child of this node.".to_owned()
+            }
+        }
+    };
     (
         ql::Predicate {
-            qldoc: field
-                .name
-                .as_ref()
-                .map(|name| format!("Gets the node corresponding to the field `{}`.", name)),
+            qldoc: Some(qldoc),
             name: &field.getter_name,
             overridden: false,
             return_type,

node-types/src/lib.rs

@@ -70,9 +70,15 @@ fn name_for_field_or_child(name: &Option<String>) -> String {
 pub enum Storage {
     /// the field is stored as a column in the parent table
     Column { name: String },
-    /// the field is stored in a link table, and may or may not have an
-    /// associated index column
-    Table { name: String, has_index: bool },
+    /// the field is stored in a link table
+    Table {
+        /// the name of the table
+        name: String,
+        /// the name of the column for the field in the dbscheme
+        column_name: String,
+        /// does it have an associated index column?
+        has_index: bool,
+    },
 }
 
 pub fn read_node_types(node_types_path: &Path) -> std::io::Result<NodeTypeMap> {
@@ -206,12 +212,11 @@ fn add_field(
     token_kinds: &Set<TypeName>,
 ) {
     let parent_flattened_name = node_type_name(&parent_type_name.kind, parent_type_name.named);
+    let column_name = escape_name(&name_for_field_or_child(&field_name));
     let storage = if !field_info.multiple && field_info.required {
         // This field must appear exactly once, so we add it as
         // a column to the main table for the node type.
-        Storage::Column {
-            name: escape_name(&name_for_field_or_child(&field_name)),
-        }
+        Storage::Column { name: column_name }
     } else {
         // Put the field in an auxiliary table.
         let has_index = field_info.multiple;
@@ -223,6 +228,7 @@ fn add_field(
         Storage::Table {
             has_index,
             name: field_table_name,
+            column_name,
         }
     };
     let converted_types = convert_types(&field_info.types);