Codegen: Add Raw::getImmediateChild and Synth::isSynth

Author: hvitved

misc/codegen/templates/ql_db.mustache

@@ -29,9 +29,70 @@ module Raw {
     {{type}} {{getter}}({{#is_indexed}}int index{{/is_indexed}}) {
       {{tablename}}({{#tableparams}}{{^first}}, {{/first}}{{param}}{{/tableparams}})
     }
+    {{#is_indexed}}
+    int getNumberOf{{plural}}() {
+      result = count(int i | {{tablename}}(this, i, _))
+    }
+    {{/is_indexed}}
     {{/synth}}
     {{/properties}}
   }
 
+
+  {{#final}}
+  private Element getImmediateChildOf{{name}}({{name}} e, int index) {
+    {{^has_children}}none(){{/has_children}}
+    {{#has_children}}
+    {{! n is the base offset 0, for ease of generation }}
+    {{! n<child> is constructed to be strictly greater than the indexes for <child> children }}
+        exists(int n{{#all_children}}, int n{{property.singular}}{{/all_children}} |
+            n = 0
+            {{#all_children}}
+                {{#property}}
+                {{#synth}}
+                       and
+                       n{{singular}} = n{{prev}}
+                {{/synth}}
+                {{^synth}}
+                    {{! n<child> is defined on top of the previous definition }}
+                    {{! for single and optional properties it adds 1 (regardless of whether the optional property exists) }}
+                    {{! for repeated it adds 1 + the maximum index (which works for repeated optional as well) }}
+                        and
+                        n{{singular}} = n{{prev}} {{^is_repeated}}+ 1{{/is_repeated}}{{#is_repeated}}+ e.getNumberOf{{plural}}(){{/is_repeated}}
+                {{/synth}}
+                {{/property}}
+            {{/all_children}} and (
+        none()
+        {{#all_children}}
+            {{#property}}
+            {{^synth}}
+                or
+                {{#is_repeated}}
+                    result = e.get{{singular}}(index - n{{prev}})
+                {{/is_repeated}}
+                {{^is_repeated}}
+                    index = n{{prev}} and result = e.get{{singular}}()
+                {{/is_repeated}}
+            {{/synth}}
+            {{/property}}
+        {{/all_children}}
+        ))
+    {{/has_children}}
+    }
+    {{/final}}
+
   {{/classes}}
+
+  pragma[nomagic]
+  Element getImmediateChild(Element e, int index) {
+  // why does this look more complicated than it should?
+  // * none() simplifies generation, as we can append `or ...` without a special case for the first item
+  none()
+  {{#classes}}
+      {{#final}}
+          or
+          result = getImmediateChildOf{{name}}(e, index)
+      {{/final}}
+  {{/classes}}
+  }
 }

misc/codegen/templates/ql_parent.mustache

@@ -23,7 +23,7 @@ private module Impl {
                         {{! for single and optional properties it adds 1 (regardless of whether the optional property exists) }}
                         {{! for repeated it adds 1 + the maximum index (which works for repeated optional as well) }}
                             and
-                            n{{singular}} = n{{prev}} + 1{{#is_repeated}}+ max(int i | i = -1 or exists(e.get{{#type_is_hideable}}Immediate{{/type_is_hideable}}{{singular}}(i)) | i){{/is_repeated}}
+                            n{{singular}} = n{{prev}} {{^is_repeated}}+ 1{{/is_repeated}}{{#is_repeated}}+ {{#type_is_hideable}}max(int i | i = 0 or exists(e.getImmediate{{singular}}(i)) | i){{/type_is_hideable}}{{^type_is_hideable}}e.getNumberOf{{plural}}(){{/type_is_hideable}}{{/is_repeated}}
                     {{/property}}
                 {{/all_children}} and (
             none()

misc/codegen/templates/ql_synth_types.mustache

@@ -32,9 +32,25 @@ module Synth {
   {{/root}}
   {{/non_final_classes}}
 
+  /**
+   * INTERNAL: Do not use.
+   *
+   * Holds if `e` is synthetic, that is, `e` cannot be converted to a raw element.
+   */
+  predicate isSynth(T{{root}} e) {
+    none()
+    {{#final_classes}}
+    {{#is_fresh_synth}}
+    or
+    e instanceof T{{name}}
+    {{/is_fresh_synth}}
+    {{/final_classes}}
+  }
+
   {{#final_classes}}
   /**
    * INTERNAL: Do not use.
+   *
    * Converts a raw element to a synthesized `T{{name}}`, if possible.
    */
   T{{name}} convert{{name}}FromRaw(Raw::Element e) {