@malloydata/malloy 0.0.1

package/dist/lang/parse-malloy.js

@@ -0,0 +1,729 @@
+"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.MalloyTranslator = exports.MalloyTranslation = exports.SQLExploreZone = 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 parse_to_ast_1 = require("./parse-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");
+class MalloyParserErrorHandler {
+    constructor(translator, messages) {
+        this.translator = translator;
+        this.messages = messages;
+    }
+    syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, _e) {
+        const errAt = { line: line - 1, character: charPositionInLine };
+        const range = offendingSymbol
+            ? this.translator.rangeFromToken(offendingSymbol)
+            : { start: errAt, end: errAt };
+        const error = {
+            message: msg,
+            at: { url: this.translator.sourceURL, range },
+        };
+        this.messages.log(error);
+    }
+}
+/**
+ * An SQL Block contains a unique key inside it, and we use that to
+ * reference and define blocks, since Zone really wants keys to be strings.
+ *
+ * If I had SQLBlocks when Zones were defined, this would not be
+ * a one off class, it would be Zone<keyType,valueType>
+ */
+class SQLExploreZone extends zone_1.Zone {
+    constructor() {
+        super(...arguments);
+        this.keyed = {};
+    }
+    referenceBlock(from, at) {
+        const sql = from.sqlBlock();
+        this.reference(sql.name, at);
+        this.keyed[sql.name] = sql;
+    }
+    getUndefinedBlocks() {
+        const blockRefs = this.getUndefined();
+        if (blockRefs) {
+            return blockRefs.map((ref) => this.keyed[ref]);
+        }
+        return undefined;
+    }
+}
+exports.SQLExploreZone = SQLExploreZone;
+function isNeedResponse(dr) {
+    return !!dr && (dr.tables || dr.urls || dr.sqlStructs) != undefined;
+}
+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);
+        const parse = this.runParser(source, that);
+        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 MalloyLexer_1.MalloyLexer(inputStream);
+        const tokenStream = new antlr4ts_1.CommonTokenStream(lexer);
+        const malloyParser = new MalloyParser_1.MalloyParser(tokenStream);
+        malloyParser.removeErrorListeners();
+        malloyParser.addErrorListener(new 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 (isNeedResponse(allMissing)) {
+            return allMissing;
+        }
+        for (const child of that.childTranslators.values()) {
+            const kidNeeds = child.importsAndTablesStep.step(child);
+            if (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 parse_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;
+        }
+        // Make sure there is a request/reference for all explored-sql entities
+        const sqlZone = that.root.sqlQueryZone;
+        for (const sqlExploreRef in sqlExplores) {
+            const sqlExplore = sqlExplores[sqlExploreRef];
+            if (sqlExplore.ref && sqlExplore.def) {
+                const sqlAt = {
+                    url: that.sourceURL,
+                    range: sqlExplore.def.location.range,
+                };
+                that.root.sqlQueryZone.referenceBlock(sqlExplore.def, sqlAt);
+            }
+        }
+        // Now make sure that every child also has all sql blocks resolved
+        for (const child of that.childTranslators.values()) {
+            const kidNeeds = child.astStep.step(child);
+            if (isNeedResponse(kidNeeds)) {
+                return kidNeeds;
+            }
+        }
+        // TODO report errors from here!
+        const missingSqlStructs = sqlZone.getUndefinedBlocks();
+        if (missingSqlStructs) {
+            return { sqlStructs: missingSqlStructs };
+        }
+        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 (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;
+                that.modelDef = doc.getModelDef(extendingModel);
+                that.queryList = doc.queryList;
+                that.sqlBlocks = doc.sqlBlocks;
+            }
+            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;
+    }
+    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 SQLExploreZone();
+        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.sqlStructs, (_c = dd.errors) === null || _c === void 0 ? void 0 : _c.sqlStructs);
+    }
+}
+exports.MalloyTranslator = MalloyTranslator;
+//# sourceMappingURL=parse-malloy.js.map