@malloydata/malloy 0.0.22-dev230207144036 → 0.0.22-dev230207171614

package/dist/lang/parse-malloy.js

@@ -0,0 +1,728 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+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.MalloyTranslator = exports.MalloyTranslation = void 0;
+const antlr4ts_1 = require("antlr4ts");
+const MalloyLexer_1 = require("./lib/Malloy/MalloyLexer");
+const MalloyParser_1 = require("./lib/Malloy/MalloyParser");
+const ast = __importStar(require("./ast"));
+const malloy_to_ast_1 = require("./malloy-to-ast");
+const parse_log_1 = require("./parse-log");
+const find_external_references_1 = require("./parse-tree-walkers/find-external-references");
+const zone_1 = require("./zone");
+const document_symbol_walker_1 = require("./parse-tree-walkers/document-symbol-walker");
+const document_highlight_walker_1 = require("./parse-tree-walkers/document-highlight-walker");
+const document_completion_walker_1 = require("./parse-tree-walkers/document-completion-walker");
+const document_help_context_walker_1 = require("./parse-tree-walkers/document-help-context-walker");
+const reference_list_1 = require("./reference-list");
+const translate_response_1 = require("./translate-response");
+const parse_error_handler_1 = require("./parse-error-handler");
+/**
+ * This ignores a -> popMode when the mode stack is empty, which is a hack,
+ * but it let's us parse }%
+ */
+class HandlesOverpoppingLexer extends MalloyLexer_1.MalloyLexer {
+    popMode() {
+        if (this._modeStack.isEmpty) {
+            return this._mode;
+        }
+        return super.popMode();
+    }
+}
+class ParseStep {
+    step(that) {
+        if (this.response) {
+            return this.response;
+        }
+        if (that.urlIsFullPath === undefined) {
+            try {
+                const _checkFull = new URL(that.sourceURL);
+                that.urlIsFullPath = true;
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : "";
+                that.urlIsFullPath = false;
+                that.root.logger.log({
+                    message: `Could not compute full path URL: ${msg}`,
+                });
+            }
+        }
+        if (!that.urlIsFullPath) {
+            return that.fatalErrors();
+        }
+        const srcEnt = that.root.importZone.getEntry(that.sourceURL);
+        if (srcEnt.status !== "present") {
+            if (srcEnt.status === "error") {
+                const message = srcEnt.message.includes(that.sourceURL)
+                    ? `import error: ${srcEnt.message}`
+                    : `import '${that.sourceURL}' error: ${srcEnt.message}`;
+                const at = srcEnt.firstReference || that.defaultLocation();
+                that.root.logger.log({ message, at });
+                this.response = that.fatalErrors();
+                return this.response;
+            }
+            return { urls: [that.sourceURL] };
+        }
+        const source = srcEnt.value == "" ? "\n" : srcEnt.value;
+        this.sourceInfo = this.getSourceInfo(source);
+        let parse;
+        try {
+            parse = this.runParser(source, that);
+        }
+        catch (parseException) {
+            that.root.logger.log({
+                message: `Malloy internal parser exception [${parseException.message}]`,
+            });
+            parse = undefined;
+        }
+        if (that.root.logger.hasErrors()) {
+            this.response = {
+                parse,
+                ...that.fatalErrors(),
+            };
+        }
+        else {
+            this.response = { parse };
+        }
+        return this.response;
+    }
+    /**
+     * Split the source up into lines so we can correctly compute offset
+     * to the line/char positions favored by LSP and VSCode.
+     */
+    getSourceInfo(code) {
+        const eolRegex = /\r?\n/;
+        const info = {
+            at: [],
+            lines: [],
+            length: code.length,
+        };
+        let src = code;
+        let lineStart = 0;
+        while (src !== "") {
+            const eol = src.match(eolRegex);
+            if (eol && eol.index != undefined) {
+                // line text DOES NOT include the EOL
+                info.lines.push(src.slice(0, eol.index));
+                const lineLength = eol.index + eol[0].length;
+                info.at.push({
+                    begin: lineStart,
+                    end: lineStart + lineLength,
+                });
+                lineStart += lineLength;
+                src = src.slice(lineLength);
+            }
+            else {
+                // last line, does not have a line end
+                info.lines.push(src);
+                info.at.push({ begin: lineStart, end: lineStart + src.length });
+                break;
+            }
+        }
+        return info;
+    }
+    runParser(source, that) {
+        const inputStream = antlr4ts_1.CharStreams.fromString(source);
+        const lexer = new HandlesOverpoppingLexer(inputStream);
+        const tokenStream = new antlr4ts_1.CommonTokenStream(lexer);
+        const malloyParser = new MalloyParser_1.MalloyParser(tokenStream);
+        malloyParser.removeErrorListeners();
+        malloyParser.addErrorListener(new parse_error_handler_1.MalloyParserErrorHandler(that, that.root.logger));
+        // Admitted code smell here, testing likes to parse from an arbitrary
+        // node and this is the simplest way to allow that.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const parseFunc = malloyParser[that.grammarRule];
+        if (!parseFunc) {
+            throw new Error(`No such parse rule as ${that.grammarRule}`);
+        }
+        return {
+            root: parseFunc.call(malloyParser),
+            tokenStream: tokenStream,
+            sourceStream: inputStream,
+            // TODO put the real version here
+            malloyVersion: "?.?.?-????",
+            subTranslator: that,
+        };
+    }
+}
+class ImportsAndTablesStep {
+    constructor(parseStep) {
+        this.parseStep = parseStep;
+        this.alreadyLooked = false;
+    }
+    step(that) {
+        const parseReq = this.parseStep.step(that);
+        if (parseReq.parse == undefined) {
+            return parseReq;
+        }
+        if (!this.alreadyLooked) {
+            this.alreadyLooked = true;
+            const parseRefs = (0, find_external_references_1.findReferences)(that, parseReq.parse.tokenStream, parseReq.parse.root);
+            if (parseRefs === null || parseRefs === void 0 ? void 0 : parseRefs.tables) {
+                for (const ref in parseRefs.tables) {
+                    that.root.schemaZone.reference(ref, {
+                        url: that.sourceURL,
+                        range: parseRefs.tables[ref],
+                    });
+                }
+            }
+            if (parseRefs === null || parseRefs === void 0 ? void 0 : parseRefs.urls) {
+                for (const relativeRef in parseRefs.urls) {
+                    const firstRef = parseRefs.urls[relativeRef];
+                    try {
+                        const ref = decodeURI(new URL(relativeRef, that.sourceURL).toString());
+                        that.addChild(ref);
+                        that.root.importZone.reference(ref, {
+                            url: that.sourceURL,
+                            range: firstRef,
+                        });
+                    }
+                    catch (err) {
+                        // This import spec is so bad the URL library threw up, this
+                        // may be impossible, because it will append any garbage
+                        // to the known good rootURL assuming it is relative
+                        that.root.logger.log({
+                            message: `Malformed URL '${relativeRef}'"`,
+                            at: { url: that.sourceURL, range: firstRef },
+                        });
+                    }
+                }
+            }
+        }
+        if (that.root.logger.hasErrors()) {
+            // Since we knew we parsed without errors, this would only be from
+            // having a malformed URL on an import reference.
+            return null;
+        }
+        let allMissing = {};
+        const missingTables = that.root.schemaZone.getUndefined();
+        if (missingTables) {
+            allMissing = { tables: missingTables };
+        }
+        const missingImports = that.root.importZone.getUndefined();
+        if (missingImports) {
+            allMissing = { ...allMissing, urls: missingImports };
+        }
+        if ((0, translate_response_1.isNeedResponse)(allMissing)) {
+            return allMissing;
+        }
+        for (const child of that.childTranslators.values()) {
+            const kidNeeds = child.importsAndTablesStep.step(child);
+            if ((0, translate_response_1.isNeedResponse)(kidNeeds)) {
+                return kidNeeds;
+            }
+        }
+        return null;
+    }
+}
+class ASTStep {
+    constructor(importStep) {
+        this.importStep = importStep;
+        this.walked = false;
+    }
+    step(that) {
+        if (this.response) {
+            return this.response;
+        }
+        const mustResolve = this.importStep.step(that);
+        if (mustResolve) {
+            return mustResolve;
+        }
+        const parseResponse = that.parseStep.response;
+        // Errors in self or children will show up here ..
+        if (that.root.logger.hasErrors()) {
+            this.response = that.fatalErrors();
+            return this.response;
+        }
+        const parse = parseResponse === null || parseResponse === void 0 ? void 0 : parseResponse.parse;
+        if (!parse) {
+            throw new Error("TRANSLATOR INTERNAL ERROR: Translator parse response had no errors, but also no parser");
+        }
+        const secondPass = new malloy_to_ast_1.MalloyToAST(parse, that.root.logger);
+        const newAst = secondPass.visit(parse.root);
+        if (that.root.logger.hasErrors()) {
+            this.response = that.fatalErrors();
+            return this.response;
+        }
+        if (newAst.elementType === "unimplemented") {
+            throw new Error("TRANSLATOR INTERNAL ERROR: Unimplemented AST node");
+        }
+        // I kind of think table refs should probably also be collected here
+        // instead of in the parse step. Note to myself, do that someday.
+        const sqlExplores = {};
+        if (!this.walked) {
+            newAst.walk((walkedTo) => {
+                if (walkedTo instanceof ast.SQLSource) {
+                    if (!sqlExplores[walkedTo.refName]) {
+                        sqlExplores[walkedTo.refName] = {};
+                    }
+                    sqlExplores[walkedTo.refName].ref = walkedTo;
+                }
+                else if (walkedTo instanceof ast.SQLStatement && walkedTo.is) {
+                    if (!sqlExplores[walkedTo.is]) {
+                        sqlExplores[walkedTo.is] = {};
+                    }
+                    sqlExplores[walkedTo.is].def = walkedTo;
+                }
+                else if (walkedTo instanceof ast.Unimplemented) {
+                    walkedTo.log("INTERNAL COMPILER ERROR: Untranslated parse node");
+                }
+            });
+            this.walked = true;
+        }
+        // If there is a partial ast ...
+        if (that.root.logger.hasErrors()) {
+            this.response = that.fatalErrors();
+            return this.response;
+        }
+        /*
+    TODO we used to scna the AST for SQL blocks here, don't need to do that
+    becausae that happens at the translate step, but the code I need to
+    understand is how a root translate can return the need of a chiold
+    which has an SQL block ...
+    
+    */
+        // Now make sure that every child has fully translated itself
+        // before this tree is ready to also translate ...
+        for (const child of that.childTranslators.values()) {
+            const kidNeeds = child.astStep.step(child);
+            if ((0, translate_response_1.isNeedResponse)(kidNeeds)) {
+                return kidNeeds;
+            }
+        }
+        newAst.setTranslator(that);
+        this.response = {
+            ...that.errors(),
+            ast: newAst,
+            final: true,
+        };
+        return this.response;
+    }
+}
+class MetadataStep {
+    constructor(parseStep) {
+        this.parseStep = parseStep;
+    }
+    step(that) {
+        if (!this.response) {
+            const tryParse = this.parseStep.step(that);
+            if (!tryParse.parse) {
+                return tryParse;
+            }
+            else {
+                // Wrap the parse tree walker in a try block -- if the parse is bad, this walk
+                // could result in unexpected errors due to the parse tree not looking as expected.
+                // We still want to attempt to walk the tree, to preserve document symbols even
+                // when there's a bad parse, but we also want to be safe about it.
+                let symbols;
+                try {
+                    symbols = (0, document_symbol_walker_1.walkForDocumentSymbols)(that, tryParse.parse.tokenStream, tryParse.parse.root);
+                }
+                catch {
+                    // Do nothing, symbols already `undefined`
+                }
+                let walkHighlights;
+                try {
+                    walkHighlights = (0, document_highlight_walker_1.walkForDocumentHighlights)(tryParse.parse.tokenStream, tryParse.parse.root);
+                }
+                catch {
+                    walkHighlights = [];
+                }
+                this.response = {
+                    symbols,
+                    highlights: (0, document_highlight_walker_1.sortHighlights)([
+                        ...(0, document_highlight_walker_1.passForHighlights)(tryParse.parse.tokenStream),
+                        ...walkHighlights,
+                    ]),
+                    final: true,
+                };
+            }
+        }
+        return this.response;
+    }
+}
+class CompletionsStep {
+    constructor(parseStep) {
+        this.parseStep = parseStep;
+    }
+    step(that, position) {
+        const tryParse = this.parseStep.step(that);
+        if (!tryParse.parse) {
+            return tryParse;
+        }
+        else {
+            let completions = [];
+            if (position !== undefined) {
+                try {
+                    completions = (0, document_completion_walker_1.walkForDocumentCompletions)(tryParse.parse.tokenStream, tryParse.parse.root, position);
+                }
+                catch {
+                    /* Do nothing */
+                }
+            }
+            return {
+                ...tryParse,
+                completions,
+            };
+        }
+    }
+}
+class HelpContextStep {
+    constructor(parseStep) {
+        this.parseStep = parseStep;
+    }
+    step(that, position) {
+        const tryParse = this.parseStep.step(that);
+        if (!tryParse.parse) {
+            return tryParse;
+        }
+        else {
+            let helpContext;
+            if (position !== undefined) {
+                try {
+                    helpContext = (0, document_help_context_walker_1.walkForDocumentHelpContext)(tryParse.parse.root, position);
+                }
+                catch {
+                    /* Do nothing */
+                }
+            }
+            return {
+                ...tryParse,
+                helpContext,
+            };
+        }
+    }
+}
+class TranslateStep {
+    constructor(astStep) {
+        this.astStep = astStep;
+    }
+    step(that, extendingModel) {
+        if (this.response) {
+            return this.response;
+        }
+        const astResponse = this.astStep.step(that);
+        if ((0, translate_response_1.isNeedResponse)(astResponse)) {
+            return astResponse;
+        }
+        if (!astResponse.ast) {
+            this.response = astResponse;
+            return this.response;
+        }
+        if (that.grammarRule === "malloyDocument") {
+            if (astResponse.ast instanceof ast.Document) {
+                const doc = astResponse.ast;
+                doc.initModelDef(extendingModel);
+                for (;;) {
+                    const docCompile = doc.compile();
+                    if (docCompile.needs) {
+                        return docCompile.needs;
+                    }
+                    else {
+                        that.modelDef = docCompile.modelDef;
+                        that.queryList = docCompile.queryList;
+                        that.sqlBlocks = docCompile.sqlBlocks;
+                        break;
+                    }
+                }
+            }
+            else {
+                that.root.logger.log({
+                    message: `'${that.sourceURL}' did not parse to malloy document`,
+                    at: that.defaultLocation(),
+                });
+            }
+        }
+        if (that.root.logger.hasErrors()) {
+            this.response = that.fatalErrors();
+        }
+        else {
+            this.response = {
+                translated: {
+                    modelDef: that.modelDef,
+                    queryList: that.queryList,
+                    sqlBlocks: that.sqlBlocks,
+                },
+                ...that.errors(),
+                final: true,
+            };
+        }
+        return this.response;
+    }
+}
+class MalloyTranslation {
+    constructor(sourceURL, grammarRule = "malloyDocument") {
+        this.sourceURL = sourceURL;
+        this.grammarRule = grammarRule;
+        this.queryList = [];
+        this.sqlBlocks = [];
+        this.childTranslators = new Map();
+        this.modelDef = {
+            name: sourceURL,
+            exports: [],
+            contents: {},
+        };
+        /**
+         * This is sort of the makefile for the translation, all the steps
+         * and the dependencies of the steps are declared here. Then when
+         * a translator method is called which needs the result of a step,
+         * it asks the step what it needs to complete, and all the right
+         * things will happen automatically.
+         */
+        this.parseStep = new ParseStep();
+        this.metadataStep = new MetadataStep(this.parseStep);
+        this.completionsStep = new CompletionsStep(this.parseStep);
+        this.helpContextStep = new HelpContextStep(this.parseStep);
+        this.importsAndTablesStep = new ImportsAndTablesStep(this.parseStep);
+        this.astStep = new ASTStep(this.importsAndTablesStep);
+        this.translateStep = new TranslateStep(this.astStep);
+        this.references = new reference_list_1.ReferenceList(sourceURL);
+    }
+    addChild(url) {
+        if (!this.childTranslators.get(url)) {
+            this.childTranslators.set(url, new MalloyChildTranslator(url, this.root));
+        }
+    }
+    addReference(reference) {
+        this.references.add(reference);
+    }
+    referenceAt(position) {
+        return this.references.find(position);
+    }
+    fatalErrors() {
+        return {
+            final: true,
+            errors: [...this.root.logger.getLog()],
+        };
+    }
+    /**
+     * The error log can grow as progressively deeper questions are asked.
+     * When returning "errors so far", make a snapshot.
+     */
+    errors() {
+        const errors = this.root.logger.getLog();
+        return { errors: [...errors] };
+    }
+    getLineMap(url) {
+        var _a, _b;
+        if (url == this.sourceURL) {
+            return (_a = this.parseStep.sourceInfo) === null || _a === void 0 ? void 0 : _a.lines;
+        }
+        const theChild = this.childTranslators.get(url);
+        if (theChild) {
+            return (_b = theChild.parseStep.sourceInfo) === null || _b === void 0 ? void 0 : _b.lines;
+        }
+    }
+    prettyErrors() {
+        let lovely = "";
+        let inFile = "";
+        for (const entry of this.root.logger.getLog()) {
+            let cooked = entry.message;
+            let errorURL = this.sourceURL;
+            if (entry.at) {
+                errorURL = entry.at.url;
+                const lineNo = entry.at.range.start.line;
+                const charFrom = entry.at.range.start.character;
+                const lines = this.getLineMap(entry.at.url);
+                if (lines) {
+                    const errorLine = lines[lineNo];
+                    cooked = `line ${lineNo + 1}: ${entry.message}\n  | ${errorLine}`;
+                    if (charFrom > 0) {
+                        cooked = cooked + `\n  | ${" ".repeat(charFrom)}^`;
+                    }
+                }
+                else {
+                    cooked = `line ${lineNo + 1}: char ${charFrom}: ${entry.message}`;
+                }
+            }
+            if (inFile !== errorURL) {
+                cooked = `FILE: ${errorURL}\n` + cooked;
+                inFile = errorURL;
+            }
+            if (lovely !== "") {
+                lovely = `${lovely}\n${cooked}`;
+            }
+            else {
+                lovely = cooked;
+            }
+        }
+        return lovely;
+    }
+    childRequest(importURL) {
+        var _a;
+        const childURL = decodeURI(new URL(importURL, this.sourceURL).toString());
+        const ret = (_a = this.childTranslators.get(childURL)) === null || _a === void 0 ? void 0 : _a.translate();
+        if (ret === null || ret === void 0 ? void 0 : ret.compileSQL) {
+            return {
+                compileSQL: ret.compileSQL,
+                partialModel: ret.partialModel,
+            };
+        }
+    }
+    getChildExports(importURL) {
+        const exports = {};
+        const childURL = decodeURI(new URL(importURL, this.sourceURL).toString());
+        const child = this.childTranslators.get(childURL);
+        if (child) {
+            const did = child.translate();
+            if (did.translated) {
+                for (const fromChild of child.modelDef.exports) {
+                    const modelEntry = child.modelDef.contents[fromChild];
+                    if (modelEntry.type === "struct") {
+                        exports[fromChild] = modelEntry;
+                    }
+                }
+            }
+            // else nothing, assuming there are already errors in the log
+        }
+        return exports;
+    }
+    translate(extendingModel) {
+        if (this.finalAnswer) {
+            return this.finalAnswer;
+        }
+        const attempt = this.translateStep.step(this, extendingModel);
+        if (attempt.final) {
+            this.finalAnswer = attempt;
+        }
+        return attempt;
+    }
+    metadata() {
+        return this.metadataStep.step(this);
+    }
+    completions(position) {
+        return this.completionsStep.step(this, position);
+    }
+    helpContext(position) {
+        return this.helpContextStep.step(this, position);
+    }
+    defaultLocation() {
+        return {
+            url: this.sourceURL,
+            range: {
+                start: { line: 0, character: 0 },
+                end: { line: 0, character: 0 },
+            },
+        };
+    }
+    rangeFromContext(pcx) {
+        return this.rangeFromTokens(pcx.start, pcx.stop || pcx.start);
+    }
+    rangeFromTokens(startToken, stopToken) {
+        const start = {
+            line: startToken.line - 1,
+            character: startToken.charPositionInLine,
+        };
+        if (this.parseStep.sourceInfo && stopToken.stopIndex != -1) {
+            // Find the line which contains the stopIndex
+            const lastLine = this.parseStep.sourceInfo.lines.length - 1;
+            for (let lineNo = startToken.line - 1; lineNo <= lastLine; lineNo++) {
+                const at = this.parseStep.sourceInfo.at[lineNo];
+                if (stopToken.stopIndex >= at.begin && stopToken.stopIndex <= at.end) {
+                    return {
+                        start,
+                        end: {
+                            line: lineNo,
+                            character: stopToken.stopIndex - at.begin + 1,
+                        },
+                    };
+                }
+            }
+            // Should be impossible to get here, but if we do ... return the last
+            // character of the last line of the file
+            return {
+                start,
+                end: {
+                    line: lastLine,
+                    character: this.parseStep.sourceInfo.lines[lastLine].length,
+                },
+            };
+        }
+        return { start, end: start };
+    }
+    rangeFromToken(token) {
+        return this.rangeFromTokens(token, token);
+    }
+}
+exports.MalloyTranslation = MalloyTranslation;
+class MalloyChildTranslator extends MalloyTranslation {
+    constructor(rootURL, root) {
+        super(rootURL);
+        this.root = root;
+    }
+}
+/**
+ * The main interface to Malloy tranlsation. It has a call pattern
+ * similar to a server. Once a translator is instantiated
+ * you can request tralnsations repeatedly. Responses to that request
+ * will either be "NeedResponse" or "TranslateResponse" objects. The
+ * correct pattern is to call "translation" in a loop, calling
+ * "update" in response to each "NeedResponse" until a "TranslateResponse"
+ * is returned. If you get a response with "final:true", there is
+ * no need to call again, the translation is finished or error'd.
+ */
+class MalloyTranslator extends MalloyTranslation {
+    constructor(rootURL, preload = null) {
+        super(rootURL);
+        this.schemaZone = new zone_1.Zone();
+        this.importZone = new zone_1.Zone();
+        this.sqlQueryZone = new zone_1.Zone();
+        this.logger = new parse_log_1.MessageLog();
+        this.root = this;
+        if (preload) {
+            this.update(preload);
+        }
+    }
+    update(dd) {
+        var _a, _b, _c;
+        this.schemaZone.updateFrom(dd.tables, (_a = dd.errors) === null || _a === void 0 ? void 0 : _a.tables);
+        this.importZone.updateFrom(dd.urls, (_b = dd.errors) === null || _b === void 0 ? void 0 : _b.urls);
+        this.sqlQueryZone.updateFrom(dd.compileSQL, (_c = dd.errors) === null || _c === void 0 ? void 0 : _c.compileSQL);
+    }
+}
+exports.MalloyTranslator = MalloyTranslator;
+//# sourceMappingURL=parse-malloy.js.map