@malloydata/malloy 0.0.43-dev230622144455 → 0.0.43-dev230622180905

package/dist/lang/ast/expressions/expr-func.js

@@ -76,6 +76,9 @@ class ExprFunc extends expression_def_1.ExpressionDef {
             this.log(`Cannot call '${this.name}', which is of type ${func.type}`);
             return (0, ast_utils_1.errorFor)('called non function');
         }
+        if (func.name !== this.name) {
+            this.log(`Case insensitivity for function names is deprecated, use '${func.name}' instead`, 'warn');
+        }
         // Find the 'implicit argument' for aggregate functions called like `some_join.some_field.agg(...args)`
         // where the full arg list is `(some_field, ...args)`.
         let implicitExpr = undefined;

package/dist/lang/ast/types/malloy-element.d.ts

@@ -1,4 +1,5 @@
 import { DocumentLocation, DocumentReference, ModelDef, Query, SQLBlockStructDef } from '../../../model/malloy_types';
+import { LogSeverity } from '../../parse-log';
 import { MalloyTranslation } from '../../parse-malloy';
 import { ModelDataRequest } from '../../translate-response';
 import { DocumentCompileResult } from './document-compile-result';
@@ -31,7 +32,7 @@ export declare abstract class MalloyElement {
     private get sourceURL();
     errorsExist(): boolean;
     private readonly logged;
-    log(message: string): void;
+    log(message: string, severity?: LogSeverity): void;
     /**
      * Mostly for debugging / testing. A string-y version of this object which
      * is used to ask "are these two AST segments equal". Formatted so that

package/dist/lang/ast/types/malloy-element.js

@@ -151,7 +151,7 @@ class MalloyElement {
         }
         return true;
     }
-    log(message) {
+    log(message, severity = 'error') {
         if (this.codeLocation) {
             /*
              * If this element has a location, then don't report the same
@@ -163,7 +163,7 @@ class MalloyElement {
             this.logged.add(message);
         }
         const trans = this.translator();
-        const msg = { at: this.location, message };
+        const msg = { at: this.location, message, severity };
         const logTo = trans === null || trans === void 0 ? void 0 : trans.root.logger;
         if (logTo) {
             logTo.log(msg);

package/dist/lang/parse-error-handler.js

@@ -36,6 +36,7 @@ class MalloyParserErrorHandler {
         const error = {
             message: msg,
             at: { url: this.translator.sourceURL, range },
+            severity: 'error',
         };
         this.messages.log(error);
     }

package/dist/lang/parse-log.d.ts

@@ -6,7 +6,7 @@ export declare type LogSeverity = 'error' | 'warn' | 'debug';
 export interface LogMessage {
     message: string;
     at?: DocumentLocation;
-    severity?: LogSeverity;
+    severity: LogSeverity;
 }
 export interface MessageLogger {
     log(logMsg: LogMessage): void;

package/dist/lang/parse-malloy.d.ts

@@ -1,10 +1,10 @@
 import { CodePointCharStream, CommonTokenStream, ParserRuleContext, Token } from 'antlr4ts';
 import { ParseTree } from 'antlr4ts/tree';
 import { DocumentLocation, DocumentPosition, DocumentRange, DocumentReference, ModelDef, NamedModelObject, Query, SQLBlockStructDef, StructDef } from '../model/malloy_types';
-import { MessageLog } from './parse-log';
+import { LogMessage, MessageLog } from './parse-log';
 import { Zone, ZoneData } from './zone';
 import { ReferenceList } from './reference-list';
-import { ASTResponse, CompletionsResponse, DataRequestResponse, ErrorResponse, FatalResponse, FinalResponse, HelpContextResponse, MetadataResponse, ModelDataRequest, NeedURLData, TranslateResponse } from './translate-response';
+import { ASTResponse, CompletionsResponse, DataRequestResponse, ProblemResponse, FatalResponse, FinalResponse, HelpContextResponse, MetadataResponse, ModelDataRequest, NeedURLData, TranslateResponse } from './translate-response';
 export declare type StepResponses = DataRequestResponse | ASTResponse | TranslateResponse | ParseResponse | MetadataResponse;
 /**
  * A Translation is a series of translation steps. Each step can depend
@@ -28,7 +28,7 @@ export interface MalloyParseRoot {
     subTranslator: MalloyTranslation;
     malloyVersion: string;
 }
-interface ParseData extends ErrorResponse, NeedURLData, FinalResponse {
+interface ParseData extends ProblemResponse, NeedURLData, FinalResponse {
     parse: MalloyParseRoot;
 }
 export declare type ParseResponse = Partial<ParseData>;
@@ -116,12 +116,18 @@ export declare abstract class MalloyTranslation {
     addChild(url: string): void;
     addReference(reference: DocumentReference): void;
     referenceAt(position: DocumentPosition): DocumentReference | undefined;
-    fatalErrors(): FatalResponse;
     /**
-     * The error log can grow as progressively deeper questions are asked.
-     * When returning "errors so far", make a snapshot.
+     * This returns a *final* response containing all problems, for when there are
+     * errors and the translation needs to stop and report errors. When doing so,
+     * it also reports warnings.
      */
-    errors(): ErrorResponse;
+    fatalResponse(): FatalResponse;
+    /**
+     * The problem log can grow as progressively deeper questions are asked.
+     * When returning "problems so far", make a snapshot.
+     */
+    problemResponse(): ProblemResponse;
+    problems(): LogMessage[];
     getLineMap(url: string): string[] | undefined;
     prettyErrors(): string;
     childRequest(importURL: string): ModelDataRequest;

package/dist/lang/parse-malloy.js

@@ -88,11 +88,12 @@ class ParseStep {
                 that.urlIsFullPath = false;
                 that.root.logger.log({
                     message: `Could not compute full path URL: ${msg}`,
+                    severity: 'error',
                 });
             }
         }
         if (!that.urlIsFullPath) {
-            return that.fatalErrors();
+            return that.fatalResponse();
         }
         const srcEnt = that.root.importZone.getEntry(that.sourceURL);
         if (srcEnt.status !== 'present') {
@@ -101,8 +102,8 @@ class ParseStep {
                     ? `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();
+                that.root.logger.log({ message, at, severity: 'error' });
+                this.response = that.fatalResponse();
                 return this.response;
             }
             return { urls: [that.sourceURL] };
@@ -116,13 +117,14 @@ class ParseStep {
         catch (parseException) {
             that.root.logger.log({
                 message: `Malloy internal parser exception [${parseException.message}]`,
+                severity: 'error',
             });
             parse = undefined;
         }
         if (that.root.logger.hasErrors()) {
             this.response = {
                 parse,
-                ...that.fatalErrors(),
+                ...that.fatalResponse(),
             };
         }
         else {
@@ -228,6 +230,7 @@ class ImportsAndTablesStep {
                         that.root.logger.log({
                             message: `Malformed URL '${relativeRef}'"`,
                             at: { url: that.sourceURL, range: firstRef },
+                            severity: 'error',
                         });
                     }
                 }
@@ -275,7 +278,7 @@ class ASTStep {
         const parseResponse = that.parseStep.response;
         // Errors in self or children will show up here ..
         if (that.root.logger.hasErrors()) {
-            this.response = that.fatalErrors();
+            this.response = that.fatalResponse();
             return this.response;
         }
         const parse = parseResponse === null || parseResponse === void 0 ? void 0 : parseResponse.parse;
@@ -285,7 +288,7 @@ class ASTStep {
         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();
+            this.response = that.fatalResponse();
             return this.response;
         }
         if (newAst.elementType === 'unimplemented') {
@@ -316,7 +319,7 @@ class ASTStep {
         }
         // If there is a partial ast ...
         if (that.root.logger.hasErrors()) {
-            this.response = that.fatalErrors();
+            this.response = that.fatalResponse();
             return this.response;
         }
         /*
@@ -336,7 +339,7 @@ class ASTStep {
         }
         newAst.setTranslator(that);
         this.response = {
-            ...that.errors(),
+            ...that.problemResponse(),
             ast: newAst,
             final: true,
         };
@@ -474,11 +477,12 @@ class TranslateStep {
                 that.root.logger.log({
                     message: `'${that.sourceURL}' did not parse to malloy document`,
                     at: that.defaultLocation(),
+                    severity: 'error',
                 });
             }
         }
         if (that.root.logger.hasErrors()) {
-            this.response = that.fatalErrors();
+            this.response = that.fatalResponse();
         }
         else {
             this.response = {
@@ -487,7 +491,7 @@ class TranslateStep {
                     queryList: that.queryList,
                     sqlBlocks: that.sqlBlocks,
                 },
-                ...that.errors(),
+                ...that.problemResponse(),
                 final: true,
             };
         }
@@ -533,19 +537,26 @@ class MalloyTranslation {
     referenceAt(position) {
         return this.references.find(position);
     }
-    fatalErrors() {
+    /**
+     * This returns a *final* response containing all problems, for when there are
+     * errors and the translation needs to stop and report errors. When doing so,
+     * it also reports warnings.
+     */
+    fatalResponse() {
         return {
             final: true,
-            errors: [...this.root.logger.getLog()],
+            ...this.problemResponse(),
         };
     }
     /**
-     * The error log can grow as progressively deeper questions are asked.
-     * When returning "errors so far", make a snapshot.
+     * The problem log can grow as progressively deeper questions are asked.
+     * When returning "problems so far", make a snapshot.
      */
-    errors() {
-        const errors = this.root.logger.getLog();
-        return { errors: [...errors] };
+    problemResponse() {
+        return { problems: this.problems() };
+    }
+    problems() {
+        return [...this.root.logger.getLog()];
     }
     getLineMap(url) {
         var _a, _b;

package/dist/lang/test/parse-expects.d.ts

@@ -1,5 +1,11 @@
 import { DocumentLocation } from '../../model';
-declare type ErrorSpec = string | RegExp;
+import { LogSeverity } from '../parse-log';
+declare type SimpleProblemSpec = string | RegExp;
+declare type ComplexProblemSpec = {
+    severity: LogSeverity;
+    message: SimpleProblemSpec;
+};
+declare type ProblemSpec = SimpleProblemSpec | ComplexProblemSpec;
 declare global {
     namespace jest {
         interface Matchers<R> {
@@ -24,6 +30,19 @@ declare global {
              * the markings.
              */
             toTranslate(): R;
+            /**
+             * expect(X).toTranslateWithWarnings(expectedWarnings)
+             *
+             * Passes if the source compiles to code which could be used to
+             * generate SQL, and the specified warnings appear. If X is a marked
+             * source, the warnings which are found must match the locations of
+             * the markings.
+             *
+             * X can be a MarkedSource, a string, or a model. If it is a marked
+             * source, the errors which are found must match the locations of
+             * the markings.
+             */
+            toTranslateWithWarnings(...expectedWarnings: SimpleProblemSpec[]): R;
             toReturnType(tp: string): R;
             /**
              * expect(X).translateToFailWith(expectedErrors)
@@ -35,7 +54,7 @@ declare global {
              * @param expectedErrors varargs list of strings which must match
              *        exactly, or regular expressions.
              */
-            translationToFailWith(...expectedErrors: ErrorSpec[]): R;
+            translationToFailWith(...expectedErrors: ProblemSpec[]): R;
             isLocationIn(at: DocumentLocation, txt: string): R;
         }
     }

package/dist/lang/test/parse-expects.js

@@ -25,13 +25,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const test_translator_1 = require("./test-translator");
 const util_1 = require("util");
-function checkForErrors(trans) {
+function ensureNoProblems(trans) {
     if (trans.logger === undefined) {
         throw new Error('JESTERY BROKEN, CANT FIND ERORR LOG');
     }
-    if (trans.logger.hasErrors()) {
+    if (!trans.logger.empty()) {
         return {
-            message: () => `Translation Errors:\n${trans.prettyErrors()}`,
+            message: () => `Translation problems:\n${trans.prettyErrors()}`,
             pass: false,
         };
     }
@@ -92,6 +92,19 @@ function highlightError(dl, txt) {
     }
     return output.join('\n');
 }
+function normalizeProblemSpec(defaultSeverity) {
+    return function (spec) {
+        if (typeof spec === 'string') {
+            return { severity: defaultSeverity, message: spec };
+        }
+        else if (spec instanceof RegExp) {
+            return { severity: defaultSeverity, message: spec };
+        }
+        else {
+            return spec;
+        }
+    };
+}
 function isMarkedSource(ts) {
     return typeof ts !== 'string' && !(ts instanceof test_translator_1.TestTranslator);
 }
@@ -105,7 +118,7 @@ function xlator(ts) {
     return ts.translator || new test_translator_1.TestTranslator(ts.code);
 }
 function xlated(tt) {
-    const errorCheck = checkForErrors(tt);
+    const errorCheck = ensureNoProblems(tt);
     if (!errorCheck.pass) {
         return errorCheck;
     }
@@ -116,7 +129,7 @@ expect.extend({
     toParse: function (tx) {
         const x = xlator(tx);
         x.compile();
-        return checkForErrors(x);
+        return ensureNoProblems(x);
     },
     toTranslate: function (tx) {
         const x = xlator(tx);
@@ -136,74 +149,10 @@ expect.extend({
         return { pass, message: () => msg };
     },
     translationToFailWith: function (s, ...msgs) {
-        var _a;
-        let emsg = 'Compile Error expectation not met\nExpected message';
-        const mSrc = isMarkedSource(s) ? s : undefined;
-        const qmsgs = msgs.map(s => `error '${s}'`);
-        if (msgs.length === 1) {
-            emsg += ` ${qmsgs[0]}`;
-        }
-        else {
-            emsg += `s [\n${qmsgs.join('\n')}\n]`;
-        }
-        const m = xlator(s);
-        const src = m.testSrc;
-        emsg += `\nSource:\n${src}`;
-        m.compile();
-        const t = m.translate();
-        if (t.translated) {
-            return { pass: false, message: () => emsg };
-        }
-        else if (t.errors === undefined) {
-            return {
-                pass: false,
-                message: () => 'TEST ERROR, not all objects resolved in source\n' +
-                    (0, test_translator_1.pretty)(t) +
-                    '\n' +
-                    emsg,
-            };
-        }
-        else {
-            const explain = [];
-            const errList = m.errors().errors;
-            let i;
-            for (i = 0; i < msgs.length && errList[i]; i += 1) {
-                const msg = msgs[i];
-                const err = errList[i];
-                const matched = typeof msg === 'string'
-                    ? msg === err.message
-                    : err.message.match(msg);
-                if (!matched) {
-                    explain.push(`Expected: ${msg}\nGot: ${err.message}`);
-                }
-                else {
-                    if (mSrc === null || mSrc === void 0 ? void 0 : mSrc.locations[i]) {
-                        const have = (_a = err.at) === null || _a === void 0 ? void 0 : _a.range;
-                        const want = mSrc.locations[i].range;
-                        if (!this.equals(have, want)) {
-                            explain.push(`Expected '${msg}' at location: ${(0, util_1.inspect)(want)}\n` +
-                                `Actual location: ${(0, util_1.inspect)(have)}`);
-                        }
-                    }
-                }
-            }
-            if (i !== msgs.length) {
-                explain.push(...msgs.slice(i).map(m => `Missing: ${m}`));
-            }
-            if (i !== errList.length) {
-                explain.push(...errList.slice(i).map(m => `Unexpected Error: ${m.message}`));
-            }
-            if (explain.length === 0) {
-                return {
-                    pass: true,
-                    message: () => `All expected errors found: ${(0, test_translator_1.pretty)(msgs)}`,
-                };
-            }
-            return {
-                pass: false,
-                message: () => `Compiler did not generated expected errors\n${explain.join('\n')}`,
-            };
-        }
+        return checkForProblems(this, false, s, 'error', ...msgs);
+    },
+    toTranslateWithWarnings: function (s, ...msgs) {
+        return checkForProblems(this, true, s, 'warn', ...msgs);
     },
     isLocationIn: function (checkAt, at, text) {
         if (this.equals(at, checkAt)) {
@@ -221,4 +170,79 @@ expect.extend({
         };
     },
 });
+function checkForProblems(context, expectCompiles, s, defaultSeverity, ...msgs) {
+    var _a;
+    let emsg = `Expected ${expectCompiles ? 'to' : 'to not'} compile with: `;
+    const mSrc = isMarkedSource(s) ? s : undefined;
+    const normalize = normalizeProblemSpec(defaultSeverity);
+    const normMsgs = msgs.map(normalize);
+    const qmsgs = normMsgs.map(s => `${s.severity} '${s.message}'`);
+    if (msgs.length === 1) {
+        emsg += ` ${qmsgs[0]}`;
+    }
+    else {
+        emsg += `s [\n${qmsgs.join('\n')}\n]`;
+    }
+    const m = xlator(s);
+    const src = m.testSrc;
+    emsg += `\nSource:\n${src}`;
+    m.compile();
+    const t = m.translate();
+    if (t.translated && !expectCompiles) {
+        return { pass: false, message: () => emsg };
+    }
+    else if (t.problems === undefined) {
+        return {
+            pass: false,
+            message: () => 'TEST ERROR, not all objects resolved in source\n' +
+                (0, test_translator_1.pretty)(t) +
+                '\n' +
+                emsg,
+        };
+    }
+    else {
+        const explain = [];
+        const errList = m.problemResponse().problems;
+        let i;
+        for (i = 0; i < normMsgs.length && errList[i]; i += 1) {
+            const msg = normMsgs[i];
+            const err = errList[i];
+            const matched = typeof msg.message === 'string'
+                ? msg.message === err.message
+                : err.message.match(msg.message);
+            if (err.severity !== msg.severity) {
+                explain.push(`Expected ${msg.severity}, got ${err.severity} ${err.message}`);
+            }
+            if (!matched) {
+                explain.push(`Expected: ${msg.message}\nGot: ${err.message}`);
+            }
+            else {
+                if (mSrc === null || mSrc === void 0 ? void 0 : mSrc.locations[i]) {
+                    const have = (_a = err.at) === null || _a === void 0 ? void 0 : _a.range;
+                    const want = mSrc.locations[i].range;
+                    if (!context.equals(have, want)) {
+                        explain.push(`Expected '${msg.message}' at location: ${(0, util_1.inspect)(want)}\n` +
+                            `Actual location: ${(0, util_1.inspect)(have)}`);
+                    }
+                }
+            }
+        }
+        if (i !== msgs.length) {
+            explain.push(...msgs.slice(i).map(m => `Missing: ${m}`));
+        }
+        if (i !== errList.length) {
+            explain.push(...errList.slice(i).map(m => `Unexpected Error: ${m.message}`));
+        }
+        if (explain.length === 0) {
+            return {
+                pass: true,
+                message: () => `All expected errors found: ${(0, test_translator_1.pretty)(msgs)}`,
+            };
+        }
+        return {
+            pass: false,
+            message: () => `Compiler did not generated expected errors\n${explain.join('\n')}`,
+        };
+    }
+}
 //# sourceMappingURL=parse-expects.js.map

package/dist/lang/test/parse.spec.js

@@ -85,7 +85,7 @@ describe('model statements', () => {
       `).toTranslate();
         });
         test('from(query) refined into query', () => {
-            expect('query: from(ab -> {group_by: astr}) { dimension: bigstr is UPPER(astr) } -> { group_by: bigstr }').toTranslate();
+            expect('query: from(ab -> {group_by: astr}) { dimension: bigstr is upper(astr) } -> { group_by: bigstr }').toTranslate();
         });
         test('query with shortcut filtered turtle', () => {
             expect("query: allA is ab->aturtle {? astr ~ 'a%' }").toTranslate();
@@ -371,6 +371,11 @@ describe('model statements', () => {
                 expect(`query: a -> {
           group_by: s is concat('a', 'b')
         }`).toTranslate();
+            });
+            test('function incorrect case', () => {
+                expect(`query: a -> {
+          group_by: s is CONCAT('a', 'b')
+        }`).toTranslateWithWarnings("Case insensitivity for function names is deprecated, use 'concat' instead");
             });
             test('function no matching overload', () => {
                 expect(`query: a -> {
@@ -1531,7 +1536,7 @@ describe('error handling', () => {
         expect('source: na is a { rename: astr is astr }').translationToFailWith("Can't rename field to itself");
     });
     test('reference to field in its definition', () => {
-        expect('source: na is a { dimension: ustr is UPPER(ustr) } ').translationToFailWith("Circular reference to 'ustr' in definition");
+        expect('source: na is a { dimension: ustr is upper(ustr) } ').translationToFailWith("Circular reference to 'ustr' in definition");
     });
     test('empty model', () => {
         expect('').toTranslate();
@@ -2336,7 +2341,6 @@ describe('translation need error locations', () => {
             errors: { urls: { [(result.urls || [])[0]]: 'Bad file!' } },
         });
         expect(source).translationToFailWith(/Bad file!/);
-        return undefined;
     });
     test('sql struct error location', () => {
         const source = (0, test_translator_1.markSource) `
@@ -2351,7 +2355,7 @@ describe('translation need error locations', () => {
             m.update({ errors: { compileSQL: { [req.name]: 'Bad SQL!' } } });
         }
         expect(m).not.toTranslate();
-        const errList = m.errors().errors;
+        const errList = m.problems();
         expect(errList[0].at).isLocationIn(source.locations[0], source.code);
     });
     test('table struct error location', () => {

package/dist/lang/test/sql-block.spec.js

@@ -176,7 +176,7 @@ describe('sql:', () => {
         extModel.importZone.define('sqlblocktest://main', 'query: malloy_source -> { project: * }');
         const tr = extModel.translate(modelDef);
         // because extModel is not a TestTranslator we can't use the hotness
-        expect(tr.errors).toEqual([]);
+        expect(tr.problems).toEqual([]);
         expect(tr.translated).toBeDefined();
     });
 });

package/dist/lang/test/test-translator.js

@@ -284,6 +284,7 @@ class TestTranslator extends parse_malloy_1.MalloyTranslator {
                 this.logger.log({
                     at: this.defaultLocation(),
                     message: `Missing imports: ${whatImports.join(',')}`,
+                    severity: 'error',
                 });
             }
             const needThese = this.schemaZone.getUndefined();
@@ -292,12 +293,14 @@ class TestTranslator extends parse_malloy_1.MalloyTranslator {
                 this.logger.log({
                     at: this.defaultLocation(),
                     message: `Missing schema: ${needThese.join(',')}`,
+                    severity: 'error',
                 });
             }
             if (mysterious) {
                 this.logger.log({
                     at: this.defaultLocation(),
                     message: 'mysterious translation failure',
+                    severity: 'error',
                 });
             }
         }

package/dist/lang/translate-response.d.ts

@@ -12,10 +12,10 @@ import { DocumentHelpContext } from './parse-tree-walkers/document-help-context-
 export interface FinalResponse {
     final: true;
 }
-export interface ErrorResponse {
-    errors: LogMessage[];
+export interface ProblemResponse {
+    problems: LogMessage[];
 }
-export declare type FatalResponse = FinalResponse & ErrorResponse;
+export declare type FatalResponse = FinalResponse & ProblemResponse;
 export interface NeedSchemaData {
     tables: string[];
 }
@@ -31,24 +31,24 @@ interface NeededData extends NeedURLData, NeedSchemaData, NeedCompileSQL {
 export declare type DataRequestResponse = Partial<NeededData> | null;
 export declare function isNeedResponse(dr: DataRequestResponse): dr is NeededData;
 export declare type ModelDataRequest = NeedCompileSQL | undefined;
-interface ASTData extends ErrorResponse, NeededData, FinalResponse {
+interface ASTData extends ProblemResponse, NeededData, FinalResponse {
     ast: MalloyElement;
 }
 export declare type ASTResponse = Partial<ASTData>;
-interface Metadata extends NeededData, ErrorResponse, FinalResponse {
+interface Metadata extends NeededData, ProblemResponse, FinalResponse {
     symbols: DocumentSymbol[];
     highlights: DocumentHighlight[];
 }
 export declare type MetadataResponse = Partial<Metadata>;
-interface Completions extends NeededData, ErrorResponse, FinalResponse {
+interface Completions extends NeededData, ProblemResponse, FinalResponse {
     completions: DocumentCompletion[];
 }
 export declare type CompletionsResponse = Partial<Completions>;
-interface HelpContext extends NeededData, ErrorResponse, FinalResponse {
+interface HelpContext extends NeededData, ProblemResponse, FinalResponse {
     helpContext: DocumentHelpContext | undefined;
 }
 export declare type HelpContextResponse = Partial<HelpContext>;
-interface TranslatedResponseData extends NeededData, ErrorResponse, FinalResponse {
+interface TranslatedResponseData extends NeededData, ProblemResponse, FinalResponse {
     translated: {
         modelDef: ModelDef;
         queryList: Query[];

package/dist/malloy.d.ts

@@ -134,11 +134,11 @@ export declare class Malloy {
  * A Malloy error, which may contain log messages produced during compilation.
  */
 export declare class MalloyError extends Error {
+    readonly problems: LogMessage[];
     /**
      * An array of log messages produced during compilation.
      */
-    readonly log: LogMessage[];
-    constructor(message: string, log?: LogMessage[]);
+    constructor(message: string, problems?: LogMessage[]);
 }
 /**
  * A compiled Malloy document.
@@ -148,7 +148,8 @@ export declare class Model {
     private queryList;
     private sqlBlocks;
     _referenceAt: (location: ModelDocumentPosition) => DocumentReference | undefined;
-    constructor(modelDef: ModelDef, queryList: InternalQuery[], sqlBlocks: SQLBlockStructDef[], referenceAt?: (location: ModelDocumentPosition) => DocumentReference | undefined);
+    readonly problems: LogMessage[];
+    constructor(modelDef: ModelDef, queryList: InternalQuery[], sqlBlocks: SQLBlockStructDef[], problems: LogMessage[], referenceAt?: (location: ModelDocumentPosition) => DocumentReference | undefined);
     /**
      * Retrieve a document reference for the token at the given position within
      * the document that produced this model.

package/dist/malloy.js

@@ -78,10 +78,10 @@ class Malloy {
             const result = translator.translate(model === null || model === void 0 ? void 0 : model._modelDef);
             if (result.final) {
                 if (result.translated) {
-                    return new Model(result.translated.modelDef, result.translated.queryList, result.translated.sqlBlocks, (position) => translator.referenceAt(position));
+                    return new Model(result.translated.modelDef, result.translated.queryList, result.translated.sqlBlocks, result.problems || [], (position) => translator.referenceAt(position));
                 }
                 else {
-                    const errors = result.errors || [];
+                    const errors = result.problems || [];
                     const errText = translator.prettyErrors();
                     throw new MalloyError(`Error(s) compiling model:\n${errText}`, errors);
                 }
@@ -304,9 +304,12 @@ exports.Malloy = Malloy;
  * A Malloy error, which may contain log messages produced during compilation.
  */
 class MalloyError extends Error {
-    constructor(message, log = []) {
+    /**
+     * An array of log messages produced during compilation.
+     */
+    constructor(message, problems = []) {
         super(message);
-        this.log = log;
+        this.problems = problems;
     }
 }
 exports.MalloyError = MalloyError;
@@ -314,11 +317,12 @@ exports.MalloyError = MalloyError;
  * A compiled Malloy document.
  */
 class Model {
-    constructor(modelDef, queryList, sqlBlocks, referenceAt = () => undefined) {
+    constructor(modelDef, queryList, sqlBlocks, problems, referenceAt = () => undefined) {
         this.modelDef = modelDef;
         this.queryList = queryList;
         this.sqlBlocks = sqlBlocks;
         this._referenceAt = referenceAt;
+        this.problems = problems;
     }
     /**
      * Retrieve a document reference for the token at the given position within
@@ -894,7 +898,7 @@ class Explore extends Entity {
         };
     }
     getSingleExploreModel() {
-        return new Model(this.modelDef, [], []);
+        return new Model(this.modelDef, [], [], []);
     }
     get fieldMap() {
         var _a;
@@ -1396,7 +1400,7 @@ class Runtime {
     //      be used in tests.
     _loadModelFromModelDef(modelDef) {
         return new ModelMaterializer(this, async () => {
-            return new Model(modelDef, [], []);
+            return new Model(modelDef, [], [], []);
         });
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.43-dev230622144455",
+  "version": "0.0.43-dev230622180905",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",