@malloydata/malloy 0.0.240-dev250311202829 → 0.0.240-dev250311214430

package/dist/api/core.d.ts

@@ -31,6 +31,7 @@ export declare function statedCompileModel(state: CompileModelState): Malloy.Com
 export declare function statedCompileSource(state: CompileModelState, name: string): Malloy.CompileSourceResponse;
 export declare function _statedCompileModel(state: CompileModelState): CompileResponse;
 export declare const DEFAULT_LOG_RANGE: Malloy.DocumentRange;
+export declare function mapLogs(logs: LogMessage[], defaultURL: string): Malloy.LogMessage[];
 export declare function compileModel(request: Malloy.CompileModelRequest, state?: CompileModelState): Malloy.CompileModelResponse;
 export declare function compileSource(request: Malloy.CompileSourceRequest): Malloy.CompileSourceResponse;
 export declare function hasErrors(log: Malloy.LogMessage[] | undefined): boolean;

package/dist/api/core.js

@@ -29,7 +29,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.statedCompileQuery = exports.newCompileQueryState = exports.hasErrors = exports.compileSource = exports.compileModel = exports.DEFAULT_LOG_RANGE = exports._statedCompileModel = exports.statedCompileSource = exports.statedCompileModel = exports.newCompileSourceState = exports.newCompileModelState = exports.updateCompileModelState = exports.compileQuery = void 0;
+exports.statedCompileQuery = exports.newCompileQueryState = exports.hasErrors = exports.compileSource = exports.compileModel = exports.mapLogs = exports.DEFAULT_LOG_RANGE = exports._statedCompileModel = exports.statedCompileSource = exports.statedCompileModel = exports.newCompileSourceState = exports.newCompileModelState = exports.updateCompileModelState = exports.compileQuery = void 0;
 const Malloy = __importStar(require("@malloydata/malloy-interfaces"));
 const lang_1 = require("../lang");
 const model_1 = require("../model");
@@ -326,6 +326,7 @@ function mapLogs(logs, defaultURL) {
         });
     });
 }
+exports.mapLogs = mapLogs;
 function wrapResponse(response, defaultURL) {
     const logs = response.logs ? mapLogs(response.logs, defaultURL) : undefined;
     if (response.compilerNeeds) {

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

@@ -1,12 +1,4 @@
-import { CodePointCharStream, CommonTokenStream, ParserRuleContext } from 'antlr4ts';
-import { ParseTree } from 'antlr4ts/tree';
-import { DocumentRange } from '../model/malloy_types';
-export interface MalloyParseInfo {
-    root: ParseTree;
-    tokenStream: CommonTokenStream;
-    sourceStream: CodePointCharStream;
-    sourceURL: string;
+import { ParseInfo } from './utils';
+export interface MalloyParseInfo extends ParseInfo {
     importBaseURL: string;
-    rangeFromContext: (pcx: ParserRuleContext) => DocumentRange;
-    malloyVersion: string;
 }

package/dist/lang/malloy-to-ast.d.ts

@@ -44,6 +44,7 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
      * Log an error message relative to an AST node
      */
     protected astError<T extends MessageCode>(el: ast.MalloyElement, code: T, data: MessageParameterType<T>, options?: LogMessageOptions): void;
+    protected rangeFromContext(cx: ParserRuleContext): DocumentRange;
     protected getLocation(cx: ParserRuleContext): DocumentLocation;
     protected getSourceString(cx: ParserRuleContext): string;
     /**

package/dist/lang/malloy-to-ast.js

@@ -105,10 +105,13 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
     astError(el, code, data, options) {
         this.msgLog.log((0, parse_log_1.makeLogMessage)(code, data, { at: el.location, ...options }));
     }
+    rangeFromContext(cx) {
+        return (0, utils_1.rangeFromContext)(this.parseInfo.sourceInfo, cx);
+    }
     getLocation(cx) {
         return {
             url: this.parseInfo.sourceURL,
-            range: this.parseInfo.rangeFromContext(cx),
+            range: this.rangeFromContext(cx),
         };
     }
     getSourceString(cx) {
@@ -180,7 +183,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
     astAt(el, cx) {
         el.location = {
             url: this.parseInfo.sourceURL,
-            range: this.parseInfo.rangeFromContext(cx),
+            range: this.rangeFromContext(cx),
         };
         return el;
     }
@@ -957,7 +960,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         const left = this.getFieldExpr(pcx.fieldExpr(0));
         const right = this.getFieldExpr(pcx.fieldExpr(1));
         if (ast.isEquality(op)) {
-            const wholeRange = this.parseInfo.rangeFromContext(pcx);
+            const wholeRange = this.rangeFromContext(pcx);
             if (right instanceof ast.ExprNULL) {
                 if (op === '=') {
                     this.warnWithReplacement('sql-is-null', "Use 'is null' to check for NULL instead of '= null'", wholeRange, `${this.getSourceCode(pcx.fieldExpr(0))} is null`);
@@ -1170,7 +1173,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         });
         const elseCx = pcx._caseElse;
         const theElse = elseCx ? this.getFieldExpr(elseCx) : undefined;
-        this.warnWithReplacement('sql-case', 'Use a `pick` statement instead of `case`', this.parseInfo.rangeFromContext(pcx), `${[
+        this.warnWithReplacement('sql-case', 'Use a `pick` statement instead of `case`', this.rangeFromContext(pcx), `${[
             ...(valueCx ? [`${this.getSourceCode(valueCx)} ?`] : []),
             ...whenCxs.map(whenCx => `pick ${this.getSourceCode(whenCx._result)} when ${this.getSourceCode(whenCx._condition)}`),
             elseCx ? `else ${elseCx.text}` : 'else null',
@@ -1486,7 +1489,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         let op = '~';
         const left = pcx.fieldExpr(0);
         const right = pcx.fieldExpr(1);
-        const wholeRange = this.parseInfo.rangeFromContext(pcx);
+        const wholeRange = this.rangeFromContext(pcx);
         if (pcx.NOT()) {
             op = '!~';
             this.warnWithReplacement('sql-not-like', "Use Malloy operator '!~' instead of 'NOT LIKE'", wholeRange, `${this.getSourceCode(left)} !~ ${this.getSourceCode(right)}`);
@@ -1505,7 +1508,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         const isNot = !!pcx.NOT();
         const from = pcx.fieldExprList().fieldExpr();
         const inStmt = this.astAt(new ast.ExprLegacyIn(expr, isNot, from.map(f => this.getFieldExpr(f))), pcx);
-        this.warnWithReplacement('sql-in', `Use = (a|b|c) instead of${isNot ? ' NOT' : ''} IN (a,b,c)`, this.parseInfo.rangeFromContext(pcx), `${this.getSourceCode(pcx.fieldExpr())} ${isNot ? '!=' : '='} (${from
+        this.warnWithReplacement('sql-in', `Use = (a|b|c) instead of${isNot ? ' NOT' : ''} IN (a,b,c)`, this.rangeFromContext(pcx), `${this.getSourceCode(pcx.fieldExpr())} ${isNot ? '!=' : '='} (${from
             .map(f => this.getSourceCode(f))
             .join(' | ')})`);
         return inStmt;

package/dist/lang/malloy-to-stable-query.d.ts

@@ -0,0 +1,76 @@
+import { ParserRuleContext } from 'antlr4ts';
+import { ParseTree, TerminalNode } from 'antlr4ts/tree';
+import { AbstractParseTreeVisitor } from 'antlr4ts/tree/AbstractParseTreeVisitor';
+import { MalloyParserVisitor } from './lib/Malloy/MalloyParserVisitor';
+import * as Malloy from '@malloydata/malloy-interfaces';
+import * as parse from './lib/Malloy/MalloyParser';
+import { LogMessageOptions, MessageCode, MessageLogger, MessageParameterType } from './parse-log';
+import { DocumentLocation } from '../model/malloy_types';
+import { ParseInfo } from './utils';
+type HasAnnotations = ParserRuleContext & {
+    ANNOTATION: () => TerminalNode[];
+};
+type Node = Malloy.Query | Malloy.QueryDefinitionWithArrow | Malloy.QueryDefinitionWithQueryReference | Malloy.QueryDefinitionWithRefinement | null;
+/**
+ * ANTLR visitor pattern parse tree traversal. Generates a Malloy
+ * AST from an ANTLR parse tree.
+ */
+export declare class MalloyToQuery extends AbstractParseTreeVisitor<Node> implements MalloyParserVisitor<Node> {
+    readonly parseInfo: ParseInfo;
+    readonly msgLog: MessageLogger;
+    constructor(parseInfo: ParseInfo, msgLog: MessageLogger);
+    /**
+     * Mostly used to flag a case where the grammar and the type system are
+     * no longer in sync. A visitor was written based on a grammar which
+     * apparently has changed and now an unexpected element type has appeared.
+     * This is a non recoverable error, since the parser and the grammar
+     * are not compatible.
+     * @return an error object to throw.
+     */
+    protected internalError(cx: ParserRuleContext, message: string): Error;
+    protected getLocation(cx: ParserRuleContext): DocumentLocation;
+    /**
+     * Log an error message relative to a parse node
+     */
+    protected contextError<T extends MessageCode>(cx: ParserRuleContext, code: T, data: MessageParameterType<T>, options?: LogMessageOptions): void;
+    protected getNumber(term: ParseTree): number;
+    protected defaultResult(): Node;
+    /**
+     * Get all the possibly missing annotations from this parse rule
+     * @param cx Any parse context which has an ANNOTATION* rules
+     * @returns Array of texts for the annotations
+     */
+    protected getAnnotations(cx: HasAnnotations): Malloy.Annotation[] | undefined;
+    protected getIsAnnotations(cx?: parse.IsDefineContext): Malloy.Annotation[] | undefined;
+    protected notAllowed(pcx: ParserRuleContext, what: string): void;
+    protected illegal(pcx: ParserRuleContext, what: string): void;
+    visitMalloyDocument(pcx: parse.MalloyDocumentContext): Malloy.Query | null;
+    visitRunStatement(pcx: parse.RunStatementContext): Malloy.Query | null;
+    protected getQueryReference(cx: parse.SQIDContext): Malloy.Reference | null;
+    protected getQueryDefinition(cx: parse.SqExprContext): Malloy.QueryDefinition | null;
+    protected getRefinementSegment(cx: parse.SegExprContext): Malloy.ViewDefinition | null;
+    protected getGroupByStatement(gbcx: parse.GroupByStatementContext): Malloy.ViewOperationWithGroupBy[] | null;
+    protected getAggregateStatement(agcx: parse.AggregateStatementContext): Malloy.ViewOperationWithAggregate[] | null;
+    protected getOrderByStatement(obcx: parse.OrderByStatementContext): Malloy.ViewOperationWithOrderBy[] | null;
+    protected getNestStatement(nstcx: parse.NestStatementContext): Malloy.ViewOperationWithNest[] | null;
+    protected getViewExpression(cx: parse.VExprContext): Malloy.ViewDefinition | null;
+    protected getLimitStatement(cx: parse.LimitStatementContext): Malloy.ViewOperationWithLimit | null;
+    protected getSegmentOperation(cx: parse.QueryStatementContext): Malloy.ViewOperation[] | null;
+    protected getFieldPath(pcx: parse.FieldPathContext): {
+        name: string;
+        path?: string[];
+    };
+    protected getTimeframe(cx: parse.TimeframeContext): Malloy.TimestampTimeframe | null;
+    protected getQueryField(cx: parse.QueryFieldEntryContext): {
+        name?: string;
+        field: Malloy.Field;
+    } | null;
+    getFieldExpression(cx: parse.FieldExprContext): Malloy.Expression | null;
+    getWhere(_whereCx: parse.WhereStatementContext): Malloy.Where[] | null;
+    protected combineAnnotations(...a: (Malloy.Annotation[] | undefined)[]): Malloy.Annotation[] | undefined;
+}
+export declare function malloyToQuery(code: string): {
+    query?: Malloy.Query;
+    logs: Malloy.LogMessage[];
+};
+export {};