@malloydata/malloy 0.0.236-dev250213234155 → 0.0.236-dev250219154103

package/dist/lang/lib/Malloy/MalloyParserListener.d.ts

@@ -236,7 +236,6 @@ import { ConnectionNameContext } from "./MalloyParser";
 import { DebugExprContext } from "./MalloyParser";
 import { DebugPartialContext } from "./MalloyParser";
 import { ExperimentalStatementForTestingContext } from "./MalloyParser";
-import { CloseCurlyContext } from "./MalloyParser";
 /**
  * This interface defines a complete listener for a parse tree produced by
  * `MalloyParser`.
@@ -2784,14 +2783,4 @@ export interface MalloyParserListener extends ParseTreeListener {
      * @param ctx the parse tree
      */
     exitExperimentalStatementForTesting?: (ctx: ExperimentalStatementForTestingContext) => void;
-    /**
-     * Enter a parse tree produced by `MalloyParser.closeCurly`.
-     * @param ctx the parse tree
-     */
-    enterCloseCurly?: (ctx: CloseCurlyContext) => void;
-    /**
-     * Exit a parse tree produced by `MalloyParser.closeCurly`.
-     * @param ctx the parse tree
-     */
-    exitCloseCurly?: (ctx: CloseCurlyContext) => void;
 }

package/dist/lang/lib/Malloy/MalloyParserVisitor.d.ts

@@ -236,7 +236,6 @@ import { ConnectionNameContext } from "./MalloyParser";
 import { DebugExprContext } from "./MalloyParser";
 import { DebugPartialContext } from "./MalloyParser";
 import { ExperimentalStatementForTestingContext } from "./MalloyParser";
-import { CloseCurlyContext } from "./MalloyParser";
 /**
  * This interface defines a complete generic visitor for a parse tree produced
  * by `MalloyParser`.
@@ -1753,10 +1752,4 @@ export interface MalloyParserVisitor<Result> extends ParseTreeVisitor<Result> {
      * @return the visitor result
      */
     visitExperimentalStatementForTesting?: (ctx: ExperimentalStatementForTestingContext) => Result;
-    /**
-     * Visit a parse tree produced by `MalloyParser.closeCurly`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitCloseCurly?: (ctx: CloseCurlyContext) => Result;
 }

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

@@ -1,6 +1,6 @@
-import { ANTLRErrorListener, ParserRuleContext, Token } from 'antlr4ts';
+import { ParserRuleContext, Token } from 'antlr4ts';
 import { DocumentLocation, DocumentPosition, DocumentRange, DocumentReference, ImportLocation, ModelDef, NamedModelObject, SourceDef, SQLSourceDef, DependencyTree } from '../model/malloy_types';
-import { BaseMessageLogger, LogMessage, LogMessageOptions, MessageCode, MessageLogger, MessageParameterType } from './parse-log';
+import { BaseMessageLogger, LogMessage, LogMessageOptions, MessageCode, MessageParameterType } from './parse-log';
 import { Zone, ZoneData } from './zone';
 import { ReferenceList } from './reference-list';
 import { ASTResponse, CompletionsResponse, DataRequestResponse, ProblemResponse, FatalResponse, FinalResponse, HelpContextResponse, MetadataResponse, ModelDataRequest, NeedURLData, TranslateResponse, ModelAnnotationResponse, TablePathResponse } from './translate-response';
@@ -228,11 +228,4 @@ export interface UpdateData extends URLData, SchemaData, SQLSources, ModelData {
     errors: Partial<ErrorData>;
 }
 export type ParseUpdate = Partial<UpdateData>;
-export declare class MalloyParserErrorHandler implements ANTLRErrorListener<Token> {
-    readonly translator: MalloyTranslation;
-    readonly messages: MessageLogger;
-    constructor(translator: MalloyTranslation, messages: MessageLogger);
-    logError<T extends MessageCode>(code: T, parameters: MessageParameterType<T>, options?: Omit<LogMessageOptions, 'severity'>): T;
-    syntaxError(recognizer: unknown, offendingSymbol: Token | undefined, line: number, charPositionInLine: number, message: string, _e: unknown): void;
-}
 export {};

package/dist/lang/parse-malloy.js

@@ -45,7 +45,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MalloyParserErrorHandler = exports.MalloyTranslator = exports.MalloyChildTranslator = exports.MalloyTranslation = void 0;
+exports.MalloyTranslator = exports.MalloyChildTranslator = exports.MalloyTranslation = void 0;
 const antlr4ts_1 = require("antlr4ts");
 const malloy_types_1 = require("../model/malloy_types");
 const MalloyLexer_1 = require("./lib/Malloy/MalloyLexer");
@@ -64,6 +64,8 @@ const utils_1 = require("./utils");
 const tags_1 = require("../tags");
 const model_annotation_walker_1 = require("./parse-tree-walkers/model-annotation-walker");
 const find_table_path_walker_1 = require("./parse-tree-walkers/find-table-path-walker");
+const malloy_error_strategy_1 = require("./syntax-errors/malloy-error-strategy");
+const malloy_parser_error_listener_1 = require("./syntax-errors/malloy-parser-error-listener");
 /**
  * This ignores a -> popMode when the mode stack is empty, which is a hack,
  * but it let's us parse }%
@@ -159,7 +161,8 @@ class ParseStep {
         const tokenStream = new antlr4ts_1.CommonTokenStream(lexer);
         const malloyParser = new MalloyParser_1.MalloyParser(tokenStream);
         malloyParser.removeErrorListeners();
-        malloyParser.addErrorListener(new MalloyParserErrorHandler(that, that.root.logger));
+        malloyParser.addErrorListener(new malloy_parser_error_listener_1.MalloyParserErrorListener(that, that.root.logger));
+        malloyParser.errorHandler = new malloy_error_strategy_1.MalloyErrorStrategy();
         // 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
@@ -883,26 +886,6 @@ class MalloyTranslator extends MalloyTranslation {
     }
 }
 exports.MalloyTranslator = MalloyTranslator;
-class MalloyParserErrorHandler {
-    constructor(translator, messages) {
-        this.translator = translator;
-        this.messages = messages;
-    }
-    logError(code, parameters, options) {
-        this.messages.log((0, parse_log_1.makeLogMessage)(code, parameters, { severity: 'error', ...options }));
-        return code;
-    }
-    syntaxError(recognizer, offendingSymbol, line, charPositionInLine, message, _e) {
-        const errAt = { line: line - 1, character: charPositionInLine };
-        const range = offendingSymbol
-            ? this.translator.rangeFromToken(offendingSymbol)
-            : { start: errAt, end: errAt };
-        this.logError('syntax-error', { message }, {
-            at: { url: this.translator.sourceURL, range },
-        });
-    }
-}
-exports.MalloyParserErrorHandler = MalloyParserErrorHandler;
 function flattenDependencyTree(dependencies) {
     return [
         ...Object.keys(dependencies),

package/dist/lang/syntax-errors/custom-error-messages.d.ts

@@ -0,0 +1,10 @@
+import { Parser, Token } from 'antlr4ts';
+export interface ErrorCase {
+    ruleContextOptions?: string[];
+    offendingSymbol?: number;
+    currentToken?: number;
+    precedingTokenOptions?: number[][];
+    lookAheadOptions?: number[][];
+    errorMessage: string;
+}
+export declare const checkCustomErrorMessage: (parser: Parser, offendingSymbol: Token | undefined, errorCases: ErrorCase[]) => string;

package/dist/lang/syntax-errors/custom-error-messages.js

@@ -0,0 +1,64 @@
+"use strict";
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkCustomErrorMessage = void 0;
+const checkCustomErrorMessage = (parser, offendingSymbol, errorCases) => {
+    const currentRuleName = parser.getRuleInvocationStack()[0];
+    const currentToken = parser.currentToken;
+    for (const errorCase of errorCases) {
+        // Check to see if the initial conditions match
+        const isCurrentTokenMatch = !errorCase.currentToken || currentToken.type === errorCase.currentToken;
+        const isOffendingSymbolMatch = !errorCase.offendingSymbol ||
+            (offendingSymbol === null || offendingSymbol === void 0 ? void 0 : offendingSymbol.type) === errorCase.offendingSymbol;
+        const isRuleContextMatch = !errorCase.ruleContextOptions ||
+            errorCase.ruleContextOptions.includes(currentRuleName);
+        if (isCurrentTokenMatch && isOffendingSymbolMatch && isRuleContextMatch) {
+            // If so, try to check the preceding tokens.
+            if (errorCase.precedingTokenOptions) {
+                const hasPrecedingTokenMatch = errorCase.precedingTokenOptions.some(sequence => checkTokenSequenceMatch(parser, sequence, 'lookback'));
+                if (!hasPrecedingTokenMatch) {
+                    continue; // Continue to check a different error case
+                }
+            }
+            if (errorCase.lookAheadOptions) {
+                const hasLookaheadTokenMatch = errorCase.lookAheadOptions.some(sequence => checkTokenSequenceMatch(parser, sequence, 'lookahead'));
+                if (!hasLookaheadTokenMatch) {
+                    continue; // Continue to check a different error case
+                }
+            }
+            // If all cases match, return the custom error message
+            const message = errorCase.errorMessage.replace('${currentToken}', (offendingSymbol === null || offendingSymbol === void 0 ? void 0 : offendingSymbol.text) || currentToken.text || '');
+            return message;
+        }
+    }
+    return '';
+};
+exports.checkCustomErrorMessage = checkCustomErrorMessage;
+const checkTokenSequenceMatch = (parser, sequence, direction) => {
+    try {
+        for (let i = 0; i < sequence.length; i++) {
+            // Note: positive lookahead starts at '2' because '1' is the current token.
+            const tokenIndex = direction === 'lookahead' ? i + 2 : -1 * (i + 1);
+            const streamToken = parser.inputStream.LA(tokenIndex);
+            // Note: negative checking is < -1 becuase Token.EOF is -1, but below
+            // that we use negatives to indicate "does-not-match" rules.
+            if (sequence[i] >= -1 && streamToken !== sequence[i]) {
+                return false;
+            }
+            if (sequence[i] < -1 && streamToken === -1 * sequence[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    catch (ex) {
+        // There may not be enough lookback tokens. If so, the case doesn't match.
+        return false;
+    }
+};
+//# sourceMappingURL=custom-error-messages.js.map

package/dist/lang/syntax-errors/malloy-error-strategy.d.ts

@@ -0,0 +1,14 @@
+import { DefaultErrorStrategy, Parser } from 'antlr4ts';
+/**
+ * Custom error strategy for the Malloy Parser. This strategy attempts to
+ * detect known cases where the default error strategy results in an unhelpful
+ * parse tree or misleading messages. In any cases not explicitly handled, this
+ * custom error strategy will fall back to the default error strategy.
+ *
+ * For more details, read the documentation in DefaultErrorStrategy.d.ts
+ * or reference the superclass at:
+ * https://github.com/tunnelvisionlabs/antlr4ts/blob/master/src/DefaultErrorStrategy.ts
+ */
+export declare class MalloyErrorStrategy extends DefaultErrorStrategy {
+    sync(parser: Parser): void;
+}

package/dist/lang/syntax-errors/malloy-error-strategy.js

@@ -0,0 +1,42 @@
+"use strict";
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MalloyErrorStrategy = void 0;
+const antlr4ts_1 = require("antlr4ts");
+const MalloyParser_1 = require("../lib/Malloy/MalloyParser");
+const custom_error_messages_1 = require("./custom-error-messages");
+const customErrorCases = [
+    {
+        errorMessage: "Missing '{' after 'extend'",
+        currentToken: MalloyParser_1.MalloyParser.EXTEND,
+        ruleContextOptions: ['sqExpr'],
+        lookAheadOptions: [[-MalloyParser_1.MalloyParser.OCURLY]],
+    },
+];
+/**
+ * Custom error strategy for the Malloy Parser. This strategy attempts to
+ * detect known cases where the default error strategy results in an unhelpful
+ * parse tree or misleading messages. In any cases not explicitly handled, this
+ * custom error strategy will fall back to the default error strategy.
+ *
+ * For more details, read the documentation in DefaultErrorStrategy.d.ts
+ * or reference the superclass at:
+ * https://github.com/tunnelvisionlabs/antlr4ts/blob/master/src/DefaultErrorStrategy.ts
+ */
+class MalloyErrorStrategy extends antlr4ts_1.DefaultErrorStrategy {
+    sync(parser) {
+        const interceptedErrorMessage = (0, custom_error_messages_1.checkCustomErrorMessage)(parser, undefined, customErrorCases);
+        if (interceptedErrorMessage) {
+            parser.notifyErrorListeners(interceptedErrorMessage, parser.currentToken, undefined);
+            return;
+        }
+        super.sync(parser);
+    }
+}
+exports.MalloyErrorStrategy = MalloyErrorStrategy;
+//# sourceMappingURL=malloy-error-strategy.js.map

package/dist/lang/syntax-errors/malloy-parser-error-listener.d.ts

@@ -0,0 +1,12 @@
+import { ANTLRErrorListener, Token } from 'antlr4ts';
+import { ErrorCase } from './custom-error-messages';
+import { MessageLogger, MessageCode, MessageParameterType, LogMessageOptions } from '../parse-log';
+import { MalloyTranslation } from '../parse-malloy';
+export declare const commonErrorCases: ErrorCase[];
+export declare class MalloyParserErrorListener implements ANTLRErrorListener<Token> {
+    readonly translator: MalloyTranslation;
+    readonly messages: MessageLogger;
+    constructor(translator: MalloyTranslation, messages: MessageLogger);
+    logError<T extends MessageCode>(code: T, parameters: MessageParameterType<T>, options?: Omit<LogMessageOptions, 'severity'>): T;
+    syntaxError(recognizer: unknown, offendingSymbol: Token | undefined, line: number, charPositionInLine: number, message: string, _e: unknown): void;
+}

package/dist/lang/syntax-errors/malloy-parser-error-listener.js

@@ -0,0 +1,64 @@
+"use strict";
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MalloyParserErrorListener = exports.commonErrorCases = void 0;
+const MalloyParser_1 = require("../lib/Malloy/MalloyParser");
+const custom_error_messages_1 = require("./custom-error-messages");
+const parse_log_1 = require("../parse-log");
+exports.commonErrorCases = [
+    {
+        errorMessage: "'view:' must be followed by '<identifier> is {'",
+        ruleContextOptions: ['exploreQueryDef'],
+        offendingSymbol: MalloyParser_1.MalloyParser.OCURLY,
+        precedingTokenOptions: [[MalloyParser_1.MalloyParser.VIEW], [MalloyParser_1.MalloyParser.COLON]],
+    },
+    {
+        errorMessage: "Missing '}' at '${currentToken}'",
+        ruleContextOptions: ['vExpr'],
+        offendingSymbol: MalloyParser_1.MalloyParser.VIEW,
+        currentToken: MalloyParser_1.MalloyParser.OCURLY,
+    },
+    {
+        errorMessage: "Missing '}' at '${currentToken}'",
+        ruleContextOptions: [
+            'exploreProperties',
+            'queryProperties',
+            'exploreStatement',
+        ],
+        lookAheadOptions: [
+            [MalloyParser_1.MalloyParser.EOF],
+            [MalloyParser_1.MalloyParser.RUN],
+            [MalloyParser_1.MalloyParser.SOURCE],
+        ],
+    },
+];
+class MalloyParserErrorListener {
+    constructor(translator, messages) {
+        this.translator = translator;
+        this.messages = messages;
+    }
+    logError(code, parameters, options) {
+        this.messages.log((0, parse_log_1.makeLogMessage)(code, parameters, { severity: 'error', ...options }));
+        return code;
+    }
+    syntaxError(recognizer, offendingSymbol, line, charPositionInLine, message, _e) {
+        const errAt = { line: line - 1, character: charPositionInLine };
+        const range = offendingSymbol
+            ? this.translator.rangeFromToken(offendingSymbol)
+            : { start: errAt, end: errAt };
+        const overrideMessage = (0, custom_error_messages_1.checkCustomErrorMessage)(recognizer, offendingSymbol, exports.commonErrorCases);
+        if (overrideMessage) {
+            message = overrideMessage;
+        }
+        this.logError('syntax-error', { message }, {
+            at: { url: this.translator.sourceURL, range },
+        });
+    }
+}
+exports.MalloyParserErrorListener = MalloyParserErrorListener;
+//# sourceMappingURL=malloy-parser-error-listener.js.map

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

@@ -33,6 +33,7 @@ declare global {
             toTranslate(): R;
             toReturnType(tp: string): R;
             toLog(...expectedErrors: ProblemSpec[]): R;
+            toLogAtLeast(...expectedErrors: ProblemSpec[]): R;
             isLocationIn(at: DocumentLocation, txt: string): R;
             /**
              * expect(X).compilesTo('expression-string')

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

@@ -236,7 +236,11 @@ expect.extend({
     },
     toLog: function (s, ...msgs) {
         const expectCompiles = !msgs.some(m => m.severity === 'error');
-        return checkForProblems(this, expectCompiles, s, ...msgs);
+        return checkForProblems(this, expectCompiles, s, false, ...msgs);
+    },
+    toLogAtLeast: function (s, ...msgs) {
+        const expectCompiles = !msgs.some(m => m.severity === 'error');
+        return checkForProblems(this, expectCompiles, s, true, ...msgs);
     },
     isLocationIn: function (checkAt, at, text) {
         if (this.equals(at, checkAt)) {
@@ -327,7 +331,7 @@ expect.extend({
 function problemSpecSummary(s) {
     return `${s.severity} '${'message' in s ? s.message : s.code}' ${s.data !== undefined ? (0, test_translator_1.pretty)(s.data) : ''}`;
 }
-function checkForProblems(context, expectCompiles, s, ...msgs) {
+function checkForProblems(context, expectCompiles, s, allowAdditionalErrors, ...msgs) {
     var _a;
     let emsg = `Expected ${expectCompiles ? 'to' : 'to not'} compile with: `;
     const mSrc = isMarkedSource(s) ? s : undefined;
@@ -404,7 +408,7 @@ function checkForProblems(context, expectCompiles, s, ...msgs) {
         if (i !== msgs.length) {
             explain.push(...msgs.slice(i).map(m => `Missing: ${m}`));
         }
-        if (i !== errList.length) {
+        if (!allowAdditionalErrors && i !== errList.length) {
             explain.push(...errList.slice(i).map(m => `Unexpected Error: ${m.message}`));
         }
         if (explain.length === 0) {

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

@@ -89,7 +89,7 @@ describe('model statements', () => {
 });
 describe('error handling', () => {
     test('no close brace', () => {
-        expect('run: a -> { group_by: ai').toLog((0, test_translator_1.errorMessage)("'{' missing a '}'"));
+        expect('run: a -> { group_by: ai').toLog((0, test_translator_1.errorMessage)("Missing '}' at '<EOF>'"));
     });
     test('field and query with same name does not overflow', () => {
         expect(`

package/dist/lang/test/syntax-errors.spec.d.ts

@@ -0,0 +1 @@
+import './parse-expects';

package/dist/lang/test/syntax-errors.spec.js

@@ -0,0 +1,59 @@
+"use strict";
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_translator_1 = require("./test-translator");
+require("./parse-expects");
+describe('errors', () => {
+    test('source missing closing curly: EOF', () => {
+        expect('source: x is a extend {').toLogAtLeast((0, test_translator_1.errorMessage)("Missing '}' at '<EOF>'"));
+    });
+    test('view is missing name', () => {
+        expect(`
+      source: x is a extend {
+        view: {
+          group_by: b
+        }
+      }
+      `).toLogAtLeast((0, test_translator_1.errorMessage)("'view:' must be followed by '<identifier> is {'"));
+    });
+    test('missing closing curly, source>view', () => {
+        expect(`
+      source: x is a extend {
+        view: y is {
+          group_by: b
+
+        view: z is {
+          group_by: c
+        }
+      }
+      `).toLogAtLeast((0, test_translator_1.errorMessage)("Missing '}' at 'view:'"));
+    });
+    test('incorrect opening curly after dimension', () => {
+        expect(`
+      source: x is a extend {
+        dimension: {
+          test is best
+        }
+      }
+      `).toLogAtLeast((0, test_translator_1.errorMessage)("extraneous input '{' expecting {BQ_STRING, IDENTIFIER}"));
+    });
+    test('misspelled primarykey', () => {
+        expect(`
+      source: x is a extend {
+        primarykey: id
+      }
+    `).toLogAtLeast((0, test_translator_1.errorMessage)("no viable alternative at input 'primarykey'"));
+    });
+    test('missing opening curly after source extend keyword', () => {
+        expect(`
+      source: x is a extend
+        primary_key: id
+    `).toLogAtLeast((0, test_translator_1.errorMessage)("Missing '{' after 'extend'"));
+    });
+});
+//# sourceMappingURL=syntax-errors.spec.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.236-dev250213234155",
+  "version": "0.0.236-dev250219154103",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",