@malloydata/malloy 0.0.43-dev230621212545 → 0.0.43-dev230622180905

package/dist/lang/ast/ast-utils.js

@@ -33,7 +33,7 @@ exports.errorFor = void 0;
  */
 function errorFor(reason) {
     return {
-        dataType: 'unknown',
+        dataType: 'error',
         expressionType: 'scalar',
         value: [`_ERROR_${reason.replace(/ /g, '_')}`],
         evalSpace: 'constant',

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

@@ -48,8 +48,12 @@ class ExprCoalesce extends expression_def_1.ExpressionDef {
          * SQL, but I decided that is will happen when the "expressions are true
          * trees" rewrite happens.
          */
+        if (!fragtype_utils_1.FT.typeEq(maybeNull, whenNull)) {
+            this.log(`Mismatched types for coalesce (${maybeNull.dataType}, ${whenNull.dataType})`);
+        }
         return {
             ...whenNull,
+            dataType: maybeNull.dataType === 'error' ? whenNull.dataType : maybeNull.dataType,
             expressionType: (0, model_1.maxExpressionType)(maybeNull.expressionType, whenNull.expressionType),
             value: (0, model_1.mkExpr) `COALESCE(${maybeNull.value},${whenNull.value})`,
             evalSpace: (0, model_1.mergeEvalSpaces)(maybeNull.evalSpace, whenNull.evalSpace),

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

@@ -70,21 +70,14 @@ class ExprFunc extends expression_def_1.ExpressionDef {
         const func = (_c = this.modelEntry(this.name.toLowerCase())) === null || _c === void 0 ? void 0 : _c.entry;
         if (func === undefined) {
             this.log(`Unknown function '${this.name}'. Use '${this.name}!(...)' to call a SQL function directly.`);
-            return {
-                dataType: 'unknown',
-                expressionType: 'scalar',
-                value: [],
-                evalSpace: 'constant',
-            };
+            return (0, ast_utils_1.errorFor)('unknown function');
         }
         else if (func.type !== 'function') {
             this.log(`Cannot call '${this.name}', which is of type ${func.type}`);
-            return {
-                dataType: 'unknown',
-                expressionType: 'scalar',
-                value: [],
-                evalSpace: 'constant',
-            };
+            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)`.
@@ -127,12 +120,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
             this.log(`No matching overload for function ${this.name}(${argExprs
                 .map(e => e.dataType)
                 .join(', ')})`);
-            return {
-                dataType: 'unknown',
-                expressionType: 'scalar',
-                value: [],
-                evalSpace: 'constant',
-            };
+            return (0, ast_utils_1.errorFor)('no matching overload');
         }
         const { overload, expressionTypeErrors, evalSpaceErrors, nullabilityErrors } = result;
         // Report errors for expression type mismatch
@@ -171,12 +159,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
             this.log(`Cannot call function ${this.name}(${argExprs
                 .map(e => e.dataType)
                 .join(', ')}) with source`);
-            return {
-                dataType: 'unknown',
-                expressionType,
-                value: [],
-                evalSpace: 'constant',
-            };
+            return (0, ast_utils_1.errorFor)('cannot call with source');
         }
         const funcCall = [
             {
@@ -189,12 +172,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
         ];
         if (type.dataType === 'any') {
             this.log(`Invalid return type ${type.dataType} for function '${this.name}'`);
-            return {
-                dataType: 'unknown',
-                expressionType,
-                value: [],
-                evalSpace: 'constant',
-            };
+            return (0, ast_utils_1.errorFor)('invalid return type');
         }
         const maxEvalSpace = (0, malloy_types_1.mergeEvalSpaces)(...argExprs.map(e => e.evalSpace));
         // If the merged eval space of all args is constant, the result is constant.
@@ -240,10 +218,7 @@ function findOverload(func, args) {
                     // does not make sense to limit function calls to not allow nulls, since have
                     // so little control over nullability.
                     arg.dataType === 'null' ||
-                    // TODO I've included this because it means that errors cascade a bit less...
-                    // I think we may want to add an `error` type for nodes generated from errors,
-                    // then make `error` propagate without generating more errors.
-                    arg.dataType === 'unknown';
+                    arg.dataType === 'error';
                 // Check expression type errors
                 if (paramT.expressionType) {
                     const expressionTypeMatch = (0, malloy_types_1.isExpressionTypeLEQ)(arg.expressionType, paramT.expressionType);

package/dist/lang/ast/expressions/expr-granular-time.js

@@ -70,8 +70,20 @@ class ExprGranularTime extends expression_def_1.ExpressionDef {
             }
             return tsVal;
         }
-        this.log(`Cannot do time truncation on type '${exprVal.dataType}'`);
-        return (0, ast_utils_1.errorFor)('granularity typecheck');
+        if (exprVal.dataType !== 'error') {
+            this.log(`Cannot do time truncation on type '${exprVal.dataType}'`);
+        }
+        const returnType = exprVal.dataType === 'error'
+            ? (0, malloy_types_1.isDateUnit)(timeframe)
+                ? 'date'
+                : 'timestamp'
+            : exprVal.dataType;
+        return {
+            ...exprVal,
+            dataType: returnType,
+            value: (0, ast_utils_1.errorFor)('granularity typecheck').value,
+            evalSpace: 'constant',
+        };
     }
     apply(fs, op, left) {
         return this.getRange(fs).apply(fs, op, left);

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

@@ -37,9 +37,9 @@ class ExprMinus extends expression_def_1.ExpressionDef {
         const expr = this.expr.getExpression(fs);
         if (this.typeCheck(this.expr, expr)) {
             if (expr.value.length > 1) {
-                return { ...expr, value: ['-(', ...expr.value, ')'] };
+                return { ...expr, dataType: 'number', value: ['-(', ...expr.value, ')'] };
             }
-            return { ...expr, value: ['-', ...expr.value] };
+            return { ...expr, dataType: 'number', value: ['-', ...expr.value] };
         }
         return (0, ast_utils_1.errorFor)('negate requires number');
     }

package/dist/lang/ast/expressions/expr-time-extract.js

@@ -54,6 +54,16 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
             if (from instanceof range_1.Range) {
                 let first = from.first.getExpression(fs);
                 let last = from.last.getExpression(fs);
+                const expressionType = (0, malloy_types_1.maxExpressionType)(first.expressionType, last.expressionType);
+                const evalSpace = (0, malloy_types_1.mergeEvalSpaces)(first.evalSpace, last.evalSpace);
+                if (first.dataType === 'error' || last.dataType === 'error') {
+                    return {
+                        dataType: 'number',
+                        expressionType,
+                        evalSpace,
+                        value: (0, ast_utils_1.errorFor)('extract from error').value,
+                    };
+                }
                 if (!(0, malloy_types_1.isTimeFieldType)(first.dataType)) {
                     from.first.log(`Can't extract ${extractTo} from '${first.dataType}'`);
                     return (0, ast_utils_1.errorFor)(`${extractTo} bad type ${first.dataType}`);
@@ -95,8 +105,8 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
                 }
                 return {
                     dataType: 'number',
-                    expressionType: (0, malloy_types_1.maxExpressionType)(first.expressionType, last.expressionType),
-                    evalSpace: (0, malloy_types_1.mergeEvalSpaces)(first.evalSpace, last.evalSpace),
+                    expressionType,
+                    evalSpace,
                     value: [
                         {
                             type: 'dialect',
@@ -125,8 +135,16 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
                         ],
                     };
                 }
-                this.log(`${this.extractText}() requires time type, not '${argV.dataType}'`);
-                return (0, ast_utils_1.errorFor)(`${this.extractText} bad type ${argV.dataType}`);
+                if (argV.dataType !== 'error') {
+                    this.log(`${this.extractText}() requires time type, not '${argV.dataType}'`);
+                }
+                return {
+                    dataType: 'number',
+                    expressionType: argV.expressionType,
+                    evalSpace: argV.evalSpace,
+                    value: (0, ast_utils_1.errorFor)(`${this.extractText} bad type ${argV.dataType}`)
+                        .value,
+                };
             }
         }
         throw this.internalError(`Illegal extraction unit '${this.extractText}'`);

package/dist/lang/ast/expressions/for-range.d.ts

@@ -7,7 +7,7 @@ export declare class ForRange extends ExpressionDef {
     readonly duration: ExpressionDef;
     readonly timeframe: Timeframe;
     elementType: string;
-    legalChildTypes: import("../../..").TypeDesc[];
+    legalChildTypes: import("../../../model").TypeDesc[];
     constructor(from: ExpressionDef, duration: ExpressionDef, timeframe: Timeframe);
     apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
     requestExpression(_fs: FieldSpace): undefined;

package/dist/lang/ast/expressions/for-range.js

@@ -23,6 +23,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ForRange = void 0;
+const model_1 = require("../../../model");
 const ast_utils_1 = require("../ast-utils");
 const fragtype_utils_1 = require("../fragtype-utils");
 const time_utils_1 = require("../time-utils");
@@ -46,8 +47,15 @@ class ForRange extends expression_def_1.ExpressionDef {
         }
         const nV = this.duration.getExpression(fs);
         if (nV.dataType !== 'number') {
-            this.log(`FOR duration count must be a number, not '${nV.dataType}'`);
-            return (0, ast_utils_1.errorFor)('FOR not number');
+            if (nV.dataType !== 'error') {
+                this.log(`FOR duration count must be a number, not '${nV.dataType}'`);
+            }
+            return {
+                dataType: 'boolean',
+                evalSpace: (0, model_1.mergeEvalSpaces)(startV.evalSpace, checkV.evalSpace),
+                expressionType: (0, model_1.maxExpressionType)(startV.expressionType, checkV.expressionType),
+                value: (0, ast_utils_1.errorFor)('for not number').value,
+            };
         }
         const units = this.timeframe.text;
         // If the duration resolution is smaller than date, we have

package/dist/lang/ast/expressions/pick-when.js

@@ -30,7 +30,11 @@ const expression_def_1 = require("../types/expression-def");
 const malloy_element_1 = require("../types/malloy-element");
 const utils_1 = require("./utils");
 function typeCoalesce(ev1, ev2) {
-    return ev1 === undefined || ev1.dataType === 'null' ? ev2 : ev1;
+    return ev1 === undefined ||
+        ev1.dataType === 'null' ||
+        ev1.dataType === 'error'
+        ? ev2
+        : ev1;
 }
 class Pick extends expression_def_1.ExpressionDef {
     constructor(choices, elsePick) {

package/dist/lang/ast/field-space/query-spaces.js

@@ -292,14 +292,11 @@ class QuerySpace extends refined_space_1.RefinedSpace {
                     }
                     else {
                         const typeDesc = field.typeDesc();
-                        // Filter out fields whose type is unknown, which means that a totally bad field
-                        // isn't sent to the compiler, where it will wig out. The downside is that in
-                        // subsequent stages of a query, the field is not in the input struct. But since
-                        // the error message says "Cannot define x which has unknown type", it makes sense
-                        // that it wouldn't be "defined" in later stages.
+                        // Filter out fields whose type is 'error', which means that a totally bad field
+                        // isn't sent to the compiler, where it will wig out.
                         // TODO Figure out how to make errors generated by `canContain` go in the right place,
                         // maybe by adding a logable element to SpaceFields.
-                        if (typeDesc.dataType !== 'unknown' && this.canContain(typeDesc)) {
+                        if (typeDesc.dataType !== 'error' && this.canContain(typeDesc)) {
                             fields.push(fieldQueryDef);
                         }
                     }

package/dist/lang/ast/field-space/reference-field.js

@@ -45,7 +45,7 @@ class ReferenceField extends space_field_1.SpaceField {
         if (this.res !== undefined && this.res.found) {
             return this.res.found.typeDesc();
         }
-        return { dataType: 'unknown', expressionType: 'scalar', evalSpace: 'input' };
+        return { dataType: 'error', expressionType: 'scalar', evalSpace: 'input' };
     }
 }
 exports.ReferenceField = ReferenceField;

package/dist/lang/ast/fragtype-utils.d.ts

@@ -21,7 +21,7 @@ export declare class FT {
      * @param right Right type
      * @param nullOk True if a NULL is an acceptable match
      */
-    static typeEq(left: TypeDesc, right: TypeDesc, nullOk?: boolean): boolean;
+    static typeEq(left: TypeDesc, right: TypeDesc, nullOk?: boolean, errorOk?: boolean): boolean;
     /**
      *
      * For error messages, returns a comma seperated list of readable names

package/dist/lang/ast/fragtype-utils.js

@@ -59,10 +59,11 @@ class FT {
      * @param right Right type
      * @param nullOk True if a NULL is an acceptable match
      */
-    static typeEq(left, right, nullOk = false) {
+    static typeEq(left, right, nullOk = false, errorOk = true) {
         const maybeEq = left.dataType === right.dataType;
         const nullEq = nullOk && (left.dataType === 'null' || right.dataType === 'null');
-        return maybeEq || nullEq;
+        const errorEq = errorOk && (left.dataType === 'error' || right.dataType === 'error');
+        return maybeEq || nullEq || errorEq;
     }
     /**
      *

package/dist/lang/ast/parameters/constant-parameter.js

@@ -37,7 +37,7 @@ class ConstantParameter extends has_parameter_1.HasParameter {
             this.log(`Unexpected expression type '${cVal.dataType}'`);
             return {
                 value: ['XXX-type-mismatch-error-XXX'],
-                type: 'string',
+                type: 'error',
                 name: this.name,
                 constant: true,
             };

package/dist/lang/ast/query-items/field-declaration.js

@@ -66,8 +66,8 @@ class FieldDeclaration extends malloy_element_1.MalloyElement {
         catch (error) {
             this.log(`Cannot define '${exprName}', ${error.message}`);
             return {
-                name: `error_defining_${exprName}`,
-                type: 'string',
+                name: exprName,
+                type: 'error',
             };
         }
         const compressValue = (0, utils_1.compressExpr)(exprValue.value);
@@ -96,17 +96,14 @@ class FieldDeclaration extends malloy_element_1.MalloyElement {
         }
         const circularDef = exprFS instanceof DefSpace && exprFS.foundCircle;
         if (!circularDef) {
-            if (exprValue.dataType === 'unknown') {
-                this.log(`Cannot define '${exprName}', value has unknown type`);
-            }
-            else {
+            if (exprValue.dataType !== 'error') {
                 const badType = fragtype_utils_1.FT.inspect(exprValue);
                 this.log(`Cannot define '${exprName}', unexpected type: ${badType}`);
             }
         }
         return {
-            name: `error_defining_${exprName}`,
-            type: 'string',
+            name: exprName,
+            type: 'error',
         };
     }
 }

package/dist/lang/ast/types/expression-def.js

@@ -67,7 +67,7 @@ class ExpressionDef extends malloy_element_1.MalloyElement {
      * @param eVal ...list of expressions that must match legalChildTypes
      */
     typeCheck(eNode, eVal) {
-        if (!fragtype_utils_1.FT.in(eVal, this.legalChildTypes)) {
+        if (eVal.dataType !== 'error' && !fragtype_utils_1.FT.in(eVal, this.legalChildTypes)) {
             eNode.log(`'${this.elementType}' Can't use type ${fragtype_utils_1.FT.inspect(eVal)}`);
             return false;
         }
@@ -232,6 +232,9 @@ function nullCompare(left, op, right) {
 function equality(fs, left, op, right) {
     const lhs = left.getExpression(fs);
     const rhs = right.getExpression(fs);
+    const err = errorCascade('boolean', lhs, rhs);
+    if (err)
+        return err;
     // Unsupported types can be compare with null
     const checkUnsupport = lhs.dataType === 'unsupported' || rhs.dataType === 'unsupported';
     if (checkUnsupport) {
@@ -245,7 +248,7 @@ function equality(fs, left, op, right) {
         }
     }
     let value = timeCompare(left, lhs, op, rhs) || (0, utils_1.compose)(lhs.value, op, rhs.value);
-    if (lhs.dataType !== 'unknown' && rhs.dataType !== 'unknown') {
+    if (lhs.dataType !== 'error' && rhs.dataType !== 'error') {
         switch (op) {
             case '~':
             case '!~': {
@@ -285,6 +288,9 @@ function equality(fs, left, op, right) {
 function compare(fs, left, op, right) {
     const lhs = left.getExpression(fs);
     const rhs = right.getExpression(fs);
+    const err = errorCascade('boolean', lhs, rhs);
+    if (err)
+        return err;
     const expressionType = (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType);
     const noCompare = unsupportError(left, lhs, right, rhs);
     if (noCompare) {
@@ -312,6 +318,9 @@ function allAre(oneType, ...values) {
 function numeric(fs, left, op, right) {
     const lhs = left.getExpression(fs);
     const rhs = right.getExpression(fs);
+    const err = errorCascade('number', lhs, rhs);
+    if (err)
+        return err;
     const noGo = unsupportError(left, lhs, right, rhs);
     if (noGo) {
         return noGo;
@@ -335,7 +344,11 @@ function delta(fs, left, op, right) {
     if (noGo) {
         return noGo;
     }
-    if ((0, malloy_types_1.isTimeFieldType)(lhs.dataType)) {
+    const timeLHS = (0, malloy_types_1.isTimeFieldType)(lhs.dataType);
+    const err = errorCascade(timeLHS ? 'error' : 'number', lhs, rhs);
+    if (err)
+        return err;
+    if (timeLHS) {
         let duration = right;
         if (rhs.dataType !== 'duration') {
             if ((0, granular_result_1.isGranularResult)(lhs)) {
@@ -385,6 +398,9 @@ function applyBinary(fs, left, op, right) {
             left.log('Cannot operate with unsupported type');
             return noGo;
         }
+        const err = errorCascade('number', num, denom);
+        if (err)
+            return err;
         if (num.dataType !== 'number') {
             left.log('Numerator for division must be a number');
         }
@@ -411,6 +427,16 @@ function applyBinary(fs, left, op, right) {
     return (0, ast_utils_1.errorFor)('applybinary bad operator');
 }
 exports.applyBinary = applyBinary;
+function errorCascade(dataType, ...es) {
+    if (es.some(e => e.dataType === 'error')) {
+        return {
+            dataType,
+            expressionType: (0, malloy_types_1.maxOfExpressionTypes)(es.map(e => e.expressionType)),
+            value: ["'cascading error'"],
+            evalSpace: (0, malloy_types_1.mergeEvalSpaces)(...es.map(e => e.evalSpace)),
+        };
+    }
+}
 /**
  * Return an error if a binary operation includes unsupported types.
  */

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);
@@ -297,14 +297,6 @@ class RunList extends ListOf {
     }
     executeList(doc) {
         while (this.execCursor < this.elements.length) {
-            if (doc.errorsExist()) {
-                // TODO make a better way to stop cascading errors -- this way means that if there are
-                // actual different errors in multiple places, we only see the first one. A better way
-                // might be to make things that have error pass all kinds of typechecks, which prevents
-                // the real cascade.
-                // This stops cascading errors
-                return;
-            }
             const el = this.elements[this.execCursor];
             if (isDocStatement(el)) {
                 const resp = el.execute(doc);

package/dist/lang/ast/types/space-param.js

@@ -40,7 +40,7 @@ class AbstractParameter extends SpaceParam {
         return this.astParam.parameter();
     }
     typeDesc() {
-        const type = this.astParam.type || 'unknown';
+        const type = this.astParam.type || 'error';
         // TODO Not sure whether params are considered "input space". It seems like they
         // could be input or constant, depending on usage.
         return { dataType: type, expressionType: 'scalar', evalSpace: 'input' };

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;