Upload 26 files

vendor/tree-sitter-ql/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "tree-sitter-ql"
+description = "ql grammar for the tree-sitter parsing library"
+version = "0.19.0"
+keywords = ["incremental", "parsing", "ql"]
+categories = ["parsing", "text-editors"]
+repository = "https://github.com/tree-sitter/tree-sitter-javascript"
+edition = "2018"
+license = "MIT"
+authors = ["Sam Lanning <[email protected]>"]
+
+build = "bindings/rust/build.rs"
+include = [
+  "bindings/rust/*",
+  "grammar.js",
+  "queries/*",
+  "src/*",
+]
+
+[lib]
+path = "bindings/rust/lib.rs"
+
+[dependencies]
+tree-sitter = ">= 0.20, < 0.21"
+
+[build-dependencies]
+cc = "1.0"

vendor/tree-sitter-ql/README.md

@@ -0,0 +1,5 @@
+# tree-sitter-ql
+
+[![Build Status](https://travis-ci.org/tree-sitter/tree-sitter-ql.svg?branch=master)](https://travis-ci.org/tree-sitter/tree-sitter-ql)
+
+tree-sitter grammar for GitHub CodeQL ([Language Spec](https://codeql.github.com/docs/ql-language-reference/ql-language-specification/))

vendor/tree-sitter-ql/bindings/node/binding.cc

@@ -0,0 +1,28 @@
+#include "tree_sitter/parser.h"
+#include <node.h>
+#include "nan.h"
+
+using namespace v8;
+
+extern "C" TSLanguage * tree_sitter_ql();
+
+namespace {
+
+NAN_METHOD(New) {}
+
+void Init(Local<Object> exports, Local<Object> module) {
+  Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(New);
+  tpl->SetClassName(Nan::New("Language").ToLocalChecked());
+  tpl->InstanceTemplate()->SetInternalFieldCount(1);
+
+  Local<Function> constructor = Nan::GetFunction(tpl).ToLocalChecked();
+  Local<Object> instance = constructor->NewInstance(Nan::GetCurrentContext()).ToLocalChecked();
+  Nan::SetInternalFieldPointer(instance, 0, tree_sitter_ql());
+
+  Nan::Set(instance, Nan::New("name").ToLocalChecked(), Nan::New("ql").ToLocalChecked());
+  Nan::Set(module, Nan::New("exports").ToLocalChecked(), instance);
+}
+
+NODE_MODULE(tree_sitter_ql_binding, Init)
+
+}  // namespace

vendor/tree-sitter-ql/bindings/node/index.js

@@ -0,0 +1,19 @@
+try {
+  module.exports = require("../../build/Release/tree_sitter_ql_binding");
+} catch (error1) {
+  if (error1.code !== 'MODULE_NOT_FOUND') {
+    throw error1;
+  }
+  try {
+    module.exports = require("../../build/Debug/tree_sitter_ql_binding");
+  } catch (error2) {
+    if (error2.code !== 'MODULE_NOT_FOUND') {
+      throw error2;
+    }
+    throw error1
+  }
+}
+
+try {
+  module.exports.nodeTypeInfo = require("../../src/node-types.json");
+} catch (_) {}

vendor/tree-sitter-ql/bindings/rust/build.rs

@@ -0,0 +1,40 @@
+fn main() {
+    let src_dir = std::path::Path::new("src");
+
+    let mut c_config = cc::Build::new();
+    c_config.include(&src_dir);
+    c_config
+        .flag_if_supported("-Wno-unused-parameter")
+        .flag_if_supported("-Wno-unused-but-set-variable")
+        .flag_if_supported("-Wno-trigraphs");
+    let parser_path = src_dir.join("parser.c");
+    c_config.file(&parser_path);
+
+    // If your language uses an external scanner written in C,
+    // then include this block of code:
+
+    /*
+    let scanner_path = src_dir.join("scanner.c");
+    c_config.file(&scanner_path);
+    println!("cargo:rerun-if-changed={}", scanner_path.to_str().unwrap());
+    */
+
+    c_config.compile("parser");
+    println!("cargo:rerun-if-changed={}", parser_path.to_str().unwrap());
+
+    // If your language uses an external scanner written in C++,
+    // then include this block of code:
+
+    /*
+    let mut cpp_config = cc::Build::new();
+    cpp_config.cpp(true);
+    cpp_config.include(&src_dir);
+    cpp_config
+        .flag_if_supported("-Wno-unused-parameter")
+        .flag_if_supported("-Wno-unused-but-set-variable");
+    let scanner_path = src_dir.join("scanner.cc");
+    cpp_config.file(&scanner_path);
+    cpp_config.compile("scanner");
+    println!("cargo:rerun-if-changed={}", scanner_path.to_str().unwrap());
+    */
+}

vendor/tree-sitter-ql/bindings/rust/lib.rs

@@ -0,0 +1,52 @@
+//! This crate provides ql language support for the [tree-sitter][] parsing library.
+//!
+//! Typically, you will use the [language][language func] function to add this language to a
+//! tree-sitter [Parser][], and then use the parser to parse some code:
+//!
+//! ```
+//! let code = "";
+//! let mut parser = tree_sitter::Parser::new();
+//! parser.set_language(tree_sitter_ql::language()).expect("Error loading ql grammar");
+//! let tree = parser.parse(code, None).unwrap();
+//! ```
+//!
+//! [Language]: https://docs.rs/tree-sitter/*/tree_sitter/struct.Language.html
+//! [language func]: fn.language.html
+//! [Parser]: https://docs.rs/tree-sitter/*/tree_sitter/struct.Parser.html
+//! [tree-sitter]: https://tree-sitter.github.io/
+
+use tree_sitter::Language;
+
+extern "C" {
+    fn tree_sitter_ql() -> Language;
+}
+
+/// Get the tree-sitter [Language][] for this grammar.
+///
+/// [Language]: https://docs.rs/tree-sitter/*/tree_sitter/struct.Language.html
+pub fn language() -> Language {
+    unsafe { tree_sitter_ql() }
+}
+
+/// The content of the [`node-types.json`][] file for this grammar.
+///
+/// [`node-types.json`]: https://tree-sitter.github.io/tree-sitter/using-parsers#static-node-types
+pub const NODE_TYPES: &'static str = include_str!("../../src/node-types.json");
+
+// Uncomment these to include any queries that this grammar contains
+
+pub const HIGHLIGHTS_QUERY: &'static str = include_str!("../../queries/highlights.scm");
+// pub const INJECTIONS_QUERY: &'static str = include_str!("../../queries/injections.scm");
+// pub const LOCALS_QUERY: &'static str = include_str!("../../queries/locals.scm");
+pub const TAGS_QUERY: &'static str = include_str!("../../queries/tags.scm");
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_can_load_grammar() {
+        let mut parser = tree_sitter::Parser::new();
+        parser
+            .set_language(super::language())
+            .expect("Error loading ql language");
+    }
+}

vendor/tree-sitter-ql/grammar.js

@@ -0,0 +1,471 @@
+module.exports = grammar({
+  name: 'ql',
+
+  conflicts: $ => [
+    [$.simpleId, $.className],
+    [$.simpleId, $.literalId],
+    [$.moduleName, $.varName],
+    [$.simpleId, $.moduleInstantiation],
+    [$.className, $.moduleInstantiation],
+  ],
+
+  extras: $ => [
+    /[ \t\r\n]/,
+    $.line_comment,
+    $.block_comment,
+  ],
+
+  word: $ => $._lower_id,
+
+  rules: {
+    ql: $ => repeat($.moduleMember),
+
+    module: $ => seq(
+      'module',
+      field("name", $.moduleName),
+      optional(
+        seq(
+          "<",
+          sep1(field('parameter', $.moduleParam), ","),
+          ">"
+        )
+      ),
+      optional(seq(
+        "implements",
+        sep1(field('implements', $.signatureExpr), ",")
+      )),
+      choice(
+        seq(
+          "{",
+          repeat($.moduleMember),
+          "}"
+        ),
+        $.moduleAliasBody
+      )
+    ),
+
+    moduleMember: $ => choice(
+      seq(
+        repeat($.annotation),
+        choice($.importDirective, $.classlessPredicate, $.dataclass, $.datatype, $.select, $.module)
+      ),
+      $.qldoc
+    ),
+
+    importDirective: $ => seq(
+      'import',
+      $.importModuleExpr,
+      optional(seq('as', $.moduleName))
+    ),
+
+    moduleAliasBody: $ => seq('=', $.moduleExpr, ";"),
+    predicateAliasBody: $ => seq('=', $.predicateExpr, ";"),
+    typeAliasBody: $ => seq('=', $.typeExpr, ";"),
+    typeUnionBody: $ => seq('=', $.typeExpr, "or", sep($.typeExpr, "or"), ";"),
+
+    classlessPredicate: $ => seq(
+      field("returnType", choice($.predicate, $.typeExpr)),
+      field("name", $.predicateName),
+      choice(
+        seq("(", sep($.varDecl, ","), ")", $._optbody),
+        $.predicateAliasBody
+      )
+    ),
+
+    datatype: $ => seq(
+      'newtype',
+      field("name", $.className),
+      '=',
+      $.datatypeBranches
+    ),
+
+    datatypeBranches: $ => sep1($.datatypeBranch, "or"),
+
+    datatypeBranch: $ => seq(
+      optional($.qldoc),
+      optional($.annotation),
+      field("name", $.className),
+      "(",
+      sep($.varDecl, ","),
+      ")",
+      optional($.body)
+    ),
+
+    select: $ => seq(
+      optional(seq("from", sep($.varDecl, ","))),
+      optional(seq("where", $._exprOrTerm)),
+      seq('select', $.asExprs, optional($.orderBys))
+    ),
+
+    dataclass: $ => seq(
+      'class',
+      field("name", $.className),
+      choice(
+        seq(
+          optional(field("extends", seq('extends', sep1($.typeExpr, ",")))),
+          optional(field("instanceof", seq('instanceof', sep1($.typeExpr, ",")))),
+          choice(
+            seq(
+              "{",
+              repeat($.classMember),
+              "}"
+            ),
+            ";"
+          )
+        ),
+        $.typeAliasBody,
+        $.typeUnionBody
+      )
+    ),
+
+    classMember: $ => choice(
+      seq(
+        repeat($.annotation),
+        choice($.charpred, $.memberPredicate, $.field)
+      ),
+      $.qldoc
+    ),
+
+    charpred: $ => seq($.className, "(", ")", "{", field('body', $._exprOrTerm), "}"),
+
+    memberPredicate: $ => seq(
+      field("returnType", choice($.predicate, $.typeExpr)),
+      field("name", $.predicateName),
+      "(",
+      sep($.varDecl, ","),
+      ")",
+      $._optbody
+    ),
+
+    field: $ => seq($.varDecl, ";"),
+
+    _optbody: $ => choice(
+      $.empty,
+      $.body,
+      $.higherOrderTerm
+    ),
+
+    empty: $ => ";",
+
+    body: $ => seq("{", $._exprOrTerm, "}"),
+
+    higherOrderTerm: $ => seq(
+      '=',
+      field("name", $.literalId),
+      "(",
+      sep($.predicateExpr, ","),
+      ")",
+      "(",
+      sep($._call_arg, ","),
+      ")"
+    ),
+
+    special_call: $ => seq($.specialId, "(", ")"),
+    prefix_cast: $ => prec.dynamic(10, seq("(", $.typeExpr, ")", $._exprOrTerm)),
+    unary_expr: $ => prec.left(9, seq($.unop, $._exprOrTerm)),
+    mul_expr: $ => prec.left(9, seq(
+      field('left', $._exprOrTerm),
+      $.mulop,
+      field('right', $._exprOrTerm)
+    )),
+    add_expr: $ => prec.left(8, seq(
+      field('left', $._exprOrTerm),
+      $.addop,
+      field('right', $._exprOrTerm)
+    )),
+    in_expr: $ => prec.left(7, seq(
+      field('left', $._exprOrTerm),
+      'in',
+      field('right', $._primary)
+    )),
+    comp_term: $ => prec.left(6, seq(
+      field('left', $._exprOrTerm),
+      $.compop,
+      field('right', $._exprOrTerm)
+    )),
+    instance_of: $ => prec.left(5, seq($._exprOrTerm, 'instanceof', $.typeExpr)),
+    negation: $ => prec.left(4, seq('not', $._exprOrTerm)),
+    if_term: $ => prec.left(3, seq(
+      "if", field('cond', $._exprOrTerm),
+      "then", field('first', $._exprOrTerm),
+      "else", field('second', $._exprOrTerm)
+    )),
+    conjunction: $ => prec.left(3, seq(
+      field('left', $._exprOrTerm),
+      "and",
+      field('right', $._exprOrTerm)
+    )),
+    disjunction: $ => prec.left(2, seq(
+      field('left', $._exprOrTerm),
+      "or",
+      field('right', $._exprOrTerm)
+    )),
+    implication: $ => prec.left(1, seq(
+      field('left', $._exprOrTerm),
+      "implies",
+      field('right', $._exprOrTerm)
+    )),
+
+    quantified: $ => seq($.quantifier, "(",
+      choice(
+        seq(
+          sep($.varDecl, ","),
+          optional(seq("|", field('range', $._exprOrTerm), optional(seq("|", field('formula', $._exprOrTerm)))))
+        ),
+        field('expr', $._exprOrTerm)
+      ),
+      ")"),
+
+    specialId: $ => 'none',
+
+    quantifier: $ => choice('exists', 'forall', 'forex'),
+
+    _call_arg: $ => choice(
+      $._exprOrTerm,  // ExprArg
+      $.underscore  // DontCare
+    ),
+
+    underscore: $ => '_',
+
+    qualifiedRhs: $ => choice(
+      seq( // QualCall
+        field("name", $.predicateName),
+        optional($.closure),
+        "(",
+        sep($._call_arg, ","),
+        ")"
+      ),
+      seq( // QualCast
+        "(",
+        $.typeExpr,
+        ")"
+      )
+    ),
+
+    call_body: $ => seq("(", sep($._call_arg, ","), ")"),
+    unqual_agg_body: $ => seq(
+      "(",
+      sep($.varDecl, ","),
+      "|",
+      field('guard', optional($._exprOrTerm)),
+      field('asExprs', optional(seq("|", $.asExprs))),
+      ")"
+    ),
+
+    _call_or_unqual_agg_body: $ => choice($.call_body, $.unqual_agg_body),
+
+    call_or_unqual_agg_expr: $ => prec.dynamic(10, seq($.aritylessPredicateExpr, optional($.closure), $._call_or_unqual_agg_body)),
+    qualified_expr: $ => seq($._primary, ".", $.qualifiedRhs),
+    super_ref: $ => seq(optional(seq($.typeExpr, ".")), $.super),
+
+
+    // The split here is to ensure that the node is non-empty
+    full_aggregate_body: $ => choice(
+      seq(sep($.varDecl, ","),
+        seq(
+          "|",
+          field('guard', optional($._exprOrTerm)),
+          optional(seq("|", field('asExprs', $.asExprs), field('orderBys', optional($.orderBys))))
+        )
+      ),
+      sep1($.varDecl, ","),
+    ),
+
+    expr_aggregate_body: $ => seq(field('asExprs', $.asExprs), field('orderBys', optional($.orderBys))),
+
+    aggregate: $ => seq($.aggId,                                                                // Agg
+      optional(
+        seq("[", sep1($._exprOrTerm, ","), "]")
+      ),
+      "(",
+      optional(
+        choice($.full_aggregate_body, $.expr_aggregate_body)
+      ),
+      ")"
+    ),
+    range: $ => seq(                                                                        // Range
+      "[",
+      field('lower', $._exprOrTerm), "..", field('upper', $._exprOrTerm),
+      "]"
+    ),
+    set_literal: $ => seq(
+      "[",
+      sep($._exprOrTerm, ','),
+      optional(','),
+      "]"
+    ),
+
+    par_expr: $ => seq("(", $._exprOrTerm, ")"),
+
+    expr_annotation: $ => seq(
+      field('name', $.annotName),
+      "[",
+      field('annot_arg', $.annotName),
+      "]",
+      "(",
+      $._exprOrTerm,
+      ")",
+    ),
+
+    _exprOrTerm: $ => choice(
+      $.special_call,
+      $.prefix_cast,
+      $._primary,
+      $.unary_expr,
+      $.mul_expr,
+      $.add_expr,
+      $.in_expr,
+      $.comp_term,
+      $.instance_of,
+      $.negation,
+      $.if_term,
+      $.conjunction,
+      $.disjunction,
+      $.implication,
+      $.quantified,                         // QuantifiedTerm
+    ),
+
+    _primary: $ => choice(
+      $.call_or_unqual_agg_expr, //
+      $.qualified_expr,                                        // QualifiedExpr
+      $.literal,                                                                  // Lit
+      $.variable,                                                                 // Var
+      $.super_ref,
+      $.aggregate,
+      $.range,
+      $.set_literal,
+      $.par_expr,                                                // ParExpr
+      $.expr_annotation, // ExprAnnotation
+    ),
+
+    literal: $ => choice(
+      $.integer,     // IntLit
+      $.float,       // FloatLit
+      $.bool,        // BoolLit
+      $.string       // StringLit
+    ),
+
+
+    bool: $ => choice($.true, $.false),
+
+    variable: $ => choice($.this, $.result, $.varName),
+
+    compop: $ => choice('=', '!=', '<', '>', '<=', '>='),
+
+    unop: $ => choice('+', '-'),
+
+    mulop: $ => choice('*', '/', '%'),
+
+    addop: $ => choice('+', '-'),
+
+    closure: $ => choice('*', '+'),
+
+    direction: $ => choice('asc', 'desc'),
+
+    varDecl: $ => seq($.typeExpr, $.varName),
+
+    moduleParam: $ => seq(
+      field('signature', $.signatureExpr),
+      field('parameter', $.simpleId)
+    ),
+
+    asExprs: $ => sep1($.asExpr, ","),
+
+    asExpr: $ => seq($._exprOrTerm, optional(seq('as', $.varName))),
+
+    orderBys: $ => seq("order", "by", sep1($.orderBy, ",")),
+
+    orderBy: $ => seq($._exprOrTerm, optional($.direction)),
+
+    qldoc: $ => /\/\*\*[^*]*\*+([^/*][^*]*\*+)*\//,
+
+    literalId: $ => choice($._lower_id, $._upper_id),
+
+    annotation: $ => choice(
+      field('name', $.annotName), // SimpleAnnotation
+      seq( // ArgsAnnotation
+        field('name', $.annotName),
+        "[",
+        field('args', sep1($.annotArg, ",")),
+        "]"
+      )
+    ),
+
+    annotName: $ => $._lower_id,
+
+    annotArg: $ => choice($.simpleId, $.this, $.result),
+
+    moduleName: $ => $.simpleId,
+
+    importModuleExpr: $ => seq(
+      repeat(seq(field("qualName", $.simpleId), ".")),
+      $.moduleExpr
+    ),
+
+    moduleExpr: $ => choice(
+      $.simpleId,
+      $.moduleInstantiation,
+      seq($.moduleExpr, "::", field("name", choice($.simpleId, $.moduleInstantiation)))
+    ),
+
+    moduleInstantiation: $ => seq(
+      field("name", $.moduleName),
+      "<",
+      sep1($.signatureExpr, ","),
+      ">"
+    ),
+
+    primitiveType: $ => choice('boolean', 'date', 'float', 'int', 'string'),
+
+    simpleId: $ => choice($._lower_id, $._upper_id),
+
+    className: $ => $._upper_id,
+
+    dbtype: $ => /@[a-z][A-Za-z0-9_]*/,
+
+    typeExpr: $ => choice(
+      seq(optional(seq(field("qualifier", $.moduleExpr), "::")), field("name", $.className)),
+      $.dbtype,
+      $.primitiveType
+    ),
+
+    signatureExpr: $ => choice(
+      field("type_expr", $.typeExpr),
+      field("mod_expr", $.moduleExpr),
+      field("predicate", $.predicateExpr)
+    ),
+
+    predicateName: $ => $._lower_id,
+
+    aritylessPredicateExpr: $ => seq(optional(seq(field('qualifier', $.moduleExpr), "::")), field("name", $.literalId)),
+
+    predicateExpr: $ => seq($.aritylessPredicateExpr, '/', $.integer),
+
+    varName: $ => $.simpleId,
+
+    aggId: $ => choice('avg', 'concat', 'strictconcat', 'count', 'max', 'min', 'rank', 'strictcount', 'strictsum', 'sum', 'any', 'unique'),
+
+    _upper_id: $ => /[A-Z][A-Za-z0-9_]*/,
+    _lower_id: $ => /[a-z][A-Za-z0-9_]*/,
+    integer: $ => /[0-9]+/,
+    float: $ => /[0-9]+\.[0-9]+/,
+    string: $ => /"([^"\\\r\n\t]|\\["\\nrt])*"/,
+    line_comment: $ => /\/\/[^\r\n]*/,
+    block_comment: $ => /\/\*([^*]+\*+([^/*][^*]*\*+)*|\*)\//,
+
+    false: $ => 'false',
+    predicate: $ => 'predicate',
+    result: $ => 'result',
+    super: $ => 'super',
+    this: $ => 'this',
+    true: $ => 'true',
+  }
+});
+
+function sep(rule, s) {
+  return optional(sep1(rule, s))
+}
+
+function sep1(rule, s) {
+  return seq(rule, repeat(seq(s, rule)))
+}

vendor/tree-sitter-ql/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "tree-sitter-ql",
+  "version": "0.19.0",
+  "description": "tree-sitter grammar for Semmle QL",
+  "keywords": [
+    "tree-sitter",
+    "semmle-ql"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tree-sitter/tree-sitter-ql.git"
+  },
+  "author": "Sam Lanning <[email protected]>",
+  "license": "MIT",
+  "devDependencies": {
+    "tree-sitter-cli": "^0.20.6"
+  },
+  "scripts": {
+    "tree-sitter": "tree-sitter",
+    "generate": "tree-sitter generate",
+    "test": "tree-sitter test",
+    "build": "tree-sitter generate && node-gyp build"
+  },
+  "tree-sitter": [
+    {
+      "file-types": [
+        "ql",
+        "qll"
+      ],
+      "scope": "source.ql"
+    }
+  ],
+  "dependencies": {
+    "nan": "^2.14.1"
+  },
+  "bugs": {
+    "url": "https://github.com/tree-sitter/tree-sitter-ql/issues"
+  },
+  "homepage": "https://github.com/tree-sitter/tree-sitter-ql#readme",
+  "main": "bindings/node",
+  "directories": {
+    "example": "examples",
+    "test": "test"
+  }
+}

vendor/tree-sitter-ql/queries/highlights.scm

@@ -0,0 +1,103 @@
+[
+  "and"
+  "any"
+  "as"
+  "asc"
+  "avg"
+  "by"
+  "class"
+  "concat"
+  "count"
+  "desc"
+  "else"
+  "exists"
+  "extends"
+  "forall"
+  "forex"
+  "from"
+  "if"
+  "implies"
+  "import"
+  "in"
+  "instanceof"
+  "max"
+  "min"
+  "module"
+  "newtype"
+  "not"
+  "or"
+  "order"
+  "rank"
+  "select"
+  "strictconcat"
+  "strictcount"
+  "strictsum"
+  "sum"
+  "then"
+  "where"
+
+  (false)
+  (predicate)
+  (result)
+  (specialId)
+  (super)
+  (this)
+  (true)
+] @keyword
+
+[
+  "boolean"
+  "float"
+  "int"
+  "date"
+  "string"
+] @type.builtin
+
+(annotName) @attribute
+
+[
+  "<"
+  "<="
+  "="
+  ">"
+  ">="
+  "-"
+  "!="
+  "/"
+  "*"
+  "%"
+  "+"
+  "::"
+] @operator
+
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  ","
+  "|"
+] @punctuation.delimiter
+
+(className) @type
+
+(varName) @variable
+
+(integer) @number
+(float) @number
+
+(string) @string
+
+(aritylessPredicateExpr (literalId) @function)
+(predicateName) @function
+
+[
+  (line_comment)
+  (block_comment)
+  (qldoc)
+] @comment

vendor/tree-sitter-ql/queries/tags.scm

@@ -0,0 +1,26 @@
+(classlessPredicate
+  name: (predicateName) @name) @definition.function
+
+(memberPredicate
+  name: (predicateName) @name) @definition.method
+
+(aritylessPredicateExpr
+  name: (literalId) @name) @reference.call
+
+(module
+  name: (moduleName) @name) @definition.module
+
+(dataclass
+  name: (className) @name) @definition.class
+
+(datatype
+  name: (className) @name) @definition.class
+
+(datatypeBranch
+  name: (className) @name) @definition.class
+
+(qualifiedRhs
+  name: (predicateName) @name) @reference.call
+
+(typeExpr
+  name: (className) @name) @reference.type

vendor/tree-sitter-ql/script/fetch-examples

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+set -e
+
+function checkout() {
+  repo=$1; url=$2; sha=$3
+
+  if [ ! -d "$repo" ]; then
+    git clone "https://github.com/$url" "$repo"
+  fi
+
+  pushd "$repo"
+  git fetch && git reset --hard "$sha"
+  popd
+}
+
+checkout examples/codeql github/codeql 86404af50100b409b18e62651295e79393a6016a

vendor/tree-sitter-ql/script/known-failures.txt

@@ -0,0 +1,2 @@
+examples/codeql/docs/language/ql-training/query-examples/cpp/data-flow-cpp-2.ql
+examples/codeql/docs/language/ql-training/query-examples/java/empty-if-java-class.ql

vendor/tree-sitter-ql/script/parse-examples

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+set -eu
+
+known_failures="$(cat script/known-failures.txt)"
+
+tree-sitter parse -q \
+  'examples/**/*.ql' \
+  $(for file in $known_failures; do echo "!${file}"; done)
+
+example_count=$(find examples -name '*.cs' | wc -l)
+failure_count=$(wc -w <<< "$known_failures")
+success_count=$(( $example_count - $failure_count ))
+success_percent=$(bc -l <<< "100*${success_count}/${example_count}")
+
+printf \
+  "Successfully parsed %d of %d example files (%.1f%%)\n" \
+  $success_count $example_count $success_percent

vendor/tree-sitter-ql/src/grammar.json

@@ -0,0 +1,3310 @@
+{
+  "name": "ql",
+  "word": "_lower_id",
+  "rules": {
+    "ql": {
+      "type": "REPEAT",
+      "content": {
+        "type": "SYMBOL",
+        "name": "moduleMember"
+      }
+    },
+    "module": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "module"
+        },
+        {
+          "type": "FIELD",
+          "name": "name",
+          "content": {
+            "type": "SYMBOL",
+            "name": "moduleName"
+          }
+        },
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SEQ",
+              "members": [
+                {
+                  "type": "STRING",
+                  "value": "<"
+                },
+                {
+                  "type": "SEQ",
+                  "members": [
+                    {
+                      "type": "FIELD",
+                      "name": "parameter",
+                      "content": {
+                        "type": "SYMBOL",
+                        "name": "moduleParam"
+                      }
+                    },
+                    {
+                      "type": "REPEAT",
+                      "content": {
+                        "type": "SEQ",
+                        "members": [
+                          {
+                            "type": "STRING",
+                            "value": ","
+                          },
+                          {
+                            "type": "FIELD",
+                            "name": "parameter",
+                            "content": {
+                              "type": "SYMBOL",
+                              "name": "moduleParam"
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  ]
+                },
+                {
+                  "type": "STRING",
+                  "value": ">"
+                }
+              ]
+            },
+            {
+              "type": "BLANK"
+            }
+          ]
+        },
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SEQ",
+              "members": [
+                {
+                  "type": "STRING",
+                  "value": "implements"
+                },
+                {
+                  "type": "SEQ",
+                  "members": [
+                    {
+                      "type": "FIELD",
+                      "name": "implements",
+                      "content": {
+                        "type": "SYMBOL",
+                        "name": "signatureExpr"
+                      }
+                    },
+                    {
+                      "type": "REPEAT",
+                      "content": {
+                        "type": "SEQ",
+                        "members": [
+                          {
+                            "type": "STRING",
+                            "value": ","
+                          },
+                          {
+                            "type": "FIELD",
+                            "name": "implements",
+                            "content": {
+                              "type": "SYMBOL",
+                              "name": "signatureExpr"
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              "type": "BLANK"
+            }
+          ]
+        },
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SEQ",
+              "members": [
+                {
+                  "type": "STRING",
+                  "value": "{"
+                },
+                {
+                  "type": "REPEAT",
+                  "content": {
+                    "type": "SYMBOL",
+                    "name": "moduleMember"
+                  }
+                },
+                {
+                  "type": "STRING",
+                  "value": "}"
+                }
+              ]
+            },
+            {
+              "type": "SYMBOL",
+              "name": "moduleAliasBody"
+            }
+          ]
+        }
+      ]
+    },
+    "moduleMember": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "SEQ",
+          "members": [
+            {
+              "type": "REPEAT",
+              "content": {
+                "type": "SYMBOL",
+                "name": "annotation"
+              }
+            },
+            {
+              "type": "CHOICE",
+              "members": [
+                {
+                  "type": "SYMBOL",
+                  "name": "importDirective"
+                },
+                {
+                  "type": "SYMBOL",
+                  "name": "classlessPredicate"
+                },
+                {
+                  "type": "SYMBOL",
+                  "name": "dataclass"
+                },
+                {
+                  "type": "SYMBOL",
+                  "name": "datatype"
+                },
+                {
+                  "type": "SYMBOL",
+                  "name": "select"
+                },
+                {
+                  "type": "SYMBOL",
+                  "name": "module"
+                }
+              ]
+            }
+          ]
+        },
+        {
+          "type": "SYMBOL",
+          "name": "qldoc"
+        }
+      ]
+    },
+    "importDirective": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "import"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "importModuleExpr"
+        },
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SEQ",
+              "members": [
+                {
+                  "type": "STRING",
+                  "value": "as"
+                },
+                {
+                  "type": "SYMBOL",
+                  "name": "moduleName"
+                }
+              ]
+            },
+            {
+              "type": "BLANK"
+            }
+          ]
+        }
+      ]
+    },
+    "moduleAliasBody": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "="
+        },
+        {
+          "type": "SYMBOL",
+          "name": "moduleExpr"
+        },
+        {
+          "type": "STRING",
+          "value": ";"
+        }
+      ]
+    },
+    "predicateAliasBody": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "="
+        },
+        {
+          "type": "SYMBOL",
+          "name": "predicateExpr"
+        },
+        {
+          "type": "STRING",
+          "value": ";"
+        }
+      ]
+    },
+    "typeAliasBody": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "="
+        },
+        {
+          "type": "SYMBOL",
+          "name": "typeExpr"
+        },
+        {
+          "type": "STRING",
+          "value": ";"
+        }
+      ]
+    },
+    "typeUnionBody": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "="
+        },
+        {
+          "type": "SYMBOL",
+          "name": "typeExpr"
+        },
+        {
+          "type": "STRING",
+          "value": "or"
+        },
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SEQ",
+              "members": [
+                {
+                  "type": "SYMBOL",
+                  "name": "typeExpr"
+                },
+                {
+                  "type": "REPEAT",
+                  "content": {
+                    "type": "SEQ",
+                    "members": [
+                      {
+                        "type": "STRING",
+                        "value": "or"
+                      },
+                      {
+                        "type": "SYMBOL",
+                        "name": "typeExpr"
+                      }
+                    ]
+                  }
+                }
+              ]
+            },
+            {
+              "type": "BLANK"
+            }
+          ]
+        },
+        {
+          "type": "STRING",
+          "value": ";"
+        }
+      ]
+    },
+    "classlessPredicate": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "FIELD",
+          "name": "returnType",
+          "content": {
+            "type": "CHOICE",
+            "members": [
+              {
+                "type": "SYMBOL",
+                "name": "predicate"
+              },
+              {
+                "type": "SYMBOL",
+                "name": "typeExpr"
+              }
+            ]
+          }
+        },
+        {
+          "type": "FIELD",
+          "name": "name",
+          "content": {
+            "type": "SYMBOL",
+            "name": "predicateName"
+          }
+        },
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SEQ",
+              "members": [
+                {
+                  "type": "STRING",
+                  "value": "("
+                },
+                {
+                  "type": "CHOICE",
+                  "members": [
+                    {
+                      "type": "SEQ",
+                      "members": [
+                        {
+                          "type": "SYMBOL",
+                          "name": "varDecl"
+                        },
+                        {
+                          "type": "REPEAT",
+                          "content": {
+                            "type": "SEQ",
+                            "members": [
+                              {
+                                "type": "STRING",
+                                "value": ","
+                              },
+                              {
+                                "type": "SYMBOL",
+                                "name": "varDecl"
+                              }
+                            ]
+                          }
+                        }
+                      ]
+                    },
+                    {
+                      "type": "BLANK"
+                    }
+                  ]
+                },
+                {
+                  "type": "STRING",
+                  "value": ")"
+                },
+                {
+                  "type": "SYMBOL",
+                  "name": "_optbody"
+                }
+              ]
+            },
+            {
+              "type": "SYMBOL",
+              "name": "predicateAliasBody"
+            }
+          ]
+        }
+      ]
+    },
+    "datatype": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "newtype"
+        },
+        {
+          "type": "FIELD",
+          "name": "name",
+          "content": {
+            "type": "SYMBOL",
+            "name": "className"
+          }
+        },
+        {
+          "type": "STRING",
+          "value": "="
+        },
+        {
+          "type": "SYMBOL",
+          "name": "datatypeBranches"
+        }
+      ]
+    },
+    "datatypeBranches": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "datatypeBranch"
+        },
+        {
+          "type": "REPEAT",
+          "content": {
+            "type": "SEQ",
+            "members": [
+              {
+                "type": "STRING",
+                "value": "or"
+              },
+              {
+                "type": "SYMBOL",
+                "name": "datatypeBranch"
+              }
+            ]
+          }
+        }
+      ]
+    },
+    "datatypeBranch": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SYMBOL",
+              "name": "qldoc"
+            },
+            {
+              "type": "BLANK"
+            }
+          ]
+        },
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SYMBOL",
+              "name": "annotation"
+            },
+            {
+              "type": "BLANK"
+            }
+          ]
+        },
+        {
+          "type": "FIELD",
+          "name": "name",
+          "content": {
+            "type": "SYMBOL",
+            "name": "className"
+          }
+        },
+        {
+          "type": "STRING",
+          "value": "("
+        },
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SEQ",
+              "members": [
+                {
+                  "type": "SYMBOL",
+                  "name": "varDecl"
+                },
+                {
+                  "type": "REPEAT",
+                  "content": {
+                    "type": "SEQ",
+                    "members": [
+                      {
+                        "type": "STRING",
+                        "value": ","
+                      },
+                      {
+                        "type": "SYMBOL",
+                        "name": "varDecl"
+                      }
+                    ]
+                  }
+                }
+              ]
+            },
+            {
+              "type": "BLANK"
+            }
+          ]
+        },
+        {
+          "type": "STRING",
+          "value": ")"
+        },
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SYMBOL",
+              "name": "body"
+            },
+            {
+              "type": "BLANK"
+            }
+          ]
+        }
+      ]
+    },
+    "select": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SEQ",
+              "members": [
+                {
+                  "type": "STRING",
+                  "value": "from"
+                },
+                {
+                  "type": "CHOICE",
+                  "members": [
+                    {
+                      "type": "SEQ",
+                      "members": [
+                        {
+                          "type": "SYMBOL",
+                          "name": "varDecl"
+                        },
+                        {
+                          "type": "REPEAT",
+                          "content": {
+                            "type": "SEQ",
+                            "members": [
+                              {
+                                "type": "STRING",
+                                "value": ","
+                              },
+                              {
+                                "type": "SYMBOL",
+                                "name": "varDecl"
+                              }
+                            ]
+                          }
+                        }
+                      ]
+                    },
+                    {
+                      "type": "BLANK"
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              "type": "BLANK"
+            }
+          ]
+        },
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SEQ",
+              "members": [
+                {
+                  "type": "STRING",
+                  "value": "where"
+                },
+                {
+                  "type": "SYMBOL",
+                  "name": "_exprOrTerm"
+                }
+              ]
+            },
+            {
+              "type": "BLANK"
+            }
+          ]
+        },
+        {
+          "type": "SEQ",
+          "members": [
+            {
+              "type": "STRING",
+              "value": "select"
+            },
+            {
+              "type": "SYMBOL",
+              "name": "asExprs"
+            },
+            {
+              "type": "CHOICE",
+              "members": [
+                {
+                  "type": "SYMBOL",
+                  "name": "orderBys"
+                },
+                {
+                  "type": "BLANK"
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    },
+    "dataclass": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "class"
+        },
+        {
+          "type": "FIELD",
+          "name": "name",
+          "content": {
+            "type": "SYMBOL",
+            "name": "className"
+          }
+        },
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SEQ",
+              "members": [
+                {
+                  "type": "CHOICE",
+                  "members": [
+                    {
+                      "type": "FIELD",
+                      "name": "extends",
+                      "content": {
+                        "type": "SEQ",
+                        "members": [
+                          {
+                            "type": "STRING",
+                            "value": "extends"
+                          },
+                          {
+                            "type": "SEQ",
+                            "members": [
+                              {
+                                "type": "SYMBOL",
+                                "name": "typeExpr"
+                              },
+                              {
+                                "type": "REPEAT",
+                                "content": {
+                                  "type": "SEQ",
+                                  "members": [
+                                    {
+                                      "type": "STRING",
+                                      "value": ","
+                                    },
+                                    {
+                                      "type": "SYMBOL",
+                                      "name": "typeExpr"
+                                    }
+                                  ]
+                                }
+                              }
+                            ]
+                          }
+                        ]
+                      }
+                    },
+                    {
+                      "type": "BLANK"
+                    }
+                  ]
+                },
+                {
+                  "type": "CHOICE",
+                  "members": [
+                    {
+                      "type": "FIELD",
+                      "name": "instanceof",
+                      "content": {
+                        "type": "SEQ",
+                        "members": [
+                          {
+                            "type": "STRING",
+                            "value": "instanceof"
+                          },
+                          {
+                            "type": "SEQ",
+                            "members": [
+                              {
+                                "type": "SYMBOL",
+                                "name": "typeExpr"
+                              },
+                              {
+                                "type": "REPEAT",
+                                "content": {
+                                  "type": "SEQ",
+                                  "members": [
+                                    {
+                                      "type": "STRING",
+                                      "value": ","
+                                    },
+                                    {
+                                      "type": "SYMBOL",
+                                      "name": "typeExpr"
+                                    }
+                                  ]
+                                }
+                              }
+                            ]
+                          }
+                        ]
+                      }
+                    },
+                    {
+                      "type": "BLANK"
+                    }
+                  ]
+                },
+                {
+                  "type": "CHOICE",
+                  "members": [
+                    {
+                      "type": "SEQ",
+                      "members": [
+                        {
+                          "type": "STRING",
+                          "value": "{"
+                        },
+                        {
+                          "type": "REPEAT",
+                          "content": {
+                            "type": "SYMBOL",
+                            "name": "classMember"
+                          }
+                        },
+                        {
+                          "type": "STRING",
+                          "value": "}"
+                        }
+                      ]
+                    },
+                    {
+                      "type": "STRING",
+                      "value": ";"
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              "type": "SYMBOL",
+              "name": "typeAliasBody"
+            },
+            {
+              "type": "SYMBOL",
+              "name": "typeUnionBody"
+            }
+          ]
+        }
+      ]
+    },
+    "classMember": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "SEQ",
+          "members": [
+            {
+              "type": "REPEAT",
+              "content": {
+                "type": "SYMBOL",
+                "name": "annotation"
+              }
+            },
+            {
+              "type": "CHOICE",
+              "members": [
+                {
+                  "type": "SYMBOL",
+                  "name": "charpred"
+                },
+                {
+                  "type": "SYMBOL",
+                  "name": "memberPredicate"
+                },
+                {
+                  "type": "SYMBOL",
+                  "name": "field"
+                }
+              ]
+            }
+          ]
+        },
+        {
+          "type": "SYMBOL",
+          "name": "qldoc"
+        }
+      ]
+    },
+    "charpred": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "className"
+        },
+        {
+          "type": "STRING",
+          "value": "("
+        },
+        {
+          "type": "STRING",
+          "value": ")"
+        },
+        {
+          "type": "STRING",
+          "value": "{"
+        },
+        {
+          "type": "FIELD",
+          "name": "body",
+          "content": {
+            "type": "SYMBOL",
+            "name": "_exprOrTerm"
+          }
+        },
+        {
+          "type": "STRING",
+          "value": "}"
+        }
+      ]
+    },
+    "memberPredicate": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "FIELD",
+          "name": "returnType",
+          "content": {
+            "type": "CHOICE",
+            "members": [
+              {
+                "type": "SYMBOL",
+                "name": "predicate"
+              },
+              {
+                "type": "SYMBOL",
+                "name": "typeExpr"
+              }
+            ]
+          }
+        },
+        {
+          "type": "FIELD",
+          "name": "name",
+          "content": {
+            "type": "SYMBOL",
+            "name": "predicateName"
+          }
+        },
+        {
+          "type": "STRING",
+          "value": "("
+        },
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SEQ",
+              "members": [
+                {
+                  "type": "SYMBOL",
+                  "name": "varDecl"
+                },
+                {
+                  "type": "REPEAT",
+                  "content": {
+                    "type": "SEQ",
+                    "members": [
+                      {
+                        "type": "STRING",
+                        "value": ","
+                      },
+                      {
+                        "type": "SYMBOL",
+                        "name": "varDecl"
+                      }
+                    ]
+                  }
+                }
+              ]
+            },
+            {
+              "type": "BLANK"
+            }
+          ]
+        },
+        {
+          "type": "STRING",
+          "value": ")"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "_optbody"
+        }
+      ]
+    },
+    "field": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "varDecl"
+        },
+        {
+          "type": "STRING",
+          "value": ";"
+        }
+      ]
+    },
+    "_optbody": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "empty"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "body"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "higherOrderTerm"
+        }
+      ]
+    },
+    "empty": {
+      "type": "STRING",
+      "value": ";"
+    },
+    "body": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "{"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "_exprOrTerm"
+        },
+        {
+          "type": "STRING",
+          "value": "}"
+        }
+      ]
+    },
+    "higherOrderTerm": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "="
+        },
+        {
+          "type": "FIELD",
+          "name": "name",
+          "content": {
+            "type": "SYMBOL",
+            "name": "literalId"
+          }
+        },
+        {
+          "type": "STRING",
+          "value": "("
+        },
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SEQ",
+              "members": [
+                {
+                  "type": "SYMBOL",
+                  "name": "predicateExpr"
+                },
+                {
+                  "type": "REPEAT",
+                  "content": {
+                    "type": "SEQ",
+                    "members": [
+                      {
+                        "type": "STRING",
+                        "value": ","
+                      },
+                      {
+                        "type": "SYMBOL",
+                        "name": "predicateExpr"
+                      }
+                    ]
+                  }
+                }
+              ]
+            },
+            {
+              "type": "BLANK"
+            }
+          ]
+        },
+        {
+          "type": "STRING",
+          "value": ")"
+        },
+        {
+          "type": "STRING",
+          "value": "("
+        },
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SEQ",
+              "members": [
+                {
+                  "type": "SYMBOL",
+                  "name": "_call_arg"
+                },
+                {
+                  "type": "REPEAT",
+                  "content": {
+                    "type": "SEQ",
+                    "members": [
+                      {
+                        "type": "STRING",
+                        "value": ","
+                      },
+                      {
+                        "type": "SYMBOL",
+                        "name": "_call_arg"
+                      }
+                    ]
+                  }
+                }
+              ]
+            },
+            {
+              "type": "BLANK"
+            }
+          ]
+        },
+        {
+          "type": "STRING",
+          "value": ")"
+        }
+      ]
+    },
+    "special_call": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "specialId"
+        },
+        {
+          "type": "STRING",
+          "value": "("
+        },
+        {
+          "type": "STRING",
+          "value": ")"
+        }
+      ]
+    },
+    "prefix_cast": {
+      "type": "PREC_DYNAMIC",
+      "value": 10,
+      "content": {
+        "type": "SEQ",
+        "members": [
+          {
+            "type": "STRING",
+            "value": "("
+          },
+          {
+            "type": "SYMBOL",
+            "name": "typeExpr"
+          },
+          {
+            "type": "STRING",
+            "value": ")"
+          },
+          {
+            "type": "SYMBOL",
+            "name": "_exprOrTerm"
+          }
+        ]
+      }
+    },
+    "unary_expr": {
+      "type": "PREC_LEFT",
+      "value": 9,
+      "content": {
+        "type": "SEQ",
+        "members": [
+          {
+            "type": "SYMBOL",
+            "name": "unop"
+          },
+          {
+            "type": "SYMBOL",
+            "name": "_exprOrTerm"
+          }
+        ]
+      }
+    },
+    "mul_expr": {
+      "type": "PREC_LEFT",
+      "value": 9,
+      "content": {
+        "type": "SEQ",
+        "members": [
+          {
+            "type": "FIELD",
+            "name": "left",
+            "content": {
+              "type": "SYMBOL",
+              "name": "_exprOrTerm"
+            }
+          },
+          {
+            "type": "SYMBOL",
+            "name": "mulop"
+          },
+          {
+            "type": "FIELD",
+            "name": "right",
+            "content": {
+              "type": "SYMBOL",
+              "name": "_exprOrTerm"
+            }
+          }
+        ]
+      }
+    },
+    "add_expr": {
+      "type": "PREC_LEFT",
+      "value": 8,
+      "content": {
+        "type": "SEQ",
+        "members": [
+          {
+            "type": "FIELD",
+            "name": "left",
+            "content": {
+              "type": "SYMBOL",
+              "name": "_exprOrTerm"
+            }
+          },
+          {
+            "type": "SYMBOL",
+            "name": "addop"
+          },
+          {
+            "type": "FIELD",
+            "name": "right",
+            "content": {
+              "type": "SYMBOL",
+              "name": "_exprOrTerm"
+            }
+          }
+        ]
+      }
+    },
+    "in_expr": {
+      "type": "PREC_LEFT",
+      "value": 7,
+      "content": {
+        "type": "SEQ",
+        "members": [
+          {
+            "type": "FIELD",
+            "name": "left",
+            "content": {
+              "type": "SYMBOL",
+              "name": "_exprOrTerm"
+            }
+          },
+          {
+            "type": "STRING",
+            "value": "in"
+          },
+          {
+            "type": "FIELD",
+            "name": "right",
+            "content": {
+              "type": "SYMBOL",
+              "name": "_primary"
+            }
+          }
+        ]
+      }
+    },
+    "comp_term": {
+      "type": "PREC_LEFT",
+      "value": 6,
+      "content": {
+        "type": "SEQ",
+        "members": [
+          {
+            "type": "FIELD",
+            "name": "left",
+            "content": {
+              "type": "SYMBOL",
+              "name": "_exprOrTerm"
+            }
+          },
+          {
+            "type": "SYMBOL",
+            "name": "compop"
+          },
+          {
+            "type": "FIELD",
+            "name": "right",
+            "content": {
+              "type": "SYMBOL",
+              "name": "_exprOrTerm"
+            }
+          }
+        ]
+      }
+    },
+    "instance_of": {
+      "type": "PREC_LEFT",
+      "value": 5,
+      "content": {
+        "type": "SEQ",
+        "members": [
+          {
+            "type": "SYMBOL",
+            "name": "_exprOrTerm"
+          },
+          {
+            "type": "STRING",
+            "value": "instanceof"
+          },
+          {
+            "type": "SYMBOL",
+            "name": "typeExpr"
+          }
+        ]
+      }
+    },
+    "negation": {
+      "type": "PREC_LEFT",
+      "value": 4,
+      "content": {
+        "type": "SEQ",
+        "members": [
+          {
+            "type": "STRING",
+            "value": "not"
+          },
+          {
+            "type": "SYMBOL",
+            "name": "_exprOrTerm"
+          }
+        ]
+      }
+    },
+    "if_term": {
+      "type": "PREC_LEFT",
+      "value": 3,
+      "content": {
+        "type": "SEQ",
+        "members": [
+          {
+            "type": "STRING",
+            "value": "if"
+          },
+          {
+            "type": "FIELD",
+            "name": "cond",
+            "content": {
+              "type": "SYMBOL",
+              "name": "_exprOrTerm"
+            }
+          },
+          {
+            "type": "STRING",
+            "value": "then"
+          },
+          {
+            "type": "FIELD",
+            "name": "first",
+            "content": {
+              "type": "SYMBOL",
+              "name": "_exprOrTerm"
+            }
+          },
+          {
+            "type": "STRING",
+            "value": "else"
+          },
+          {
+            "type": "FIELD",
+            "name": "second",
+            "content": {
+              "type": "SYMBOL",
+              "name": "_exprOrTerm"
+            }
+          }
+        ]
+      }
+    },
+    "conjunction": {
+      "type": "PREC_LEFT",
+      "value": 3,
+      "content": {
+        "type": "SEQ",
+        "members": [
+          {
+            "type": "FIELD",
+            "name": "left",
+            "content": {
+              "type": "SYMBOL",
+              "name": "_exprOrTerm"
+            }
+          },
+          {
+            "type": "STRING",
+            "value": "and"
+          },
+          {
+            "type": "FIELD",
+            "name": "right",
+            "content": {
+              "type": "SYMBOL",
+              "name": "_exprOrTerm"
+            }
+          }
+        ]
+      }
+    },
+    "disjunction": {
+      "type": "PREC_LEFT",
+      "value": 2,
+      "content": {
+        "type": "SEQ",
+        "members": [
+          {
+            "type": "FIELD",
+            "name": "left",
+            "content": {
+              "type": "SYMBOL",
+              "name": "_exprOrTerm"
+            }
+          },
+          {
+            "type": "STRING",
+            "value": "or"
+          },
+          {
+            "type": "FIELD",
+            "name": "right",
+            "content": {
+              "type": "SYMBOL",
+              "name": "_exprOrTerm"
+            }
+          }
+        ]
+      }
+    },
+    "implication": {
+      "type": "PREC_LEFT",
+      "value": 1,
+      "content": {
+        "type": "SEQ",
+        "members": [
+          {
+            "type": "FIELD",
+            "name": "left",
+            "content": {
+              "type": "SYMBOL",
+              "name": "_exprOrTerm"
+            }
+          },
+          {
+            "type": "STRING",
+            "value": "implies"
+          },
+          {
+            "type": "FIELD",
+            "name": "right",
+            "content": {
+              "type": "SYMBOL",
+              "name": "_exprOrTerm"
+            }
+          }
+        ]
+      }
+    },
+    "quantified": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "quantifier"
+        },
+        {
+          "type": "STRING",
+          "value": "("
+        },
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SEQ",
+              "members": [
+                {
+                  "type": "CHOICE",
+                  "members": [
+                    {
+                      "type": "SEQ",
+                      "members": [
+                        {
+                          "type": "SYMBOL",
+                          "name": "varDecl"
+                        },
+                        {
+                          "type": "REPEAT",
+                          "content": {
+                            "type": "SEQ",
+                            "members": [
+                              {
+                                "type": "STRING",
+                                "value": ","
+                              },
+                              {
+                                "type": "SYMBOL",
+                                "name": "varDecl"
+                              }
+                            ]
+                          }
+                        }
+                      ]
+                    },
+                    {
+                      "type": "BLANK"
+                    }
+                  ]
+                },
+                {
+                  "type": "CHOICE",
+                  "members": [
+                    {
+                      "type": "SEQ",
+                      "members": [
+                        {
+                          "type": "STRING",
+                          "value": "|"
+                        },
+                        {
+                          "type": "FIELD",
+                          "name": "range",
+                          "content": {
+                            "type": "SYMBOL",
+                            "name": "_exprOrTerm"
+                          }
+                        },
+                        {
+                          "type": "CHOICE",
+                          "members": [
+                            {
+                              "type": "SEQ",
+                              "members": [
+                                {
+                                  "type": "STRING",
+                                  "value": "|"
+                                },
+                                {
+                                  "type": "FIELD",
+                                  "name": "formula",
+                                  "content": {
+                                    "type": "SYMBOL",
+                                    "name": "_exprOrTerm"
+                                  }
+                                }
+                              ]
+                            },
+                            {
+                              "type": "BLANK"
+                            }
+                          ]
+                        }
+                      ]
+                    },
+                    {
+                      "type": "BLANK"
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              "type": "FIELD",
+              "name": "expr",
+              "content": {
+                "type": "SYMBOL",
+                "name": "_exprOrTerm"
+              }
+            }
+          ]
+        },
+        {
+          "type": "STRING",
+          "value": ")"
+        }
+      ]
+    },
+    "specialId": {
+      "type": "STRING",
+      "value": "none"
+    },
+    "quantifier": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "exists"
+        },
+        {
+          "type": "STRING",
+          "value": "forall"
+        },
+        {
+          "type": "STRING",
+          "value": "forex"
+        }
+      ]
+    },
+    "_call_arg": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "_exprOrTerm"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "underscore"
+        }
+      ]
+    },
+    "underscore": {
+      "type": "STRING",
+      "value": "_"
+    },
+    "qualifiedRhs": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "SEQ",
+          "members": [
+            {
+              "type": "FIELD",
+              "name": "name",
+              "content": {
+                "type": "SYMBOL",
+                "name": "predicateName"
+              }
+            },
+            {
+              "type": "CHOICE",
+              "members": [
+                {
+                  "type": "SYMBOL",
+                  "name": "closure"
+                },
+                {
+                  "type": "BLANK"
+                }
+              ]
+            },
+            {
+              "type": "STRING",
+              "value": "("
+            },
+            {
+              "type": "CHOICE",
+              "members": [
+                {
+                  "type": "SEQ",
+                  "members": [
+                    {
+                      "type": "SYMBOL",
+                      "name": "_call_arg"
+                    },
+                    {
+                      "type": "REPEAT",
+                      "content": {
+                        "type": "SEQ",
+                        "members": [
+                          {
+                            "type": "STRING",
+                            "value": ","
+                          },
+                          {
+                            "type": "SYMBOL",
+                            "name": "_call_arg"
+                          }
+                        ]
+                      }
+                    }
+                  ]
+                },
+                {
+                  "type": "BLANK"
+                }
+              ]
+            },
+            {
+              "type": "STRING",
+              "value": ")"
+            }
+          ]
+        },
+        {
+          "type": "SEQ",
+          "members": [
+            {
+              "type": "STRING",
+              "value": "("
+            },
+            {
+              "type": "SYMBOL",
+              "name": "typeExpr"
+            },
+            {
+              "type": "STRING",
+              "value": ")"
+            }
+          ]
+        }
+      ]
+    },
+    "call_body": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "("
+        },
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SEQ",
+              "members": [
+                {
+                  "type": "SYMBOL",
+                  "name": "_call_arg"
+                },
+                {
+                  "type": "REPEAT",
+                  "content": {
+                    "type": "SEQ",
+                    "members": [
+                      {
+                        "type": "STRING",
+                        "value": ","
+                      },
+                      {
+                        "type": "SYMBOL",
+                        "name": "_call_arg"
+                      }
+                    ]
+                  }
+                }
+              ]
+            },
+            {
+              "type": "BLANK"
+            }
+          ]
+        },
+        {
+          "type": "STRING",
+          "value": ")"
+        }
+      ]
+    },
+    "unqual_agg_body": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "("
+        },
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SEQ",
+              "members": [
+                {
+                  "type": "SYMBOL",
+                  "name": "varDecl"
+                },
+                {
+                  "type": "REPEAT",
+                  "content": {
+                    "type": "SEQ",
+                    "members": [
+                      {
+                        "type": "STRING",
+                        "value": ","
+                      },
+                      {
+                        "type": "SYMBOL",
+                        "name": "varDecl"
+                      }
+                    ]
+                  }
+                }
+              ]
+            },
+            {
+              "type": "BLANK"
+            }
+          ]
+        },
+        {
+          "type": "STRING",
+          "value": "|"
+        },
+        {
+          "type": "FIELD",
+          "name": "guard",
+          "content": {
+            "type": "CHOICE",
+            "members": [
+              {
+                "type": "SYMBOL",
+                "name": "_exprOrTerm"
+              },
+              {
+                "type": "BLANK"
+              }
+            ]
+          }
+        },
+        {
+          "type": "FIELD",
+          "name": "asExprs",
+          "content": {
+            "type": "CHOICE",
+            "members": [
+              {
+                "type": "SEQ",
+                "members": [
+                  {
+                    "type": "STRING",
+                    "value": "|"
+                  },
+                  {
+                    "type": "SYMBOL",
+                    "name": "asExprs"
+                  }
+                ]
+              },
+              {
+                "type": "BLANK"
+              }
+            ]
+          }
+        },
+        {
+          "type": "STRING",
+          "value": ")"
+        }
+      ]
+    },
+    "_call_or_unqual_agg_body": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "call_body"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "unqual_agg_body"
+        }
+      ]
+    },
+    "call_or_unqual_agg_expr": {
+      "type": "PREC_DYNAMIC",
+      "value": 10,
+      "content": {
+        "type": "SEQ",
+        "members": [
+          {
+            "type": "SYMBOL",
+            "name": "aritylessPredicateExpr"
+          },
+          {
+            "type": "CHOICE",
+            "members": [
+              {
+                "type": "SYMBOL",
+                "name": "closure"
+              },
+              {
+                "type": "BLANK"
+              }
+            ]
+          },
+          {
+            "type": "SYMBOL",
+            "name": "_call_or_unqual_agg_body"
+          }
+        ]
+      }
+    },
+    "qualified_expr": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "_primary"
+        },
+        {
+          "type": "STRING",
+          "value": "."
+        },
+        {
+          "type": "SYMBOL",
+          "name": "qualifiedRhs"
+        }
+      ]
+    },
+    "super_ref": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SEQ",
+              "members": [
+                {
+                  "type": "SYMBOL",
+                  "name": "typeExpr"
+                },
+                {
+                  "type": "STRING",
+                  "value": "."
+                }
+              ]
+            },
+            {
+              "type": "BLANK"
+            }
+          ]
+        },
+        {
+          "type": "SYMBOL",
+          "name": "super"
+        }
+      ]
+    },
+    "full_aggregate_body": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "SEQ",
+          "members": [
+            {
+              "type": "CHOICE",
+              "members": [
+                {
+                  "type": "SEQ",
+                  "members": [
+                    {
+                      "type": "SYMBOL",
+                      "name": "varDecl"
+                    },
+                    {
+                      "type": "REPEAT",
+                      "content": {
+                        "type": "SEQ",
+                        "members": [
+                          {
+                            "type": "STRING",
+                            "value": ","
+                          },
+                          {
+                            "type": "SYMBOL",
+                            "name": "varDecl"
+                          }
+                        ]
+                      }
+                    }
+                  ]
+                },
+                {
+                  "type": "BLANK"
+                }
+              ]
+            },
+            {
+              "type": "SEQ",
+              "members": [
+                {
+                  "type": "STRING",
+                  "value": "|"
+                },
+                {
+                  "type": "FIELD",
+                  "name": "guard",
+                  "content": {
+                    "type": "CHOICE",
+                    "members": [
+                      {
+                        "type": "SYMBOL",
+                        "name": "_exprOrTerm"
+                      },
+                      {
+                        "type": "BLANK"
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "CHOICE",
+                  "members": [
+                    {
+                      "type": "SEQ",
+                      "members": [
+                        {
+                          "type": "STRING",
+                          "value": "|"
+                        },
+                        {
+                          "type": "FIELD",
+                          "name": "asExprs",
+                          "content": {
+                            "type": "SYMBOL",
+                            "name": "asExprs"
+                          }
+                        },
+                        {
+                          "type": "FIELD",
+                          "name": "orderBys",
+                          "content": {
+                            "type": "CHOICE",
+                            "members": [
+                              {
+                                "type": "SYMBOL",
+                                "name": "orderBys"
+                              },
+                              {
+                                "type": "BLANK"
+                              }
+                            ]
+                          }
+                        }
+                      ]
+                    },
+                    {
+                      "type": "BLANK"
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        {
+          "type": "SEQ",
+          "members": [
+            {
+              "type": "SYMBOL",
+              "name": "varDecl"
+            },
+            {
+              "type": "REPEAT",
+              "content": {
+                "type": "SEQ",
+                "members": [
+                  {
+                    "type": "STRING",
+                    "value": ","
+                  },
+                  {
+                    "type": "SYMBOL",
+                    "name": "varDecl"
+                  }
+                ]
+              }
+            }
+          ]
+        }
+      ]
+    },
+    "expr_aggregate_body": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "FIELD",
+          "name": "asExprs",
+          "content": {
+            "type": "SYMBOL",
+            "name": "asExprs"
+          }
+        },
+        {
+          "type": "FIELD",
+          "name": "orderBys",
+          "content": {
+            "type": "CHOICE",
+            "members": [
+              {
+                "type": "SYMBOL",
+                "name": "orderBys"
+              },
+              {
+                "type": "BLANK"
+              }
+            ]
+          }
+        }
+      ]
+    },
+    "aggregate": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "aggId"
+        },
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SEQ",
+              "members": [
+                {
+                  "type": "STRING",
+                  "value": "["
+                },
+                {
+                  "type": "SEQ",
+                  "members": [
+                    {
+                      "type": "SYMBOL",
+                      "name": "_exprOrTerm"
+                    },
+                    {
+                      "type": "REPEAT",
+                      "content": {
+                        "type": "SEQ",
+                        "members": [
+                          {
+                            "type": "STRING",
+                            "value": ","
+                          },
+                          {
+                            "type": "SYMBOL",
+                            "name": "_exprOrTerm"
+                          }
+                        ]
+                      }
+                    }
+                  ]
+                },
+                {
+                  "type": "STRING",
+                  "value": "]"
+                }
+              ]
+            },
+            {
+              "type": "BLANK"
+            }
+          ]
+        },
+        {
+          "type": "STRING",
+          "value": "("
+        },
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "CHOICE",
+              "members": [
+                {
+                  "type": "SYMBOL",
+                  "name": "full_aggregate_body"
+                },
+                {
+                  "type": "SYMBOL",
+                  "name": "expr_aggregate_body"
+                }
+              ]
+            },
+            {
+              "type": "BLANK"
+            }
+          ]
+        },
+        {
+          "type": "STRING",
+          "value": ")"
+        }
+      ]
+    },
+    "range": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "["
+        },
+        {
+          "type": "FIELD",
+          "name": "lower",
+          "content": {
+            "type": "SYMBOL",
+            "name": "_exprOrTerm"
+          }
+        },
+        {
+          "type": "STRING",
+          "value": ".."
+        },
+        {
+          "type": "FIELD",
+          "name": "upper",
+          "content": {
+            "type": "SYMBOL",
+            "name": "_exprOrTerm"
+          }
+        },
+        {
+          "type": "STRING",
+          "value": "]"
+        }
+      ]
+    },
+    "set_literal": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "["
+        },
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SEQ",
+              "members": [
+                {
+                  "type": "SYMBOL",
+                  "name": "_exprOrTerm"
+                },
+                {
+                  "type": "REPEAT",
+                  "content": {
+                    "type": "SEQ",
+                    "members": [
+                      {
+                        "type": "STRING",
+                        "value": ","
+                      },
+                      {
+                        "type": "SYMBOL",
+                        "name": "_exprOrTerm"
+                      }
+                    ]
+                  }
+                }
+              ]
+            },
+            {
+              "type": "BLANK"
+            }
+          ]
+        },
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "STRING",
+              "value": ","
+            },
+            {
+              "type": "BLANK"
+            }
+          ]
+        },
+        {
+          "type": "STRING",
+          "value": "]"
+        }
+      ]
+    },
+    "par_expr": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "("
+        },
+        {
+          "type": "SYMBOL",
+          "name": "_exprOrTerm"
+        },
+        {
+          "type": "STRING",
+          "value": ")"
+        }
+      ]
+    },
+    "expr_annotation": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "FIELD",
+          "name": "name",
+          "content": {
+            "type": "SYMBOL",
+            "name": "annotName"
+          }
+        },
+        {
+          "type": "STRING",
+          "value": "["
+        },
+        {
+          "type": "FIELD",
+          "name": "annot_arg",
+          "content": {
+            "type": "SYMBOL",
+            "name": "annotName"
+          }
+        },
+        {
+          "type": "STRING",
+          "value": "]"
+        },
+        {
+          "type": "STRING",
+          "value": "("
+        },
+        {
+          "type": "SYMBOL",
+          "name": "_exprOrTerm"
+        },
+        {
+          "type": "STRING",
+          "value": ")"
+        }
+      ]
+    },
+    "_exprOrTerm": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "special_call"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "prefix_cast"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "_primary"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "unary_expr"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "mul_expr"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "add_expr"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "in_expr"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "comp_term"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "instance_of"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "negation"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "if_term"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "conjunction"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "disjunction"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "implication"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "quantified"
+        }
+      ]
+    },
+    "_primary": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "call_or_unqual_agg_expr"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "qualified_expr"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "literal"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "variable"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "super_ref"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "aggregate"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "range"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "set_literal"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "par_expr"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "expr_annotation"
+        }
+      ]
+    },
+    "literal": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "integer"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "float"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "bool"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "string"
+        }
+      ]
+    },
+    "bool": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "true"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "false"
+        }
+      ]
+    },
+    "variable": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "this"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "result"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "varName"
+        }
+      ]
+    },
+    "compop": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "="
+        },
+        {
+          "type": "STRING",
+          "value": "!="
+        },
+        {
+          "type": "STRING",
+          "value": "<"
+        },
+        {
+          "type": "STRING",
+          "value": ">"
+        },
+        {
+          "type": "STRING",
+          "value": "<="
+        },
+        {
+          "type": "STRING",
+          "value": ">="
+        }
+      ]
+    },
+    "unop": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "+"
+        },
+        {
+          "type": "STRING",
+          "value": "-"
+        }
+      ]
+    },
+    "mulop": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "*"
+        },
+        {
+          "type": "STRING",
+          "value": "/"
+        },
+        {
+          "type": "STRING",
+          "value": "%"
+        }
+      ]
+    },
+    "addop": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "+"
+        },
+        {
+          "type": "STRING",
+          "value": "-"
+        }
+      ]
+    },
+    "closure": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "*"
+        },
+        {
+          "type": "STRING",
+          "value": "+"
+        }
+      ]
+    },
+    "direction": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "asc"
+        },
+        {
+          "type": "STRING",
+          "value": "desc"
+        }
+      ]
+    },
+    "varDecl": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "typeExpr"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "varName"
+        }
+      ]
+    },
+    "moduleParam": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "FIELD",
+          "name": "signature",
+          "content": {
+            "type": "SYMBOL",
+            "name": "signatureExpr"
+          }
+        },
+        {
+          "type": "FIELD",
+          "name": "parameter",
+          "content": {
+            "type": "SYMBOL",
+            "name": "simpleId"
+          }
+        }
+      ]
+    },
+    "asExprs": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "asExpr"
+        },
+        {
+          "type": "REPEAT",
+          "content": {
+            "type": "SEQ",
+            "members": [
+              {
+                "type": "STRING",
+                "value": ","
+              },
+              {
+                "type": "SYMBOL",
+                "name": "asExpr"
+              }
+            ]
+          }
+        }
+      ]
+    },
+    "asExpr": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "_exprOrTerm"
+        },
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SEQ",
+              "members": [
+                {
+                  "type": "STRING",
+                  "value": "as"
+                },
+                {
+                  "type": "SYMBOL",
+                  "name": "varName"
+                }
+              ]
+            },
+            {
+              "type": "BLANK"
+            }
+          ]
+        }
+      ]
+    },
+    "orderBys": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "order"
+        },
+        {
+          "type": "STRING",
+          "value": "by"
+        },
+        {
+          "type": "SEQ",
+          "members": [
+            {
+              "type": "SYMBOL",
+              "name": "orderBy"
+            },
+            {
+              "type": "REPEAT",
+              "content": {
+                "type": "SEQ",
+                "members": [
+                  {
+                    "type": "STRING",
+                    "value": ","
+                  },
+                  {
+                    "type": "SYMBOL",
+                    "name": "orderBy"
+                  }
+                ]
+              }
+            }
+          ]
+        }
+      ]
+    },
+    "orderBy": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "_exprOrTerm"
+        },
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SYMBOL",
+              "name": "direction"
+            },
+            {
+              "type": "BLANK"
+            }
+          ]
+        }
+      ]
+    },
+    "qldoc": {
+      "type": "PATTERN",
+      "value": "\\/\\*\\*[^*]*\\*+([^/*][^*]*\\*+)*\\/"
+    },
+    "literalId": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "_lower_id"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "_upper_id"
+        }
+      ]
+    },
+    "annotation": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "FIELD",
+          "name": "name",
+          "content": {
+            "type": "SYMBOL",
+            "name": "annotName"
+          }
+        },
+        {
+          "type": "SEQ",
+          "members": [
+            {
+              "type": "FIELD",
+              "name": "name",
+              "content": {
+                "type": "SYMBOL",
+                "name": "annotName"
+              }
+            },
+            {
+              "type": "STRING",
+              "value": "["
+            },
+            {
+              "type": "FIELD",
+              "name": "args",
+              "content": {
+                "type": "SEQ",
+                "members": [
+                  {
+                    "type": "SYMBOL",
+                    "name": "annotArg"
+                  },
+                  {
+                    "type": "REPEAT",
+                    "content": {
+                      "type": "SEQ",
+                      "members": [
+                        {
+                          "type": "STRING",
+                          "value": ","
+                        },
+                        {
+                          "type": "SYMBOL",
+                          "name": "annotArg"
+                        }
+                      ]
+                    }
+                  }
+                ]
+              }
+            },
+            {
+              "type": "STRING",
+              "value": "]"
+            }
+          ]
+        }
+      ]
+    },
+    "annotName": {
+      "type": "SYMBOL",
+      "name": "_lower_id"
+    },
+    "annotArg": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "simpleId"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "this"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "result"
+        }
+      ]
+    },
+    "moduleName": {
+      "type": "SYMBOL",
+      "name": "simpleId"
+    },
+    "importModuleExpr": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "REPEAT",
+          "content": {
+            "type": "SEQ",
+            "members": [
+              {
+                "type": "FIELD",
+                "name": "qualName",
+                "content": {
+                  "type": "SYMBOL",
+                  "name": "simpleId"
+                }
+              },
+              {
+                "type": "STRING",
+                "value": "."
+              }
+            ]
+          }
+        },
+        {
+          "type": "SYMBOL",
+          "name": "moduleExpr"
+        }
+      ]
+    },
+    "moduleExpr": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "simpleId"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "moduleInstantiation"
+        },
+        {
+          "type": "SEQ",
+          "members": [
+            {
+              "type": "SYMBOL",
+              "name": "moduleExpr"
+            },
+            {
+              "type": "STRING",
+              "value": "::"
+            },
+            {
+              "type": "FIELD",
+              "name": "name",
+              "content": {
+                "type": "CHOICE",
+                "members": [
+                  {
+                    "type": "SYMBOL",
+                    "name": "simpleId"
+                  },
+                  {
+                    "type": "SYMBOL",
+                    "name": "moduleInstantiation"
+                  }
+                ]
+              }
+            }
+          ]
+        }
+      ]
+    },
+    "moduleInstantiation": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "FIELD",
+          "name": "name",
+          "content": {
+            "type": "SYMBOL",
+            "name": "moduleName"
+          }
+        },
+        {
+          "type": "STRING",
+          "value": "<"
+        },
+        {
+          "type": "SEQ",
+          "members": [
+            {
+              "type": "SYMBOL",
+              "name": "signatureExpr"
+            },
+            {
+              "type": "REPEAT",
+              "content": {
+                "type": "SEQ",
+                "members": [
+                  {
+                    "type": "STRING",
+                    "value": ","
+                  },
+                  {
+                    "type": "SYMBOL",
+                    "name": "signatureExpr"
+                  }
+                ]
+              }
+            }
+          ]
+        },
+        {
+          "type": "STRING",
+          "value": ">"
+        }
+      ]
+    },
+    "primitiveType": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "boolean"
+        },
+        {
+          "type": "STRING",
+          "value": "date"
+        },
+        {
+          "type": "STRING",
+          "value": "float"
+        },
+        {
+          "type": "STRING",
+          "value": "int"
+        },
+        {
+          "type": "STRING",
+          "value": "string"
+        }
+      ]
+    },
+    "simpleId": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "_lower_id"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "_upper_id"
+        }
+      ]
+    },
+    "className": {
+      "type": "SYMBOL",
+      "name": "_upper_id"
+    },
+    "dbtype": {
+      "type": "PATTERN",
+      "value": "@[a-z][A-Za-z0-9_]*"
+    },
+    "typeExpr": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "SEQ",
+          "members": [
+            {
+              "type": "CHOICE",
+              "members": [
+                {
+                  "type": "SEQ",
+                  "members": [
+                    {
+                      "type": "FIELD",
+                      "name": "qualifier",
+                      "content": {
+                        "type": "SYMBOL",
+                        "name": "moduleExpr"
+                      }
+                    },
+                    {
+                      "type": "STRING",
+                      "value": "::"
+                    }
+                  ]
+                },
+                {
+                  "type": "BLANK"
+                }
+              ]
+            },
+            {
+              "type": "FIELD",
+              "name": "name",
+              "content": {
+                "type": "SYMBOL",
+                "name": "className"
+              }
+            }
+          ]
+        },
+        {
+          "type": "SYMBOL",
+          "name": "dbtype"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "primitiveType"
+        }
+      ]
+    },
+    "signatureExpr": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "FIELD",
+          "name": "type_expr",
+          "content": {
+            "type": "SYMBOL",
+            "name": "typeExpr"
+          }
+        },
+        {
+          "type": "FIELD",
+          "name": "mod_expr",
+          "content": {
+            "type": "SYMBOL",
+            "name": "moduleExpr"
+          }
+        },
+        {
+          "type": "FIELD",
+          "name": "predicate",
+          "content": {
+            "type": "SYMBOL",
+            "name": "predicateExpr"
+          }
+        }
+      ]
+    },
+    "predicateName": {
+      "type": "SYMBOL",
+      "name": "_lower_id"
+    },
+    "aritylessPredicateExpr": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SEQ",
+              "members": [
+                {
+                  "type": "FIELD",
+                  "name": "qualifier",
+                  "content": {
+                    "type": "SYMBOL",
+                    "name": "moduleExpr"
+                  }
+                },
+                {
+                  "type": "STRING",
+                  "value": "::"
+                }
+              ]
+            },
+            {
+              "type": "BLANK"
+            }
+          ]
+        },
+        {
+          "type": "FIELD",
+          "name": "name",
+          "content": {
+            "type": "SYMBOL",
+            "name": "literalId"
+          }
+        }
+      ]
+    },
+    "predicateExpr": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "aritylessPredicateExpr"
+        },
+        {
+          "type": "STRING",
+          "value": "/"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "integer"
+        }
+      ]
+    },
+    "varName": {
+      "type": "SYMBOL",
+      "name": "simpleId"
+    },
+    "aggId": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "avg"
+        },
+        {
+          "type": "STRING",
+          "value": "concat"
+        },
+        {
+          "type": "STRING",
+          "value": "strictconcat"
+        },
+        {
+          "type": "STRING",
+          "value": "count"
+        },
+        {
+          "type": "STRING",
+          "value": "max"
+        },
+        {
+          "type": "STRING",
+          "value": "min"
+        },
+        {
+          "type": "STRING",
+          "value": "rank"
+        },
+        {
+          "type": "STRING",
+          "value": "strictcount"
+        },
+        {
+          "type": "STRING",
+          "value": "strictsum"
+        },
+        {
+          "type": "STRING",
+          "value": "sum"
+        },
+        {
+          "type": "STRING",
+          "value": "any"
+        },
+        {
+          "type": "STRING",
+          "value": "unique"
+        }
+      ]
+    },
+    "_upper_id": {
+      "type": "PATTERN",
+      "value": "[A-Z][A-Za-z0-9_]*"
+    },
+    "_lower_id": {
+      "type": "PATTERN",
+      "value": "[a-z][A-Za-z0-9_]*"
+    },
+    "integer": {
+      "type": "PATTERN",
+      "value": "[0-9]+"
+    },
+    "float": {
+      "type": "PATTERN",
+      "value": "[0-9]+\\.[0-9]+"
+    },
+    "string": {
+      "type": "PATTERN",
+      "value": "\"([^\"\\\\\\r\\n\\t]|\\\\[\"\\\\nrt])*\""
+    },
+    "line_comment": {
+      "type": "PATTERN",
+      "value": "\\/\\/[^\\r\\n]*"
+    },
+    "block_comment": {
+      "type": "PATTERN",
+      "value": "\\/\\*([^*]+\\*+([^/*][^*]*\\*+)*|\\*)\\/"
+    },
+    "false": {
+      "type": "STRING",
+      "value": "false"
+    },
+    "predicate": {
+      "type": "STRING",
+      "value": "predicate"
+    },
+    "result": {
+      "type": "STRING",
+      "value": "result"
+    },
+    "super": {
+      "type": "STRING",
+      "value": "super"
+    },
+    "this": {
+      "type": "STRING",
+      "value": "this"
+    },
+    "true": {
+      "type": "STRING",
+      "value": "true"
+    }
+  },
+  "extras": [
+    {
+      "type": "PATTERN",
+      "value": "[ \\t\\r\\n]"
+    },
+    {
+      "type": "SYMBOL",
+      "name": "line_comment"
+    },
+    {
+      "type": "SYMBOL",
+      "name": "block_comment"
+    }
+  ],
+  "conflicts": [
+    [
+      "simpleId",
+      "className"
+    ],
+    [
+      "simpleId",
+      "literalId"
+    ],
+    [
+      "moduleName",
+      "varName"
+    ],
+    [
+      "simpleId",
+      "moduleInstantiation"
+    ],
+    [
+      "className",
+      "moduleInstantiation"
+    ]
+  ],
+  "precedences": [],
+  "externals": [],
+  "inline": [],
+  "supertypes": []
+}
+

vendor/tree-sitter-ql/src/tree_sitter/parser.h

@@ -0,0 +1,224 @@
+#ifndef TREE_SITTER_PARSER_H_
+#define TREE_SITTER_PARSER_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#define ts_builtin_sym_error ((TSSymbol)-1)
+#define ts_builtin_sym_end 0
+#define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024
+
+typedef uint16_t TSStateId;
+
+#ifndef TREE_SITTER_API_H_
+typedef uint16_t TSSymbol;
+typedef uint16_t TSFieldId;
+typedef struct TSLanguage TSLanguage;
+#endif
+
+typedef struct {
+  TSFieldId field_id;
+  uint8_t child_index;
+  bool inherited;
+} TSFieldMapEntry;
+
+typedef struct {
+  uint16_t index;
+  uint16_t length;
+} TSFieldMapSlice;
+
+typedef struct {
+  bool visible;
+  bool named;
+  bool supertype;
+} TSSymbolMetadata;
+
+typedef struct TSLexer TSLexer;
+
+struct TSLexer {
+  int32_t lookahead;
+  TSSymbol result_symbol;
+  void (*advance)(TSLexer *, bool);
+  void (*mark_end)(TSLexer *);
+  uint32_t (*get_column)(TSLexer *);
+  bool (*is_at_included_range_start)(const TSLexer *);
+  bool (*eof)(const TSLexer *);
+};
+
+typedef enum {
+  TSParseActionTypeShift,
+  TSParseActionTypeReduce,
+  TSParseActionTypeAccept,
+  TSParseActionTypeRecover,
+} TSParseActionType;
+
+typedef union {
+  struct {
+    uint8_t type;
+    TSStateId state;
+    bool extra;
+    bool repetition;
+  } shift;
+  struct {
+    uint8_t type;
+    uint8_t child_count;
+    TSSymbol symbol;
+    int16_t dynamic_precedence;
+    uint16_t production_id;
+  } reduce;
+  uint8_t type;
+} TSParseAction;
+
+typedef struct {
+  uint16_t lex_state;
+  uint16_t external_lex_state;
+} TSLexMode;
+
+typedef union {
+  TSParseAction action;
+  struct {
+    uint8_t count;
+    bool reusable;
+  } entry;
+} TSParseActionEntry;
+
+struct TSLanguage {
+  uint32_t version;
+  uint32_t symbol_count;
+  uint32_t alias_count;
+  uint32_t token_count;
+  uint32_t external_token_count;
+  uint32_t state_count;
+  uint32_t large_state_count;
+  uint32_t production_id_count;
+  uint32_t field_count;
+  uint16_t max_alias_sequence_length;
+  const uint16_t *parse_table;
+  const uint16_t *small_parse_table;
+  const uint32_t *small_parse_table_map;
+  const TSParseActionEntry *parse_actions;
+  const char * const *symbol_names;
+  const char * const *field_names;
+  const TSFieldMapSlice *field_map_slices;
+  const TSFieldMapEntry *field_map_entries;
+  const TSSymbolMetadata *symbol_metadata;
+  const TSSymbol *public_symbol_map;
+  const uint16_t *alias_map;
+  const TSSymbol *alias_sequences;
+  const TSLexMode *lex_modes;
+  bool (*lex_fn)(TSLexer *, TSStateId);
+  bool (*keyword_lex_fn)(TSLexer *, TSStateId);
+  TSSymbol keyword_capture_token;
+  struct {
+    const bool *states;
+    const TSSymbol *symbol_map;
+    void *(*create)(void);
+    void (*destroy)(void *);
+    bool (*scan)(void *, TSLexer *, const bool *symbol_whitelist);
+    unsigned (*serialize)(void *, char *);
+    void (*deserialize)(void *, const char *, unsigned);
+  } external_scanner;
+  const TSStateId *primary_state_ids;
+};
+
+/*
+ *  Lexer Macros
+ */
+
+#define START_LEXER()           \
+  bool result = false;          \
+  bool skip = false;            \
+  bool eof = false;             \
+  int32_t lookahead;            \
+  goto start;                   \
+  next_state:                   \
+  lexer->advance(lexer, skip);  \
+  start:                        \
+  skip = false;                 \
+  lookahead = lexer->lookahead;
+
+#define ADVANCE(state_value) \
+  {                          \
+    state = state_value;     \
+    goto next_state;         \
+  }
+
+#define SKIP(state_value) \
+  {                       \
+    skip = true;          \
+    state = state_value;  \
+    goto next_state;      \
+  }
+
+#define ACCEPT_TOKEN(symbol_value)     \
+  result = true;                       \
+  lexer->result_symbol = symbol_value; \
+  lexer->mark_end(lexer);
+
+#define END_STATE() return result;
+
+/*
+ *  Parse Table Macros
+ */
+
+#define SMALL_STATE(id) id - LARGE_STATE_COUNT
+
+#define STATE(id) id
+
+#define ACTIONS(id) id
+
+#define SHIFT(state_value)            \
+  {{                                  \
+    .shift = {                        \
+      .type = TSParseActionTypeShift, \
+      .state = state_value            \
+    }                                 \
+  }}
+
+#define SHIFT_REPEAT(state_value)     \
+  {{                                  \
+    .shift = {                        \
+      .type = TSParseActionTypeShift, \
+      .state = state_value,           \
+      .repetition = true              \
+    }                                 \
+  }}
+
+#define SHIFT_EXTRA()                 \
+  {{                                  \
+    .shift = {                        \
+      .type = TSParseActionTypeShift, \
+      .extra = true                   \
+    }                                 \
+  }}
+
+#define REDUCE(symbol_val, child_count_val, ...) \
+  {{                                             \
+    .reduce = {                                  \
+      .type = TSParseActionTypeReduce,           \
+      .symbol = symbol_val,                      \
+      .child_count = child_count_val,            \
+      __VA_ARGS__                                \
+    },                                           \
+  }}
+
+#define RECOVER()                    \
+  {{                                 \
+    .type = TSParseActionTypeRecover \
+  }}
+
+#define ACCEPT_INPUT()              \
+  {{                                \
+    .type = TSParseActionTypeAccept \
+  }}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TREE_SITTER_PARSER_H_

vendor/tree-sitter-ql/test/corpus/basic.txt

@@ -0,0 +1,85 @@
+============
+Basic select
+============
+
+import javascript
+
+select
+  "hello world" as foo,
+  "other",
+  "string with escaped \\ backslashes \" quotes \n\r\t whitespace",
+  1234,
+  1234.4321,
+  true,
+  false
+
+---
+
+(ql
+  (moduleMember (importDirective (importModuleExpr (moduleExpr (simpleId)))))
+  (moduleMember (select (asExprs
+    (asExpr (literal (string)) (varName (simpleId)))
+    (asExpr (literal (string)))
+    (asExpr (literal (string)))
+    (asExpr (literal (integer)))
+    (asExpr (literal (float)))
+    (asExpr (literal (bool (true))))
+    (asExpr (literal (bool (false))))))))
+
+============
+Select with variables and order by
+============
+
+from
+  Foo foo,
+  some::submodule::Bar bar,
+  @dbtype bar,
+  boolean b,
+  date d,
+  float f,
+  int i,
+  string s
+select "hello world"
+order by foo, bar desc, baz asc
+
+---
+
+(ql (moduleMember
+  (select
+    (varDecl (typeExpr (className)) (varName (simpleId)))
+    (varDecl (typeExpr (moduleExpr (moduleExpr (simpleId)) (simpleId)) (className)) (varName (simpleId)))
+    (varDecl (typeExpr (dbtype)) (varName (simpleId)))
+    (varDecl (typeExpr (primitiveType)) (varName (simpleId)))
+    (varDecl (typeExpr (primitiveType)) (varName (simpleId)))
+    (varDecl (typeExpr (primitiveType)) (varName (simpleId)))
+    (varDecl (typeExpr (primitiveType)) (varName (simpleId)))
+    (varDecl (typeExpr (primitiveType)) (varName (simpleId)))
+    (asExprs
+      (asExpr (literal (string))))
+    (orderBys
+      (orderBy (variable (varName (simpleId))))
+      (orderBy (variable (varName (simpleId))) (direction))
+      (orderBy (variable (varName (simpleId))) (direction))))))
+
+========================
+Annotations and comments
+========================
+
+private import foo // some other comment
+
+/*
+ * Some comment
+ */
+pragma[noinline]
+bindingset[foobar, this]
+import bar
+
+---
+
+(ql
+  (moduleMember (annotation (annotName)) (importDirective (importModuleExpr (moduleExpr (simpleId)))))
+  (line_comment) (block_comment)
+  (moduleMember
+    (annotation (annotName) (annotArg (simpleId)))
+    (annotation (annotName) (annotArg (simpleId)) (annotArg (this)))
+    (importDirective (importModuleExpr (moduleExpr (simpleId))))))

vendor/tree-sitter-ql/test/corpus/class.txt

@@ -0,0 +1,88 @@
+===========
+empty class
+===========
+
+class Foo extends Bar {}
+
+---
+(ql (moduleMember (dataclass (className) (typeExpr (className)))))
+
+===================================
+class with characteristic predicate
+===================================
+
+abstract class Foo extends Bar {
+
+  pragma[inline]
+  Foo() {
+    this = this
+  }
+
+}
+
+---
+
+(ql (moduleMember
+  (annotation (annotName))
+  (dataclass (className) (typeExpr (className))
+    (classMember (annotation (annotName)  (annotArg (simpleId)))
+      (charpred (className)
+        (comp_term (variable (this)) (compop) (variable (this))))))))
+==================
+class with members
+==================
+
+class X extends Y {
+  m::F f;
+
+  m::F a() {
+    result = f
+  }
+}
+
+---
+
+(ql (moduleMember
+  (dataclass (className) (typeExpr (className))
+    (classMember (field (varDecl (typeExpr (moduleExpr (simpleId)) (className)) (varName (simpleId)))))
+    (classMember (memberPredicate (typeExpr (moduleExpr (simpleId)) (className)) (predicateName)
+    (body (comp_term (variable (result)) (compop) (variable (varName (simpleId))))))))))
+
+===========
+class alias
+===========
+
+class X = foo::Bas;
+
+---
+(ql (moduleMember
+  (dataclass (className) (typeAliasBody (typeExpr (moduleExpr (simpleId)) (className))))))
+
+
+================
+class instanceof
+================
+
+class X extends Y1, Y2 instanceof Z1, Z2 {
+  X() { none() }
+}
+
+---
+
+(ql
+  (moduleMember
+    (dataclass
+      (className)
+      (typeExpr
+        (className))
+      (typeExpr
+        (className))
+      (typeExpr
+        (className))
+      (typeExpr
+        (className))
+      (classMember
+        (charpred
+          (className)
+          (special_call
+            (specialId)))))))

vendor/tree-sitter-ql/test/corpus/ctf.txt

@@ -0,0 +1,23 @@
+=========================
+dataflow example from ctf
+=========================
+
+from Configuration cfg, DataFlow::PathNode source, DataFlow::PathNode sink
+where cfg.hasFlowPath(source, sink)
+select sink.getNode(), source, sink, "Potential XSS vulnerability in plugin."
+
+---
+
+(ql (moduleMember 
+  (select 
+    (varDecl (typeExpr (className)) (varName (simpleId))) 
+    (varDecl (typeExpr (moduleExpr (simpleId)) (className)) (varName (simpleId))) 
+    (varDecl (typeExpr (moduleExpr (simpleId)) (className)) (varName (simpleId))) 
+    (qualified_expr 
+      (variable (varName (simpleId))) 
+      (qualifiedRhs (predicateName) (variable (varName (simpleId))) (variable (varName (simpleId))))) 
+    (asExprs 
+      (asExpr (qualified_expr (variable (varName (simpleId))) (qualifiedRhs (predicateName)))) 
+      (asExpr (variable (varName (simpleId)))) 
+      (asExpr (variable (varName (simpleId)))) 
+      (asExpr (literal (string)))))))

vendor/tree-sitter-ql/test/corpus/expr.txt

@@ -0,0 +1,266 @@
+====
+cast
+====
+
+select (Foo) f
+
+---
+(ql (moduleMember (select (asExprs (asExpr (prefix_cast (typeExpr (className)) (variable (varName (simpleId)))))))))
+========
+dontcare
+========
+
+select foo(_)
+
+---
+(ql (moduleMember (select (asExprs (asExpr (call_or_unqual_agg_expr (aritylessPredicateExpr (literalId)) (call_body (underscore))))))))
+====
+unop
+====
+
+select - 5, + 5
+
+---
+ (ql (moduleMember (select (asExprs (asExpr (unary_expr (unop) (literal (integer)))) (asExpr (unary_expr (unop) (literal (integer))))))))
+=====
+binop
+=====
+
+select 5 + 5, 5 - 5, 5 * 5, 5 / 5, 5 % 5
+
+---
+
+(ql (moduleMember
+  (select
+    (asExprs
+      (asExpr (add_expr (literal (integer)) (addop) (literal (integer))))
+      (asExpr (add_expr (literal (integer)) (addop) (literal (integer))))
+      (asExpr (mul_expr (literal (integer)) (mulop) (literal (integer))))
+      (asExpr (mul_expr (literal (integer)) (mulop) (literal (integer))))
+      (asExpr (mul_expr (literal (integer)) (mulop) (literal (integer))))))))
+
+===========
+set literal
+===========
+
+select [1,2,4]
+
+---
+
+(ql (moduleMember
+  (select
+    (asExprs
+      (asExpr
+        (set_literal
+          (literal (integer))
+          (literal (integer))
+          (literal (integer))))))))
+
+====================
+uniqueness aggregate
+====================
+
+select unique(int x | x = 1 | x)
+
+---
+
+(ql (moduleMember
+  (select
+    (asExprs
+      (asExpr
+        (aggregate
+          (aggId)
+          (full_aggregate_body
+            (varDecl (typeExpr (primitiveType)) (varName (simpleId)))
+            (comp_term (variable (varName (simpleId))) (compop) (literal (integer)))
+            (asExprs (asExpr (variable (varName (simpleId))))))))))))
+
+================
+binop precedence
+================
+
+select
+  // left associative
+  5 + 5 - 5,
+  5 - 5 + 5,
+  // mul binds tighter
+  5 + 5 * 5,
+  5 + 5 / 5,
+  5 * 5 + 5,
+  5 / 5 + 5,
+  // left associative
+  5 / 5 * 5,
+  5 * 5 / 5,
+  // mod tighter,
+  5 * 5 % 5,
+  5 % 5 * 5
+
+---
+
+(ql (moduleMember (select (line_comment)
+  (asExprs
+    (asExpr (add_expr (add_expr (literal (integer)) (addop) (literal (integer))) (addop) (literal (integer))))
+    (asExpr (add_expr (add_expr (literal (integer)) (addop) (literal (integer))) (addop) (literal (integer))))
+    (line_comment)
+    (asExpr (add_expr (literal (integer)) (addop) (mul_expr (literal (integer)) (mulop) (literal (integer)))))
+    (asExpr (add_expr (literal (integer)) (addop) (mul_expr (literal (integer)) (mulop) (literal (integer)))))
+    (asExpr (add_expr (mul_expr (literal (integer)) (mulop) (literal (integer))) (addop) (literal (integer))))
+    (asExpr (add_expr (mul_expr (literal (integer)) (mulop) (literal (integer))) (addop) (literal (integer))))
+    (line_comment)
+    (asExpr (mul_expr (mul_expr (literal (integer)) (mulop) (literal (integer))) (mulop) (literal (integer))))
+    (asExpr (mul_expr (mul_expr (literal (integer)) (mulop) (literal (integer))) (mulop) (literal (integer))))
+    (line_comment)
+    (asExpr (mul_expr (mul_expr (literal (integer)) (mulop) (literal (integer))) (mulop) (literal (integer))))
+    (asExpr (mul_expr (mul_expr (literal (integer)) (mulop) (literal (integer))) (mulop) (literal (integer))))))))
+
+===========================
+unary minus and prefix cast
+===========================
+
+where x = -(float) -7
+select 0
+
+---
+
+(ql (moduleMember
+  (select
+    (comp_term
+      (variable (varName (simpleId)))
+      (compop)
+      (unary_expr
+        (unop)
+        (prefix_cast
+          (typeExpr (primitiveType))
+          (unary_expr
+            (unop)
+            (literal (integer))))))
+    (asExprs (asExpr (literal (integer)))))))
+
+========================
+unary minus and non-cast
+========================
+
+where x = -(foo) -7
+select 0
+
+---
+
+(ql (moduleMember
+  (select
+    (comp_term
+      (variable (varName (simpleId)))
+      (compop)
+      (add_expr
+        (unary_expr
+          (unop)
+          (par_expr (variable (varName (simpleId)))))
+        (addop)
+        (literal (integer))))
+    (asExprs (asExpr (literal (integer)))))))
+
+==============================
+unary minus and multiplication
+==============================
+
+where x = -a * b
+select 0
+
+---
+
+(ql (moduleMember
+  (select
+    (comp_term
+      (variable (varName (simpleId)))
+      (compop)
+      (mul_expr
+        (unary_expr
+        (unop)
+          (variable (varName (simpleId))))
+        (mulop)
+        (variable (varName (simpleId)))))
+    (asExprs (asExpr (literal (integer)))))))
+
+========================
+expression-level pragmas
+========================
+
+from int i
+where i = pragma[only_bind_out](5)
+select i
+
+---
+
+(ql (moduleMember (select
+  (varDecl (typeExpr (primitiveType)) (varName (simpleId)))
+  (comp_term
+    (variable (varName (simpleId)))
+    (compop)
+    (expr_annotation
+      (annotName)
+      (annotName)
+      (literal (integer))))
+  (asExprs (asExpr (variable (varName (simpleId))))))))
+
+===========================
+unary minus and prefix cast
+===========================
+
+where x = -(float) -7
+select 0
+
+---
+
+(ql (moduleMember
+  (select
+    (comp_term
+      (variable (varName (simpleId)))
+      (compop)
+      (unary_expr
+        (unop)
+        (prefix_cast
+          (typeExpr (primitiveType))
+          (unary_expr
+            (unop)
+            (literal (integer))))))
+    (asExprs (asExpr (literal (integer)))))))
+
+========================
+unary minus and non-cast
+========================
+
+where x = -(foo) -7
+select 0
+
+---
+
+(ql (moduleMember
+  (select
+    (comp_term
+      (variable (varName (simpleId)))
+      (compop)
+      (add_expr
+        (unary_expr
+          (unop)
+          (par_expr (variable (varName (simpleId)))))
+        (addop)
+        (literal (integer))))
+    (asExprs (asExpr (literal (integer)))))))
+
+
+===============================
+set literal with trailing comma
+===============================
+
+where x in [1,2,]
+select x
+
+---
+
+(ql (moduleMember
+  (select
+    (in_expr
+      (variable (varName (simpleId)))
+      (set_literal
+        (literal (integer))
+        (literal (integer))))
+    (asExprs (asExpr (variable (varName (simpleId))))))))

vendor/tree-sitter-ql/test/corpus/formula.txt

@@ -0,0 +1,185 @@
+===========
+comparisons
+===========
+
+from File f
+where (f = f)
+  or f != f
+  and f < f
+  and (f > f or f <= f)
+  and f >= f
+select f
+
+---
+
+(ql (moduleMember
+  (select
+    (varDecl (typeExpr (className)) (varName (simpleId)))
+    (disjunction
+      (par_expr (comp_term (variable (varName (simpleId))) (compop) (variable (varName (simpleId)))))
+      (conjunction
+        (conjunction
+          (conjunction
+            (comp_term (variable (varName (simpleId))) (compop) (variable (varName (simpleId))))
+            (comp_term (variable (varName (simpleId))) (compop) (variable (varName (simpleId)))))
+          (par_expr (disjunction
+            (comp_term (variable (varName (simpleId))) (compop) (variable (varName (simpleId))))
+            (comp_term (variable (varName (simpleId))) (compop) (variable (varName (simpleId)))))))
+        (comp_term (variable (varName (simpleId))) (compop) (variable (varName (simpleId))))))
+    (asExprs (asExpr (variable (varName (simpleId))))))))
+
+==========
+instanceof
+==========
+
+from Foo f
+where f instanceof Foo
+select f
+
+---
+
+(ql (moduleMember
+  (select
+    (varDecl (typeExpr (className)) (varName (simpleId)))
+    (instance_of (variable (varName (simpleId))) (typeExpr (className)))
+    (asExprs (asExpr (variable (varName (simpleId))))))))
+
+=====
+range
+=====
+
+from int i
+where i in [0..10]
+select i
+
+---
+
+(ql (moduleMember
+  (select
+   (varDecl (typeExpr (primitiveType)) (varName (simpleId)))
+   (in_expr (variable (varName (simpleId))) (range (literal (integer)) (literal (integer))))
+   (asExprs (asExpr (variable (varName (simpleId))))))))
+
+=====
+set literals
+=====
+
+from int i
+where i in [1, 2]
+select i
+
+---
+
+(ql (moduleMember
+  (select
+    (varDecl (typeExpr (primitiveType)) (varName (simpleId)))
+    (in_expr (variable (varName (simpleId))) (set_literal (literal (integer)) (literal (integer))))
+    (asExprs (asExpr (variable (varName (simpleId))))))))
+
+=================
+predicateRef call
+=================
+
+from int i
+where bar(i) and module::baz+()
+select i
+
+---
+
+(ql (moduleMember
+  (select
+    (varDecl (typeExpr (primitiveType)) (varName (simpleId)))
+    (conjunction
+      (call_or_unqual_agg_expr (aritylessPredicateExpr (literalId)) (call_body (variable (varName (simpleId)))))
+      (call_or_unqual_agg_expr (aritylessPredicateExpr (moduleExpr (simpleId)) (literalId)) (closure) (call_body)))
+    (asExprs (asExpr (variable (varName (simpleId))))))))
+=================================
+calls with results & method calls
+=================================
+
+from int i
+select i.foo+(), 1.foo(), 1.1.foo()
+
+---
+(ql (moduleMember
+  (select
+    (varDecl (typeExpr (primitiveType)) (varName (simpleId)))
+    (asExprs
+      (asExpr (qualified_expr (variable (varName (simpleId))) (qualifiedRhs (predicateName) (closure))))
+      (asExpr (qualified_expr (literal (integer)) (qualifiedRhs (predicateName))))
+      (asExpr (qualified_expr (literal (float)) (qualifiedRhs (predicateName))))))))
+
+==============
+quantification
+==============
+
+
+from Foo f
+where exists(f.aThing())
+   or exists(Foo f | f.aThing())
+   or exists(Foo f | f.aThing() | f.aThing())
+   or forall(Foo f | f.aThing() | f.aThing())
+   or forex(Foo f | f.aThing() | f.aThing())
+select f
+
+---
+
+(ql (moduleMember
+  (select
+    (varDecl (typeExpr (className)) (varName (simpleId)))
+    (disjunction
+      (disjunction
+        (disjunction
+          (disjunction
+            (quantified (quantifier) (qualified_expr (variable (varName (simpleId))) (qualifiedRhs (predicateName))))
+            (quantified (quantifier) (varDecl (typeExpr (className)) (varName (simpleId)))
+          (qualified_expr (variable (varName (simpleId))) (qualifiedRhs (predicateName)))))
+        (quantified (quantifier) (varDecl (typeExpr (className)) (varName (simpleId)))
+          (qualified_expr (variable (varName (simpleId))) (qualifiedRhs (predicateName)))
+          (qualified_expr (variable (varName (simpleId))) (qualifiedRhs (predicateName)))))
+      (quantified (quantifier) (varDecl (typeExpr (className)) (varName (simpleId)))
+        (qualified_expr (variable (varName (simpleId))) (qualifiedRhs (predicateName)))
+        (qualified_expr (variable (varName (simpleId))) (qualifiedRhs (predicateName)))))
+    (quantified (quantifier) (varDecl (typeExpr (className)) (varName (simpleId)))
+      (qualified_expr (variable (varName (simpleId))) (qualifiedRhs (predicateName)))
+      (qualified_expr (variable (varName (simpleId))) (qualifiedRhs (predicateName)))))
+  (asExprs (asExpr (variable (varName (simpleId))))))))
+
+==================
+unary op ambiguity
+==================
+
+from int x
+where x = -1 and any()
+select x
+
+---
+
+(ql (moduleMember
+  (select 
+    (varDecl (typeExpr (primitiveType)) (varName (simpleId)))
+    (conjunction 
+      (comp_term 
+        (variable (varName (simpleId))) 
+        (compop) 
+        (unary_expr (unop) (literal (integer))))
+      (aggregate (aggId)))
+    (asExprs (asExpr (variable (varName (simpleId))))))))
+
+====================
+unary op ambiguity 2
+====================
+
+where -1 in [-1..1]
+select "yes"
+
+---
+
+(ql (moduleMember
+  (select 
+    (in_expr 
+      (unary_expr (unop) (literal (integer))) 
+      (range 
+        (unary_expr (unop) (literal (integer))) 
+        (literal (integer)))) 
+  (asExprs (asExpr (literal (string)))))))

vendor/tree-sitter-ql/test/corpus/modules.txt

@@ -0,0 +1,239 @@
+======
+module
+======
+
+module foo {
+  module bar {
+    import woo
+
+    predicate baz();
+  }
+}
+
+---
+
+(ql (moduleMember
+   (module (moduleName (simpleId)) (moduleMember
+     (module (moduleName (simpleId))
+       (moduleMember (importDirective (importModuleExpr (moduleExpr (simpleId)))))
+       (moduleMember (classlessPredicate (predicate) (predicateName) (empty))))))))
+
+============
+module alias
+============
+
+module foo = bar::baz;
+
+---
+
+(ql (moduleMember (module (moduleName (simpleId)) (moduleAliasBody (moduleExpr (moduleExpr (simpleId)) (simpleId))))))
+
+==============================
+parameterised module signature
+==============================
+
+signature int supplyInt();
+
+signature module SupplyInt {
+  int get();
+  class C extends Foo, Bar;
+  predicate baz(C c);
+}
+
+---
+
+(ql
+  (moduleMember
+    (annotation
+      (annotName))
+    (classlessPredicate
+      (typeExpr
+        (primitiveType))
+      (predicateName)
+      (empty)))
+  (moduleMember
+    (annotation
+      (annotName))
+    (module
+      (moduleName
+        (simpleId))
+      (moduleMember
+        (classlessPredicate
+          (typeExpr
+            (primitiveType))
+          (predicateName)
+          (empty)))
+      (moduleMember
+        (dataclass
+          (className)
+          (typeExpr
+            (className))
+          (typeExpr
+            (className))))
+      (moduleMember
+        (classlessPredicate
+          (predicate)
+          (predicateName)
+          (varDecl
+            (typeExpr
+              (className))
+            (varName
+              (simpleId)))
+          (empty))))))
+
+================================
+parameterised module declaration
+================================
+
+module PModule<supplyInt/0 s1, SupplyInt S2> {
+  int foo() { result = s1() + S2::get() }
+}
+
+---
+
+(ql
+  (moduleMember
+    (module
+      (moduleName
+        (simpleId))
+      (moduleParam
+        (signatureExpr
+          (predicateExpr
+            (aritylessPredicateExpr
+              (literalId))
+            (integer)))
+        (simpleId))
+      (moduleParam
+        (signatureExpr
+          (typeExpr
+            (className)))
+        (simpleId))
+      (moduleMember
+        (classlessPredicate
+          (typeExpr
+            (primitiveType))
+          (predicateName)
+          (body
+            (comp_term
+              (variable
+                (result))
+              (compop)
+              (add_expr
+                (call_or_unqual_agg_expr
+                  (aritylessPredicateExpr
+                    (literalId))
+                  (call_body))
+                (addop)
+                (call_or_unqual_agg_expr
+                  (aritylessPredicateExpr
+                    (moduleExpr
+                      (simpleId))
+                    (literalId))
+                  (call_body))))))))))
+
+===============================
+parameterised module implements
+===============================
+
+module Supply11 implements SupplyInt {
+  int get() { result = 11 }
+}
+
+---
+
+(ql
+  (moduleMember
+    (module
+      (moduleName
+        (simpleId))
+      (signatureExpr
+        (typeExpr
+          (className)))
+      (moduleMember
+        (classlessPredicate
+          (typeExpr
+            (primitiveType))
+          (predicateName)
+          (body
+            (comp_term
+              (variable
+                (result))
+              (compop)
+              (literal
+                (integer)))))))))
+
+================================
+parameterised module application
+================================
+
+select PModule<supply6/0, supply10/0, Supply11, Supply15>::foo()
+
+---
+
+
+(ql
+  (moduleMember
+    (select
+      (asExprs
+        (asExpr
+          (call_or_unqual_agg_expr
+            (aritylessPredicateExpr
+              (moduleExpr
+                (moduleInstantiation
+                  (moduleName
+                    (simpleId))
+                  (signatureExpr
+                    (predicateExpr
+                      (aritylessPredicateExpr
+                        (literalId))
+                      (integer)))
+                  (signatureExpr
+                    (predicateExpr
+                      (aritylessPredicateExpr
+                        (literalId))
+                      (integer)))
+                  (signatureExpr
+                    (typeExpr
+                      (className)))
+                  (signatureExpr
+                    (typeExpr
+                      (className)))))
+              (literalId))
+            (call_body)))))))
+
+==================
+second application
+==================
+
+where node = DataFlow::BarrierGuard<containsDotDotSanitizer/3>::getABarrierNode()
+select 1
+
+---
+
+(ql
+  (moduleMember
+    (select
+      (comp_term
+        (variable
+          (varName
+            (simpleId)))
+        (compop)
+        (call_or_unqual_agg_expr
+          (aritylessPredicateExpr
+            (moduleExpr
+              (moduleExpr
+                (simpleId))
+              (moduleInstantiation
+                (moduleName
+                  (simpleId))
+                (signatureExpr
+                  (predicateExpr
+                    (aritylessPredicateExpr
+                      (literalId))
+                    (integer)))))
+            (literalId))
+          (call_body)))
+      (asExprs
+        (asExpr
+          (literal
+            (integer)))))))

vendor/tree-sitter-ql/test/corpus/operators_and_precedence.txt

@@ -0,0 +1,123 @@
+============
+And vs Or 1
+============
+
+from Foo f
+where f = f and f = f or f = f
+select f
+
+---
+
+(ql (moduleMember
+  (select
+    (varDecl (typeExpr (className)) (varName (simpleId)))
+    (disjunction
+      (conjunction
+        (comp_term (variable (varName (simpleId))) (compop) (variable (varName (simpleId))))
+        (comp_term (variable (varName (simpleId))) (compop) (variable (varName (simpleId)))))
+      (comp_term (variable (varName (simpleId))) (compop) (variable (varName (simpleId)))))
+    (asExprs (asExpr (variable (varName (simpleId))))))))
+
+============
+And vs Or 2
+============
+
+from Foo f
+where f = f or f = f and f = f
+select f
+
+---
+
+(ql (moduleMember
+  (select (varDecl (typeExpr (className)) (varName (simpleId)))
+    (disjunction
+      (comp_term (variable (varName (simpleId))) (compop) (variable (varName (simpleId))))
+      (conjunction
+        (comp_term (variable (varName (simpleId))) (compop) (variable (varName (simpleId))))
+        (comp_term (variable (varName (simpleId))) (compop) (variable (varName (simpleId))))))
+    (asExprs (asExpr (variable (varName (simpleId))))))))
+
+============
+Or vs implies
+============
+
+from Foo f
+where (f = f or f = f implies f = f)
+  and (f = f implies f = f or f = f)
+select f
+
+---
+
+(ql (moduleMember
+  (select
+    (varDecl (typeExpr (className)) (varName (simpleId)))
+    (conjunction
+      (par_expr
+        (implication
+          (disjunction
+            (comp_term (variable (varName (simpleId))) (compop) (variable (varName (simpleId))))
+            (comp_term (variable (varName (simpleId))) (compop) (variable (varName (simpleId)))))
+        (comp_term (variable (varName (simpleId))) (compop) (variable (varName (simpleId))))))
+      (par_expr
+        (implication
+          (comp_term (variable (varName (simpleId))) (compop) (variable (varName (simpleId))))
+          (disjunction
+            (comp_term (variable (varName (simpleId))) (compop) (variable (varName (simpleId))))
+            (comp_term (variable (varName (simpleId))) (compop) (variable (varName (simpleId))))))))
+    (asExprs (asExpr (variable (varName (simpleId))))))))
+
+============
+if then else
+============
+
+from Foo f
+where if f = f then f = f else f = f
+select f
+
+---
+
+(ql (moduleMember
+  (select
+    (varDecl (typeExpr (className)) (varName (simpleId)))
+    (if_term
+      (comp_term (variable (varName (simpleId))) (compop) (variable (varName (simpleId))))
+      (comp_term (variable (varName (simpleId))) (compop) (variable (varName (simpleId))))
+      (comp_term (variable (varName (simpleId))) (compop) (variable (varName (simpleId)))))
+  (asExprs (asExpr (variable (varName (simpleId))))))))
+
+==========
+and vs not
+==========
+
+from Foo f
+where not f = f and f = f
+select f
+
+---
+
+(ql (moduleMember
+  (select
+    (varDecl (typeExpr (className)) (varName (simpleId)))
+    (conjunction
+      (negation (comp_term (variable (varName (simpleId))) (compop) (variable (varName (simpleId)))))
+      (comp_term (variable (varName (simpleId))) (compop) (variable (varName (simpleId)))))
+    (asExprs (asExpr (variable (varName (simpleId))))))))
+
+==========
+call vs plus
+==========
+
+select a+(b)
+
+---
+
+(ql (moduleMember (select (asExprs (asExpr (call_or_unqual_agg_expr (aritylessPredicateExpr (literalId)) (closure) (call_body (variable (varName (simpleId))))))))))
+
+==========
+cast vs subtract
+==========
+
+select (A)-(b)
+
+---
+(ql (moduleMember (select (asExprs (asExpr (prefix_cast (typeExpr (className)) (unary_expr (unop) (par_expr (variable (varName (simpleId)))))))))))

vendor/tree-sitter-ql/test/corpus/predicates.txt

@@ -0,0 +1,90 @@
+=======
+no-body
+=======
+
+predicate foo();
+
+mod::Type foo(int arg, Foo arg);
+
+---
+
+(ql
+  (moduleMember (classlessPredicate (predicate) (predicateName) (empty)))
+  (moduleMember (classlessPredicate (typeExpr (moduleExpr (simpleId)) (className)) (predicateName)
+    (varDecl (typeExpr (primitiveType)) (varName (simpleId))) (varDecl (typeExpr (className)) (varName (simpleId))) (empty))))
+
+================
+simple predicate
+================
+
+predicate foo(F f){
+  f = f
+}
+
+int predicateWithResult(){
+  result = 43
+}
+
+---
+
+ (ql
+    (moduleMember (classlessPredicate (predicate) (predicateName) (varDecl (typeExpr (className)) (varName (simpleId))) (body
+      (comp_term (variable (varName (simpleId))) (compop) (variable (varName (simpleId)))))))
+    (moduleMember (classlessPredicate (typeExpr (primitiveType)) (predicateName) (body
+      (comp_term (variable (result)) (compop) (literal (integer)))))))
+
+=====================
+higher-order relation
+=====================
+
+int foo(X x, Y y) = name(pred1/1, pred2/3)(x.x(), result)
+
+---
+
+(ql (moduleMember
+  (classlessPredicate
+    (typeExpr (primitiveType))
+    (predicateName)
+    (varDecl (typeExpr (className)) (varName (simpleId)))
+    (varDecl (typeExpr (className)) (varName (simpleId)))
+    (higherOrderTerm (literalId)
+      (predicateExpr (aritylessPredicateExpr (literalId)) (integer))
+      (predicateExpr (aritylessPredicateExpr (literalId)) (integer))
+      (qualified_expr (variable (varName (simpleId))) (qualifiedRhs (predicateName)))
+      (variable (result))))))
+
+===============
+predicate alias
+===============
+
+predicate foo = somePredicate/12;
+
+---
+
+(ql (moduleMember (classlessPredicate
+  (predicate)
+  (predicateName) (predicateAliasBody (predicateExpr (aritylessPredicateExpr (literalId)) (integer))))))
+
+==========
+type union
+==========
+
+newtype T =
+  T1() or
+  T2(int x) { x = 1 or x = 2 } or
+  T3(int x) { x = 3 or x = 4 or x = 5 }
+
+class T2orT3 = T2 or T3;
+
+---
+
+(ql (moduleMember (datatype (className) (datatypeBranches
+      (datatypeBranch (className))
+      (datatypeBranch (className) (varDecl (typeExpr (primitiveType)) (varName (simpleId))) (body (disjunction
+        (comp_term (variable (varName (simpleId))) (compop) (literal (integer)))
+        (comp_term (variable (varName (simpleId))) (compop) (literal (integer))))))
+      (datatypeBranch (className) (varDecl (typeExpr (primitiveType)) (varName (simpleId))) (body (disjunction (disjunction
+        (comp_term (variable (varName (simpleId))) (compop) (literal (integer)))
+        (comp_term (variable (varName (simpleId))) (compop) (literal (integer))))
+        (comp_term (variable (varName (simpleId))) (compop) (literal (integer)))))))))
+    (moduleMember (dataclass (className) (typeUnionBody (typeExpr (className)) (typeExpr (className))))))

vendor/tree-sitter-ql/test/corpus/primary.txt

@@ -0,0 +1,136 @@
+======
+eparen
+======
+
+select (f).getAThing()
+
+---
+
+(ql (moduleMember (select (asExprs (asExpr (qualified_expr (par_expr (variable (varName (simpleId)))) (qualifiedRhs (predicateName))))))))
+
+=====
+super
+=====
+
+select super.foo(), module::Foo.super.foo()
+
+---
+
+(ql (moduleMember
+  (select
+    (asExprs
+      (asExpr (qualified_expr (super_ref (super)) (qualifiedRhs (predicateName))))
+      (asExpr (qualified_expr (super_ref (typeExpr (moduleExpr (simpleId)) (className)) (super)) (qualifiedRhs (predicateName))))))))
+
+============
+postfix cast
+============
+
+select f.(Foo).thing()
+
+---
+
+(ql (moduleMember (select (asExprs (asExpr (qualified_expr (qualified_expr (variable (varName (simpleId))) (qualifiedRhs (typeExpr (className)))) (qualifiedRhs (predicateName))))))))
+
+===
+any
+===
+
+select
+  any(Foo f),
+  any(Foo f | f = f),
+  any(Foo f | | f.thing()),
+  any(Foo f | f = f | f.thing())
+
+---
+
+(ql (moduleMember (select (asExprs
+  (asExpr (aggregate (aggId) (full_aggregate_body (varDecl (typeExpr (className)) (varName (simpleId))))))
+  (asExpr (aggregate (aggId) (full_aggregate_body (varDecl (typeExpr (className)) (varName (simpleId)))
+    (comp_term (variable (varName (simpleId))) (compop) (variable (varName (simpleId)))))))
+  (asExpr (aggregate (aggId)
+    (full_aggregate_body
+      (varDecl (typeExpr (className)) (varName (simpleId)))
+      (asExprs (asExpr (qualified_expr (variable (varName (simpleId))) (qualifiedRhs (predicateName))))))))
+  (asExpr (aggregate (aggId) (full_aggregate_body
+    (varDecl (typeExpr (className))
+      (varName (simpleId)))
+      (comp_term (variable (varName (simpleId))) (compop) (variable (varName (simpleId))))
+      (asExprs (asExpr (qualified_expr (variable (varName (simpleId))) (qualifiedRhs (predicateName))))))))))))
+
+
+=====
+range
+=====
+
+select [0..10]
+
+---
+
+(ql (moduleMember (select (asExprs (asExpr (range (literal (integer)) (literal (integer))))))))
+
+==========
+aggregates
+==========
+
+select
+  rank[123](Foo f),
+  count(f.thing()),
+  count(f.thing() as thing order by thing asc, thing desc),
+  count(Foo f),
+  count(f),
+  count (| | f),
+  count(),
+  count(Foo f | f.thing() ),
+  sum(Foo f | | f.x() ),
+  sum(Foo f | | f.x() as x),
+  sum(Foo f | | f.x() as x order by x),
+  sum(Foo f | | f.x() as x order by x asc, f.y()),
+  sum(Foo f | f.thing() | f.x() )
+
+---
+
+  (ql (moduleMember (select  (asExprs
+    (asExpr (aggregate (aggId) (literal (integer))
+      (full_aggregate_body (varDecl (typeExpr (className)) (varName (simpleId))))))
+    (asExpr (aggregate (aggId)
+      (expr_aggregate_body (asExprs (asExpr (qualified_expr (variable (varName (simpleId))) (qualifiedRhs (predicateName))))))))
+    (asExpr (aggregate (aggId)
+      (expr_aggregate_body (asExprs
+        (asExpr (qualified_expr (variable (varName (simpleId))) (qualifiedRhs (predicateName))) (varName (simpleId))))
+        (orderBys
+        (orderBy (variable (varName (simpleId))) (direction))
+        (orderBy (variable (varName (simpleId))) (direction))))))
+    (asExpr (aggregate (aggId) (full_aggregate_body (varDecl (typeExpr (className)) (varName (simpleId))))))
+    (asExpr (aggregate (aggId) (expr_aggregate_body (asExprs (asExpr (variable (varName (simpleId))))))))
+    (asExpr (aggregate (aggId) (full_aggregate_body (asExprs (asExpr (variable (varName (simpleId))))))))
+    (asExpr (aggregate (aggId)))
+    (asExpr (aggregate (aggId)
+      (full_aggregate_body (varDecl (typeExpr (className)) (varName (simpleId)))
+        (qualified_expr (variable (varName (simpleId))) (qualifiedRhs (predicateName))))))
+    (asExpr (aggregate (aggId)
+      (full_aggregate_body
+        (varDecl (typeExpr (className))
+        (varName (simpleId)))
+        (asExprs
+        (asExpr (qualified_expr (variable (varName (simpleId))) (qualifiedRhs (predicateName))))))))
+    (asExpr (aggregate (aggId)
+      (full_aggregate_body
+        (varDecl (typeExpr (className)) (varName (simpleId)))
+        (asExprs
+          (asExpr (qualified_expr (variable (varName (simpleId))) (qualifiedRhs (predicateName))) (varName (simpleId)))))))
+    (asExpr (aggregate (aggId) (full_aggregate_body
+      (varDecl (typeExpr (className)) (varName (simpleId)))
+      (asExprs
+        (asExpr (qualified_expr (variable (varName (simpleId))) (qualifiedRhs (predicateName))) (varName (simpleId))))
+        (orderBys  (orderBy (variable (varName (simpleId))))))))
+    (asExpr (aggregate (aggId)
+      (full_aggregate_body (varDecl (typeExpr (className)) (varName (simpleId)))
+        (asExprs (asExpr (qualified_expr (variable (varName (simpleId))) (qualifiedRhs (predicateName))) (varName (simpleId))))
+        (orderBys
+          (orderBy (variable (varName (simpleId))) (direction))
+          (orderBy (qualified_expr (variable (varName (simpleId))) (qualifiedRhs (predicateName))))))))
+    (asExpr (aggregate (aggId) (full_aggregate_body
+      (varDecl (typeExpr (className)) (varName (simpleId)))
+      (qualified_expr (variable (varName (simpleId))) (qualifiedRhs (predicateName)))
+      (asExprs (asExpr (qualified_expr (variable (varName (simpleId))) (qualifiedRhs (predicateName))))))))))))