@malloydata/malloy 0.0.1

package/dist/lang/parse-to-ast.js

@@ -0,0 +1,945 @@
+"use strict";
+/*
+ * Copyright 2021 Google LLC
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MalloyToAST = void 0;
+const AbstractParseTreeVisitor_1 = require("antlr4ts/tree/AbstractParseTreeVisitor");
+const ast = __importStar(require("./ast"));
+const Interval_1 = require("antlr4ts/misc/Interval");
+/**
+ * ANTLR visitor pattern parse tree traversal. Generates a Malloy
+ * AST from an ANTLR parse tree.
+ */
+class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
+    constructor(parse, msgLog) {
+        super();
+        this.parse = parse;
+        this.msgLog = msgLog;
+    }
+    /**
+     * Mostly used to flag a case where the grammar and the type system are
+     * no longer in sync. A visitor was written based on a grammar which
+     * apparently has changed and now an unexpected element type has appeared.
+     * This is a non recoverable error, since the parser and the grammar
+     * are not compatible.
+     * @returns an error object to throw.
+     */
+    internalError(cx, msg) {
+        const tmsg = `Internal Translator Error: ${msg}`;
+        this.contextError(cx, tmsg);
+        return new Error(tmsg);
+    }
+    /**
+     * Log an error message relative to an AST node
+     */
+    astError(el, str, sev = "error") {
+        this.msgLog.log({ message: str, at: el.location, severity: sev });
+    }
+    /**
+     * Log an error message relative to a parse node
+     */
+    contextError(cx, msg, sev = "error") {
+        this.msgLog.log({
+            message: msg,
+            at: {
+                url: this.parse.subTranslator.sourceURL,
+                range: this.parse.subTranslator.rangeFromContext(cx),
+            },
+            severity: sev,
+        });
+    }
+    onlyExploreProperties(els) {
+        const eps = [];
+        for (const el of els) {
+            if (ast.isExploreProperty(el)) {
+                eps.push(el);
+            }
+            else {
+                this.astError(el, `Expected explore property, not '${el.elementType}'`);
+            }
+        }
+        return eps;
+    }
+    onlyJoins(els) {
+        const eps = [];
+        for (const el of els) {
+            if (el instanceof ast.Join) {
+                eps.push(el);
+            }
+            else {
+                this.astError(el, `Expected explore property, not '${el.elementType}'`);
+            }
+        }
+        return eps;
+    }
+    onlyDocStatements(els) {
+        const eps = [];
+        for (const el of els) {
+            if (ast.isDocStatement(el)) {
+                eps.push(el);
+            }
+            else {
+                this.astError(el, `Expected statement, not '${el.elementType}'`);
+            }
+        }
+        return eps;
+    }
+    onlyNestedQueries(els) {
+        const eps = [];
+        for (const el of els) {
+            if (ast.isNestedQuery(el)) {
+                eps.push(el);
+            }
+            else {
+                this.astError(el, `Expected query, not '${el.elementType}'`);
+            }
+        }
+        return eps;
+    }
+    onlyQueryRefs(els) {
+        const eps = [];
+        for (const el of els) {
+            if (el instanceof ast.FieldReference ||
+                el instanceof ast.FieldDeclaration) {
+                eps.push(el);
+            }
+            else {
+                const reported = el instanceof ast.Unimplemented && el.reported;
+                if (!reported) {
+                    this.astError(el, `Expected query field, not '${el.elementType}'`);
+                }
+            }
+        }
+        return eps;
+    }
+    getNumber(term) {
+        return Number.parseInt(term.text);
+    }
+    getIdText(fromTerm) {
+        return this.stripQuotes(fromTerm.text);
+    }
+    getFieldName(cx) {
+        return this.astAt(new ast.FieldName(this.getIdText(cx)), cx);
+    }
+    getModelEntryName(cx) {
+        return this.astAt(new ast.ModelEntryReference(this.getIdText(cx)), cx);
+    }
+    stripQuotes(s) {
+        if (s[0] === "`" || s[0] === "'" || s[0] === '"') {
+            if (s[0] === s[s.length - 1]) {
+                return s.slice(1, -1);
+            }
+        }
+        return s;
+    }
+    optionalText(idCx) {
+        if (idCx) {
+            return this.getIdText(idCx);
+        }
+        return undefined;
+    }
+    defaultResult() {
+        return new ast.Unimplemented();
+    }
+    astAt(el, cx) {
+        el.location = {
+            url: this.parse.subTranslator.sourceURL,
+            range: this.parse.subTranslator.rangeFromContext(cx),
+        };
+        return el;
+    }
+    getSourceCode(cx) {
+        const from = cx.start.startIndex;
+        const lastToken = cx.stop || cx.start;
+        const sourceRange = new Interval_1.Interval(from, lastToken.stopIndex);
+        return this.parse.sourceStream.getText(sourceRange);
+    }
+    getFilterElement(cx) {
+        const expr = this.getFieldExpr(cx);
+        const fel = new ast.FilterElement(expr, this.getSourceCode(cx));
+        return this.astAt(fel, cx);
+    }
+    getFieldDefs(cxList, isAgg) {
+        const visited = [];
+        for (const cx of cxList) {
+            const v = this.visit(cx);
+            if (v instanceof ast.FieldDeclaration) {
+                this.astAt(v, cx);
+                visited.push(v);
+                if (isAgg !== undefined) {
+                    v.isMeasure = isAgg;
+                }
+            }
+            else {
+                this.contextError(cx, "Expected field definition");
+            }
+        }
+        return visited;
+    }
+    getFieldExpr(cx) {
+        const element = this.visit(cx);
+        if (element instanceof ast.ExpressionDef) {
+            return this.astAt(element, cx);
+        }
+        throw this.internalError(cx, `expression node unknown type '${element.elementType}'`);
+    }
+    getSegments(segments) {
+        return segments.map((cx) => this.visitQueryProperties(cx.queryProperties()));
+    }
+    getFilterShortcut(cx) {
+        const el = this.getFilterElement(cx.fieldExpr());
+        return new ast.Filter([el]);
+    }
+    getExploreSource(pcx) {
+        const element = this.visit(pcx);
+        if (element instanceof ast.Mallobj) {
+            return element;
+        }
+        throw this.internalError(pcx, `'${element.elementType}': illegal explore source`);
+    }
+    visitMalloyDocument(pcx) {
+        const stmts = this.onlyDocStatements(pcx.malloyStatement().map((scx) => this.visit(scx)));
+        return new ast.Document(stmts);
+    }
+    visitDefineExploreStatement(pcx) {
+        const defsCx = pcx.exploreDefinitionList().exploreDefinition();
+        const defs = defsCx.map((dcx) => this.visitExploreDefinition(dcx));
+        if (defs.length == 1) {
+            return defs[0];
+        }
+        return new ast.DefineSourceList(defs);
+    }
+    visitExploreDefinition(pcx) {
+        const exploreDef = new ast.DefineExplore(this.getIdText(pcx.exploreNameDef()), this.visitExplore(pcx.explore()), true, []);
+        return this.astAt(exploreDef, pcx);
+    }
+    visitExplore(pcx) {
+        const source = this.getExploreSource(pcx.exploreSource());
+        const refineCx = pcx.exploreProperties();
+        if (refineCx) {
+            return this.astAt(new ast.RefinedExplore(source, this.visitExploreProperties(refineCx)), pcx);
+        }
+        return source;
+    }
+    visitExploreProperties(pcx) {
+        const filterCx = pcx.filterShortcut();
+        const visited = pcx.exploreStatement().map((ecx) => this.visit(ecx));
+        const propList = new ast.ExploreDesc(this.onlyExploreProperties(visited));
+        if (filterCx) {
+            propList.push(this.getFilterShortcut(filterCx));
+        }
+        return propList;
+    }
+    visitExploreTable(pcx) {
+        const tableName = this.stripQuotes(pcx.tableName().text);
+        return this.astAt(new ast.TableSource(tableName), pcx);
+    }
+    visitTableSource(pcx) {
+        return this.visitExploreTable(pcx.exploreTable());
+    }
+    visitSQLSource(pcx) {
+        const name = this.getModelEntryName(pcx.sqlExploreNameRef());
+        return this.astAt(new ast.SQLSource(name), pcx);
+    }
+    visitQuerySource(pcx) {
+        const query = this.visit(pcx.query());
+        if (ast.isQueryElement(query)) {
+            return this.astAt(new ast.QuerySource(query), pcx);
+        }
+        throw this.internalError(pcx, `Expect query definition, got a '${query.elementType}'`);
+    }
+    visitDefJoinMany(pcx) {
+        const joinList = this.getJoinList(pcx.joinList());
+        const joins = [];
+        for (const join of joinList) {
+            if (join instanceof ast.Join) {
+                joins.push(join);
+                if (join instanceof ast.ExpressionJoin) {
+                    join.joinType = "many";
+                    if (join.joinOn == undefined) {
+                        join.log("join_many: requires ON expression");
+                    }
+                }
+                else if (join instanceof ast.KeyJoin) {
+                    join.log("Foreign key join not legal in join_many:");
+                }
+            }
+        }
+        return new ast.Joins(joins);
+    }
+    visitDefJoinOne(pcx) {
+        const joinList = this.getJoinList(pcx.joinList());
+        const joins = [];
+        for (const join of joinList) {
+            if (join instanceof ast.Join) {
+                joins.push(join);
+                if (join instanceof ast.ExpressionJoin) {
+                    join.joinType = "one";
+                }
+            }
+        }
+        return new ast.Joins(joins);
+    }
+    visitDefJoinCross(pcx) {
+        const joinList = this.getJoinList(pcx.joinList());
+        const joins = [];
+        for (const join of joinList) {
+            if (join instanceof ast.Join) {
+                joins.push(join);
+                if (join instanceof ast.ExpressionJoin) {
+                    join.joinType = "cross";
+                }
+                else {
+                    join.log("Foreign key join not legal in join_cross:");
+                }
+            }
+        }
+        return new ast.Joins(joins);
+    }
+    getJoinList(pcx) {
+        return pcx.joinDef().map((jcx) => this.visit(jcx));
+    }
+    getJoinSource(name, ecx) {
+        if (ecx) {
+            return this.visitExplore(ecx);
+        }
+        return new ast.NamedSource(name);
+    }
+    visitJoinOn(pcx) {
+        const joinAs = this.getModelEntryName(pcx.joinNameDef());
+        const joinFrom = this.getJoinSource(joinAs, pcx.explore());
+        const join = new ast.ExpressionJoin(joinAs, joinFrom);
+        const onCx = pcx.joinExpression();
+        if (onCx) {
+            join.joinOn = this.getFieldExpr(onCx);
+        }
+        return this.astAt(join, pcx);
+    }
+    visitJoinWith(pcx) {
+        const joinAs = this.getModelEntryName(pcx.joinNameDef());
+        const joinFrom = this.getJoinSource(joinAs, pcx.explore());
+        const joinOn = this.getFieldExpr(pcx.fieldExpr());
+        const join = new ast.KeyJoin(joinAs, joinFrom, joinOn);
+        return this.astAt(join, pcx);
+    }
+    visitFieldDef(pcx) {
+        const defCx = pcx.fieldExpr();
+        const fieldName = this.getIdText(pcx.fieldNameDef());
+        const valExpr = this.getFieldExpr(defCx);
+        const def = new ast.FieldDeclaration(valExpr, fieldName, this.getSourceCode(defCx));
+        return this.astAt(def, pcx);
+    }
+    visitDefExploreDimension(pcx) {
+        const defs = this.getFieldDefs(pcx.dimensionDefList().dimensionDef(), false);
+        const stmt = new ast.Dimensions(defs);
+        return this.astAt(stmt, pcx);
+    }
+    visitDefExploreMeasure(pcx) {
+        const defs = this.getFieldDefs(pcx.measureDefList().measureDef(), true);
+        const stmt = new ast.Measures(defs);
+        return this.astAt(stmt, pcx);
+    }
+    visitDeclareStatement(pcx) {
+        const defs = this.getFieldDefs(pcx.fieldDef(), true);
+        const stmt = new ast.DeclareFields(defs);
+        return this.astAt(stmt, pcx);
+    }
+    visitExploreRenameDef(pcx) {
+        const newName = pcx.fieldName(0).id();
+        const oldName = pcx.fieldName(1).id();
+        const rename = new ast.RenameField(this.getIdText(newName), this.getFieldName(oldName));
+        return this.astAt(rename, pcx);
+    }
+    visitDefExploreRename(pcx) {
+        const rcxs = pcx.renameList().exploreRenameDef();
+        const renames = rcxs.map((rcx) => this.visitExploreRenameDef(rcx));
+        const stmt = new ast.Renames(renames);
+        return this.astAt(stmt, pcx);
+    }
+    visitFilterClauseList(pcx) {
+        return new ast.Filter(pcx.fieldExpr().map((f) => this.getFilterElement(f)));
+    }
+    visitFilterByShortcut(pcx) {
+        const el = this.getFilterElement(pcx.fieldExpr());
+        return this.astAt(new ast.Filter([el]), pcx);
+    }
+    visitWhereStatement(pcx) {
+        const where = this.visitFilterClauseList(pcx.filterClauseList());
+        where.having = false;
+        return this.astAt(where, pcx);
+    }
+    visitHavingStatement(pcx) {
+        const having = this.visitFilterClauseList(pcx.filterClauseList());
+        having.having = true;
+        return this.astAt(having, pcx);
+    }
+    visitSubQueryDefList(pcx) {
+        const babyTurtles = pcx
+            .exploreQueryDef()
+            .map((cx) => this.visitExploreQueryDef(cx));
+        return new ast.Turtles(babyTurtles);
+    }
+    visitDefExplorePrimaryKey(pcx) {
+        const node = new ast.PrimaryKey(this.getFieldName(pcx.fieldName()));
+        return this.astAt(node, pcx);
+    }
+    visitFieldNameList(pcx) {
+        const members = pcx
+            .fieldName()
+            .map((cx) => new ast.FieldReference([this.getFieldName(cx)]));
+        return new ast.FieldReferences(members);
+    }
+    visitDefExploreEditField(pcx) {
+        const action = pcx.ACCEPT() ? "accept" : "except";
+        return new ast.FieldListEdit(action, this.visitFieldNameList(pcx.fieldNameList()));
+    }
+    visitQueryProperties(pcx) {
+        const qProps = pcx
+            .queryStatement()
+            .map((qcx) => this.astAt(this.visit(qcx), qcx))
+            .filter(function (p) {
+            if (ast.isQueryProperty(p)) {
+                return true;
+            }
+            p.log(`Unexpected statement type '${p.elementType}' in query`);
+            return false;
+        });
+        const fcx = pcx.filterShortcut();
+        if (fcx) {
+            qProps.push(this.getFilterShortcut(fcx));
+        }
+        return new ast.QOPDesc(qProps);
+    }
+    visitFieldPath(pcx) {
+        const names = pcx.fieldName().map((nameCx) => this.getFieldName(nameCx));
+        return this.astAt(new ast.FieldReference(names), pcx);
+    }
+    visitQueryFieldDef(pcx) {
+        const defCx = pcx.dimensionDef().fieldDef();
+        const dim = this.visitFieldDef(defCx);
+        return this.astAt(dim, defCx);
+    }
+    visitQueryFieldRef(pcx) {
+        return this.visitFieldPath(pcx.fieldPath());
+    }
+    // visitQueryFieldNameless(
+    //   pcx: parse.QueryFieldNamelessContext
+    // ): ast.MalloyElement {
+    //   this.contextError(pcx, `Expressions in queries must have names`);
+    //   const noItem = new ast.Unimplemented();
+    //   noItem.reported = true;
+    //   return noItem;
+    // }
+    getQueryItems(pcx) {
+        const itemList = pcx.queryFieldEntry().map((e) => this.visit(e));
+        return this.onlyQueryRefs(itemList);
+    }
+    visitAggregateStatement(pcx) {
+        return new ast.Aggregate(this.getQueryItems(pcx.queryFieldList()));
+    }
+    visitGroupByStatement(pcx) {
+        return new ast.GroupBy(this.getQueryItems(pcx.queryFieldList()));
+    }
+    visitFieldCollection(pcx) {
+        const fields = [];
+        for (const elCx of pcx.collectionMember()) {
+            const el = this.visit(elCx);
+            if (ast.isFieldCollectionMember(el)) {
+                fields.push(el);
+            }
+            else {
+                throw this.internalError(elCx, `${el.elementType} is not a query field`);
+            }
+        }
+        return this.astAt(new ast.ProjectStatement(fields), pcx);
+    }
+    visitWildMember(pcx) {
+        const nameCx = pcx.fieldPath();
+        const stars = pcx.STAR() ? "*" : "**";
+        const join = nameCx ? this.visitFieldPath(nameCx) : undefined;
+        return new ast.WildcardFieldReference(join, stars);
+    }
+    visitIndexFields(pcx) {
+        const refList = pcx.indexElement().map((el) => {
+            const hasStar = el.STAR() != undefined;
+            const pathCx = el.fieldPath();
+            if (!pathCx) {
+                return new ast.WildcardFieldReference(undefined, "*");
+            }
+            const path = this.visitFieldPath(pathCx);
+            if (!hasStar) {
+                return this.astAt(path, pcx);
+            }
+            return this.astAt(new ast.WildcardFieldReference(path, "*"), pcx);
+        });
+        return new ast.FieldReferences(refList);
+    }
+    visitIndexStatement(pcx) {
+        const fields = this.visitIndexFields(pcx.indexFields());
+        const indexStmt = new ast.Index(fields);
+        const weightCx = pcx.fieldName();
+        if (weightCx) {
+            indexStmt.useWeight(this.getFieldName(weightCx));
+        }
+        return this.astAt(indexStmt, pcx);
+    }
+    visitLimitStatement(pcx) {
+        return new ast.Limit(this.getNumber(pcx.INTEGER_LITERAL()));
+    }
+    visitOrderBySpec(pcx) {
+        const dir = pcx.ASC() ? "asc" : pcx.DESC() ? "desc" : undefined;
+        const ncx = pcx.INTEGER_LITERAL();
+        if (ncx) {
+            return new ast.OrderBy(this.getNumber(ncx), dir);
+        }
+        const fieldCx = pcx.fieldName();
+        if (fieldCx) {
+            return new ast.OrderBy(this.getFieldName(fieldCx), dir);
+        }
+        throw this.internalError(pcx, "can't parse order_by specification");
+    }
+    visitOrdering(pcx) {
+        const orderList = pcx.orderBySpec().map((o) => this.visitOrderBySpec(o));
+        return this.astAt(new ast.Ordering(orderList), pcx);
+    }
+    visitTopStatement(pcx) {
+        const byCx = pcx.bySpec();
+        const topN = this.getNumber(pcx.INTEGER_LITERAL());
+        let top;
+        if (byCx) {
+            const nameCx = byCx.fieldName();
+            if (nameCx) {
+                const name = this.getFieldName(nameCx);
+                top = new ast.Top(topN, name);
+            }
+            const exprCx = byCx.fieldExpr();
+            if (exprCx) {
+                top = new ast.Top(topN, this.getFieldExpr(exprCx));
+            }
+        }
+        if (!top) {
+            top = new ast.Top(topN, undefined);
+        }
+        return this.astAt(top, pcx);
+    }
+    visitExploreName(pcx) {
+        const name = this.getModelEntryName(pcx.id());
+        return this.astAt(new ast.NamedSource(name), pcx);
+    }
+    buildPipelineFromName(pipe, pipeCx) {
+        const firstCx = pipeCx.firstSegment();
+        const nameCx = firstCx.exploreQueryName();
+        if (nameCx) {
+            pipe.turtleName = this.getFieldName(nameCx);
+        }
+        const propsCx = firstCx.queryProperties();
+        if (propsCx) {
+            const queryDesc = this.visitQueryProperties(propsCx);
+            if (nameCx) {
+                pipe.refineHead(queryDesc);
+            }
+            else {
+                pipe.addSegments(queryDesc);
+            }
+        }
+        const tail = this.getSegments(pipeCx.pipeElement());
+        pipe.addSegments(...tail);
+    }
+    visitExploreArrowQuery(pcx) {
+        const root = this.visitExplore(pcx.explore());
+        const query = new ast.FullQuery(root);
+        this.buildPipelineFromName(query, pcx.pipelineFromName());
+        return this.astAt(query, pcx);
+    }
+    visitArrowQuery(pcx) {
+        const query = new ast.ExistingQuery();
+        query.head = this.getModelEntryName(pcx.queryName());
+        const refCx = pcx.queryProperties();
+        if (refCx) {
+            query.refineHead(this.visitQueryProperties(refCx));
+        }
+        query.addSegments(...this.getSegments(pcx.pipeElement()));
+        return this.astAt(query, pcx);
+    }
+    visitTopLevelQueryDefs(pcx) {
+        const stmts = pcx
+            .topLevelQueryDef()
+            .map((cx) => this.visitTopLevelQueryDef(cx));
+        if (stmts.length === 1) {
+            return stmts[0];
+        }
+        return new ast.DefineQueryList(stmts);
+    }
+    visitTopLevelQueryDef(pcx) {
+        const queryName = this.getIdText(pcx.queryName());
+        const queryDef = this.visit(pcx.query());
+        if (ast.isQueryElement(queryDef)) {
+            return this.astAt(new ast.DefineQuery(queryName, queryDef), pcx);
+        }
+        throw this.internalError(pcx, `Expect query definition, got a '${queryDef.elementType}'`);
+    }
+    visitAnonymousQuery(pcx) {
+        const query = this.visit(pcx.topLevelAnonQueryDef().query());
+        if (ast.isQueryElement(query)) {
+            return new ast.AnonymousQuery(query);
+        }
+        throw this.internalError(pcx, `Anonymous query matched, but ${query.elementType} found`);
+    }
+    visitNestedQueryList(pcx) {
+        const nestedList = pcx.nestEntry().map((cx) => this.visit(cx));
+        if (nestedList.length == 1) {
+            return nestedList[0];
+        }
+        return new ast.Nests(this.onlyNestedQueries(nestedList));
+    }
+    visitNestExisting(pcx) {
+        const name = this.getFieldName(pcx.queryName());
+        const propsCx = pcx.queryProperties();
+        if (propsCx) {
+            const nestRefine = new ast.NestRefinement(name);
+            const queryDesc = this.visitQueryProperties(propsCx);
+            nestRefine.refineHead(queryDesc);
+            return this.astAt(nestRefine, pcx);
+        }
+        return this.astAt(new ast.NestReference(name), pcx);
+    }
+    visitNestDef(pcx) {
+        const name = this.getIdText(pcx.queryName());
+        const nestDef = new ast.NestDefinition(name);
+        this.buildPipelineFromName(nestDef, pcx.pipelineFromName());
+        return this.astAt(nestDef, pcx);
+    }
+    visitExploreQueryDef(pcx) {
+        const name = this.getIdText(pcx.exploreQueryNameDef());
+        const queryDef = new ast.TurtleDecl(name);
+        this.buildPipelineFromName(queryDef, pcx.pipelineFromName());
+        return this.astAt(queryDef, pcx);
+    }
+    visitExprNot(pcx) {
+        return new ast.ExprNot(this.getFieldExpr(pcx.fieldExpr()));
+    }
+    visitExprBool(pcx) {
+        return new ast.Boolean(pcx.TRUE() ? "true" : "false");
+    }
+    allFieldExpressions(exprList) {
+        return exprList.map((ecx) => this.getFieldExpr(ecx));
+    }
+    visitExprLogical(pcx) {
+        const left = this.getFieldExpr(pcx.fieldExpr(0));
+        const right = this.getFieldExpr(pcx.fieldExpr(1));
+        return new ast.ExprLogicalOp(left, pcx.AND() ? "and" : "or", right);
+    }
+    visitExprLogicalTree(pcx) {
+        const left = this.getFieldExpr(pcx.fieldExpr());
+        const right = this.getFieldExpr(pcx.partialAllowedFieldExpr());
+        return new ast.ExprAlternationTree(left, pcx.AMPER() ? "&" : "|", right);
+    }
+    visitExprNotPartial(pcx) {
+        return this.getFieldExpr(pcx.fieldExpr());
+    }
+    visitExprPartialCompare(pcx) {
+        const op = pcx.compareOp().text;
+        if (ast.isComparison(op)) {
+            return new ast.PartialCompare(op, this.getFieldExpr(pcx.fieldExpr()));
+        }
+        throw this.internalError(pcx, `partial comparison '${op}' not recognized`);
+    }
+    visitExprString(pcx) {
+        return new ast.ExprString(pcx.STRING_LITERAL().text);
+    }
+    visitExprRegex(pcx) {
+        const malloyRegex = pcx.HACKY_REGEX().text;
+        return new ast.ExprRegEx(this.stripQuotes(malloyRegex.slice(1)));
+    }
+    visitExprNow(_pcx) {
+        return new ast.ExprNow();
+    }
+    visitExprNumber(pcx) {
+        var _a, _b;
+        const number = ((_a = pcx.INTEGER_LITERAL()) === null || _a === void 0 ? void 0 : _a.text) || ((_b = pcx.NUMERIC_LITERAL()) === null || _b === void 0 ? void 0 : _b.text);
+        /*
+         * I "know" one of these is true because grammar, but Typescript
+         * rightly points out that grammvisitExprFieldPathar can change in unexpected ways
+         */
+        if (number) {
+            return new ast.ExprNumber(number);
+        }
+        else {
+            this.contextError(pcx, `'${pcx.text}' is not a number`);
+            return new ast.ExprNumber("42");
+        }
+    }
+    visitExprFieldPath(pcx) {
+        const idRef = new ast.ExprIdReference(this.visitFieldPath(pcx.fieldPath()));
+        return this.astAt(idRef, pcx);
+    }
+    visitExprNULL(_pcx) {
+        return new ast.ExprNULL();
+    }
+    visitExprExpr(pcx) {
+        return new ast.ExprParens(this.getFieldExpr(pcx.partialAllowedFieldExpr()));
+    }
+    visitExprMinus(pcx) {
+        return new ast.ExprMinus(this.getFieldExpr(pcx.fieldExpr()));
+    }
+    visitExprAddSub(pcx) {
+        const lhs = this.getFieldExpr(pcx.fieldExpr(0));
+        const rhs = this.getFieldExpr(pcx.fieldExpr(1));
+        const op = pcx.PLUS() ? "+" : "-";
+        return new ast.ExprAddSub(lhs, op, rhs);
+    }
+    visitExprMulDiv(pcx) {
+        return new ast.ExprMulDiv(this.getFieldExpr(pcx.fieldExpr(0)), pcx.STAR() ? "*" : "/", this.getFieldExpr(pcx.fieldExpr(1)));
+    }
+    visitExprCompare(pcx) {
+        const op = pcx.compareOp().text;
+        if (ast.isComparison(op)) {
+            return new ast.ExprCompare(this.getFieldExpr(pcx.fieldExpr(0)), op, this.getFieldExpr(pcx.fieldExpr(1)));
+        }
+        throw this.internalError(pcx, `untranslatable comparison operator '${op}'`);
+    }
+    visitExprCountDisinct(pcx) {
+        return this.astAt(new ast.ExprCountDistinct(this.getFieldExpr(pcx.fieldExpr())), pcx);
+    }
+    visitExprUngroup(pcx) {
+        const flist = pcx.fieldName().map((fcx) => this.getFieldName(fcx));
+        const kw = this.getIdText(pcx.ungroup()).toLocaleLowerCase();
+        return this.astAt(new ast.ExprUngroup(kw == "all" ? kw : "exclude", this.getFieldExpr(pcx.fieldExpr()), flist), pcx);
+    }
+    visitExprAggregate(pcx) {
+        const pathCx = pcx.fieldPath();
+        const path = pathCx ? this.visitFieldPath(pathCx) : undefined;
+        const source = pathCx && path ? this.astAt(path, pathCx) : undefined;
+        const exprDef = pcx.fieldExpr();
+        if (pcx.aggregate().COUNT()) {
+            if (exprDef) {
+                this.contextError(exprDef, "Ignored expression inside COUNT()");
+            }
+            return new ast.ExprCount(source);
+        }
+        // * was ok in count, not ok now ... this should be in grammer but at
+        // the moment while things are still changing its right to be caught here
+        const star = pcx.STAR();
+        if (star) {
+            this.contextError(pcx, "'*' is not a valid expression");
+        }
+        const expr = exprDef ? this.getFieldExpr(exprDef) : undefined;
+        if (pcx.aggregate().MIN()) {
+            if (path) {
+                this.contextError(pcx, `Path not legal for min()`);
+            }
+            else if (expr) {
+                return new ast.ExprMin(expr);
+            }
+            else {
+                this.contextError(pcx, "Missing expression for min");
+            }
+        }
+        else if (pcx.aggregate().MAX()) {
+            if (path) {
+                this.contextError(pcx, `Path not legal for max()`);
+            }
+            else if (expr) {
+                return new ast.ExprMax(expr);
+            }
+            else {
+                this.contextError(pcx, "Missing expression for max");
+            }
+        }
+        else if (pcx.aggregate().AVG()) {
+            return new ast.ExprAvg(expr, source);
+        }
+        else if (pcx.aggregate().SUM()) {
+            return new ast.ExprSum(expr, source);
+        }
+        return new ast.ExprNULL();
+    }
+    visitExprApply(pcx) {
+        if (pcx.COLON()) {
+            this.contextError(pcx, "':' for apply is deprecated, use '?'", "warn");
+        }
+        return new ast.Apply(this.getFieldExpr(pcx.fieldExpr()), this.getFieldExpr(pcx.partialAllowedFieldExpr()));
+    }
+    visitExprRange(pcx) {
+        return new ast.Range(this.getFieldExpr(pcx.fieldExpr(0)), this.getFieldExpr(pcx.fieldExpr(1)));
+    }
+    visitExprCast(pcx) {
+        const type = pcx.malloyType().text;
+        if (ast.isCastType(type)) {
+            return new ast.ExprCast(this.getFieldExpr(pcx.fieldExpr()), type);
+        }
+        this.contextError(pcx, `CAST to unknown type '${type}'`);
+        return new ast.ExprNULL();
+    }
+    visitExprSafeCast(pcx) {
+        const type = pcx.malloyType().text;
+        if (ast.isCastType(type)) {
+            return new ast.ExprCast(this.getFieldExpr(pcx.fieldExpr()), type, true);
+        }
+        this.contextError(pcx, `'::' cast to unknown type '${type}'`);
+        return new ast.ExprNULL();
+    }
+    visitExprTimeTrunc(pcx) {
+        return new ast.ExprGranularTime(this.getFieldExpr(pcx.fieldExpr()), this.visitTimeframe(pcx.timeframe()).text, true);
+    }
+    visitTimeframe(pcx) {
+        return new ast.Timeframe(pcx.text);
+    }
+    visitExprForRange(pcx) {
+        const begin = this.getFieldExpr(pcx._startAt);
+        const duration = this.getFieldExpr(pcx._duration);
+        const units = this.visitTimeframe(pcx.timeframe());
+        return new ast.ForRange(begin, duration, units);
+    }
+    visitExprFunc(pcx) {
+        const argsCx = pcx.argumentList();
+        const args = argsCx ? this.allFieldExpressions(argsCx.fieldExpr()) : [];
+        const idCx = pcx.id();
+        const dCx = pcx.timeframe();
+        let fn;
+        if (idCx) {
+            fn = this.getIdText(idCx);
+        }
+        else if (dCx) {
+            fn = dCx.text;
+        }
+        else {
+            this.contextError(pcx, "Funciton name error");
+            fn = "FUNCTION_NAME_ERROR";
+        }
+        if (ast.ExprTimeExtract.extractor(fn)) {
+            return this.astAt(new ast.ExprTimeExtract(fn, args), pcx);
+        }
+        return this.astAt(new ast.ExprFunc(fn, args), pcx);
+    }
+    visitExprDuration(pcx) {
+        return new ast.ExprDuration(this.getFieldExpr(pcx.fieldExpr()), this.visitTimeframe(pcx.timeframe()).text);
+    }
+    visitPickStatement(pcx) {
+        const picks = pcx.pick().map((pwCx) => {
+            let pickExpr;
+            if (pwCx._pickValue) {
+                pickExpr = this.getFieldExpr(pwCx._pickValue);
+            }
+            return new ast.PickWhen(pickExpr, this.getFieldExpr(pwCx._pickWhen));
+        });
+        if (pcx.ELSE()) {
+            return new ast.Pick(picks, this.getFieldExpr(pcx._pickElse));
+        }
+        return new ast.Pick(picks);
+    }
+    visitNamedSource(pcx) {
+        const name = this.getModelEntryName(pcx.exploreName());
+        // Parameters ... coming ...
+        // const paramListCx = pcx.isParam();
+        // if (paramListCx) {
+        //   const paramInit: Record<string, ast.ConstantSubExpression> = {};
+        //   for (const cx of paramListCx) {
+        //     const pName = this.identifer(cx.id());
+        //     const pVal = this.getFieldExpr(cx.isExpr().partialAllowedFieldExpr());
+        //     paramInit[pName] = new ast.ConstantSubExpression(pVal);
+        //   }
+        //   return this.astAt(new ast.NamedSource(name, paramInit), pcx);
+        // }
+        return this.astAt(new ast.NamedSource(name), pcx);
+    }
+    visitExprFilter(pcx) {
+        const filters = this.visit(pcx.filteredBy());
+        return new ast.ExprFilter(this.getFieldExpr(pcx.fieldExpr()), filters);
+    }
+    getLiteralTime(cx) {
+        const parsed = ast.GranularLiteral.parse(cx.text);
+        if (parsed === undefined) {
+            this.contextError(cx, `${cx.text} is not a legal day specification`);
+            return new ast.ExprNow();
+        }
+        return parsed;
+    }
+    visitLiteralTimestamp(pcx) {
+        return this.getLiteralTime(pcx);
+    }
+    visitLiteralDay(pcx) {
+        return this.getLiteralTime(pcx);
+    }
+    visitLiteralWeek(pcx) {
+        return this.getLiteralTime(pcx);
+    }
+    visitLiteralMonth(pcx) {
+        return this.getLiteralTime(pcx);
+    }
+    visitLiteralQuarter(pcx) {
+        return this.getLiteralTime(pcx);
+    }
+    visitLiteralYear(pcx) {
+        return this.getLiteralTime(pcx);
+    }
+    visitImportStatement(pcx) {
+        const url = this.stripQuotes(pcx.importURL().text);
+        return this.astAt(new ast.ImportStatement(url, this.parse.subTranslator.sourceURL), pcx);
+    }
+    visitJustExpr(pcx) {
+        return this.getFieldExpr(pcx.fieldExpr());
+    }
+    visitDefineSQLStatement(pcx) {
+        return this.visitSQLStatementDef(pcx.sqlStatementDef());
+    }
+    visitSQLStatementDef(pcx) {
+        const commands = pcx.sqlBlock().text;
+        const sqlStmt = new ast.SQLStatement({
+            select: commands.slice(2, commands.length - 2),
+            connection: this.optionalText(pcx.connectionName()),
+        });
+        const nameCx = pcx.sqlCommandNameDef();
+        if (nameCx) {
+            sqlStmt.is = this.getIdText(nameCx);
+        }
+        return this.astAt(sqlStmt, pcx);
+    }
+    visitSampleStatement(pcx) {
+        const rowCx = pcx.sampleSpec().INTEGER_LITERAL();
+        if (rowCx) {
+            return new ast.SampleProperty({ rows: this.getNumber(rowCx) });
+        }
+        const limitCx = pcx.sampleSpec().PERCENT_LITERAL();
+        if (limitCx) {
+            return new ast.SampleProperty({ percent: this.getNumber(limitCx) });
+        }
+        const enabled = pcx.sampleSpec().TRUE() != undefined;
+        return new ast.SampleProperty({ enable: enabled });
+    }
+}
+exports.MalloyToAST = MalloyToAST;
+//# sourceMappingURL=parse-to-ast.js.map