@malloydata/malloy 0.0.43-dev230621212545 → 0.0.43-dev230622180905

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