@malloydata/malloy 0.0.43 → 0.0.44-dev230623185845

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

@@ -50,6 +50,25 @@ const AbstractParseTreeVisitor_1 = require("antlr4ts/tree/AbstractParseTreeVisit
 const ast = __importStar(require("./ast"));
 const Interval_1 = require("antlr4ts/misc/Interval");
 const ENABLE_M4_WARNINGS = false;
+class IgnoredElement extends ast.MalloyElement {
+    constructor(src) {
+        super();
+        this.elementType = 'ignoredByParser';
+        this.malloySrc = src;
+    }
+}
+/**
+ * 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
+ */
+function getNotes(cx) {
+    return cx.ANNOTATION().map(a => a.text);
+}
+function getIsNotes(cx) {
+    const before = getNotes(cx._beforeIs);
+    return before.concat(getNotes(cx._afterIs));
+}
 /**
  * ANTLR visitor pattern parse tree traversal. Generates a Malloy
  * AST from an ANTLR parse tree.
@@ -92,69 +111,18 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
             severity: sev,
         });
     }
-    onlyExploreProperties(els) {
-        const eps = [];
+    only(els, isGood, desc) {
+        const acceptable = [];
         for (const el of els) {
-            if (ast.isSourceProperty(el)) {
-                eps.push(el);
+            const checked = isGood(el);
+            if (checked) {
+                acceptable.push(checked);
             }
-            else {
-                this.astError(el, `Expected source property, not '${el.elementType}'`);
+            else if (!(el instanceof IgnoredElement)) {
+                this.astError(el, `Expected ${desc}, not '${el.elementType}'`);
             }
         }
-        return eps;
-    }
-    onlyJoins(els) {
-        const eps = [];
-        for (const el of els) {
-            if (el instanceof ast.Join) {
-                eps.push(el);
-            }
-            else {
-                this.astError(el, `Expected source property, not '${el.elementType}'`);
-            }
-        }
-        return eps;
-    }
-    onlyDocStatements(els) {
-        const eps = [];
-        for (const el of els) {
-            if (ast.isDocStatement(el)) {
-                eps.push(el);
-            }
-            else {
-                this.astError(el, `Expected statement, not '${el.elementType}'`);
-            }
-        }
-        return eps;
-    }
-    onlyNestedQueries(els) {
-        const eps = [];
-        for (const el of els) {
-            if (ast.isNestedQuery(el)) {
-                eps.push(el);
-            }
-            else {
-                this.astError(el, `Expected query, not '${el.elementType}'`);
-            }
-        }
-        return eps;
-    }
-    onlyQueryRefs(els) {
-        const eps = [];
-        for (const el of els) {
-            if (el instanceof ast.FieldReference ||
-                el instanceof ast.FieldDeclaration) {
-                eps.push(el);
-            }
-            else {
-                const reported = el instanceof ast.Unimplemented && el.reported;
-                if (!reported) {
-                    this.astError(el, `Expected query field, not '${el.elementType}'`);
-                }
-            }
-        }
-        return eps;
+        return acceptable;
     }
     getNumber(term) {
         return Number.parseInt(term.text);
@@ -260,19 +228,21 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         return this.astAt(def, pcx);
     }
     visitMalloyDocument(pcx) {
-        const stmts = this.onlyDocStatements(pcx.malloyStatement().map(scx => this.visit(scx)));
+        const stmts = this.only(pcx.malloyStatement().map(scx => this.visit(scx)), x => ast.isDocStatement(x) && x, 'statement');
         return new ast.Document(stmts);
     }
     visitDefineSourceStatement(pcx) {
         const defsCx = pcx.sourcePropertyList().sourceDefinition();
-        const defs = defsCx.map(dcx => this.visitsourceDefinition(dcx));
-        if (defs.length === 1) {
-            return defs[0];
-        }
-        return new ast.DefineSourceList(defs);
+        const defs = defsCx.map(dcx => this.visitSourceDefinition(dcx));
+        const blockNotes = getNotes(pcx.tags());
+        const defList = new ast.DefineSourceList(defs);
+        defList.extendNote({ blockNotes });
+        return defList;
     }
-    visitsourceDefinition(pcx) {
+    visitSourceDefinition(pcx) {
         const exploreDef = new ast.DefineSource(this.getIdText(pcx.sourceNameDef()), this.visitExplore(pcx.explore()), true, []);
+        const notes = getNotes(pcx.tags()).concat(getIsNotes(pcx.isDefine()));
+        exploreDef.extendNote({ notes });
         return this.astAt(exploreDef, pcx);
     }
     visitExplore(pcx) {
@@ -285,8 +255,8 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
     }
     visitExploreProperties(pcx) {
         const filterCx = pcx.filterShortcut();
-        const visited = pcx.exploreStatement().map(ecx => this.visit(ecx));
-        const propList = new ast.ExploreDesc(this.onlyExploreProperties(visited));
+        const visited = this.only(pcx.exploreStatement().map(ecx => this.visit(ecx)), x => ast.isSourceProperty(x) && x, 'source property');
+        const propList = new ast.SourceDesc(visited);
         if (filterCx) {
             propList.push(this.getFilterShortcut(filterCx));
         }
@@ -327,7 +297,9 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
                 }
             }
         }
-        return new ast.Joins(joins);
+        const joinMany = new ast.Joins(joins);
+        joinMany.extendNote({ blockNotes: getNotes(pcx.tags()) });
+        return joinMany;
     }
     visitDefJoinOne(pcx) {
         const joinList = this.getJoinList(pcx.joinList());
@@ -340,7 +312,9 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
                 }
             }
         }
-        return new ast.Joins(joins);
+        const joinOne = new ast.Joins(joins);
+        joinOne.extendNote({ blockNotes: getNotes(pcx.tags()) });
+        return joinOne;
     }
     visitDefJoinCross(pcx) {
         const joinList = this.getJoinList(pcx.joinList());
@@ -356,16 +330,20 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
                 }
             }
         }
-        return new ast.Joins(joins);
+        const joinCross = new ast.Joins(joins);
+        joinCross.extendNote({ blockNotes: getNotes(pcx.tags()) });
+        return joinCross;
     }
     getJoinList(pcx) {
         return pcx.joinDef().map(jcx => this.visit(jcx));
     }
     getJoinSource(name, ecx) {
         if (ecx) {
-            return this.visitExplore(ecx);
+            const joinSrc = this.visitExplore(ecx.explore());
+            const notes = getNotes(ecx._before_is).concat(getNotes(ecx._after_is));
+            return { joinFrom: joinSrc, notes };
         }
-        return new ast.NamedSource(name);
+        return { joinFrom: new ast.NamedSource(name), notes: [] };
     }
     visitQueryJoinStatement(pcx) {
         const result = this.astAt(this.visit(pcx.joinStatement()), pcx);
@@ -376,19 +354,21 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
     }
     visitJoinOn(pcx) {
         const joinAs = this.getModelEntryName(pcx.joinNameDef());
-        const joinFrom = this.getJoinSource(joinAs, pcx.explore());
+        const { joinFrom, notes } = this.getJoinSource(joinAs, pcx.isExplore());
         const join = new ast.ExpressionJoin(joinAs, joinFrom);
         const onCx = pcx.joinExpression();
         if (onCx) {
             join.joinOn = this.getFieldExpr(onCx);
         }
+        join.extendNote({ notes: getNotes(pcx).concat(notes) });
         return this.astAt(join, pcx);
     }
     visitJoinWith(pcx) {
         const joinAs = this.getModelEntryName(pcx.joinNameDef());
-        const joinFrom = this.getJoinSource(joinAs, pcx.explore());
+        const { joinFrom, notes } = this.getJoinSource(joinAs, pcx.isExplore());
         const joinOn = this.getFieldExpr(pcx.fieldExpr());
         const join = new ast.KeyJoin(joinAs, joinFrom, joinOn);
+        join.extendNote({ notes: getNotes(pcx).concat(notes) });
         return this.astAt(join, pcx);
     }
     getFieldDef(pcx, makeFieldDef) {
@@ -396,16 +376,20 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         const fieldName = this.getIdText(pcx.fieldNameDef());
         const valExpr = this.getFieldExpr(defCx);
         const def = new makeFieldDef(valExpr, fieldName, this.getSourceCode(defCx));
+        const notes = getNotes(pcx.tags()).concat(getIsNotes(pcx.isDefine()));
+        def.extendNote({ notes });
         return this.astAt(def, pcx);
     }
     visitDefDimensions(pcx) {
         const defs = this.getFieldDefs(pcx.defList().fieldDef(), ast.DimensionFieldDeclaration);
         const stmt = new ast.Dimensions(defs);
+        stmt.extendNote({ blockNotes: getNotes(pcx.tags()) });
         return this.astAt(stmt, pcx);
     }
     visitDefMeasures(pcx) {
         const defs = this.getFieldDefs(pcx.defList().fieldDef(), ast.MeasureFieldDeclaration);
         const stmt = new ast.Measures(defs);
+        stmt.extendNote({ blockNotes: getNotes(pcx.tags()) });
         return this.astAt(stmt, pcx);
     }
     visitQueryExtend(pcx) {
@@ -469,6 +453,12 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
             .map(cx => this.visitExploreQueryDef(cx));
         return new ast.Turtles(babyTurtles);
     }
+    visitDefExploreQuery(pcx) {
+        const queryDefs = this.visitSubQueryDefList(pcx.subQueryDefList());
+        const blockNotes = getNotes(pcx.tags());
+        queryDefs.extendNote({ blockNotes });
+        return queryDefs;
+    }
     visitDefExplorePrimaryKey(pcx) {
         const node = new ast.PrimaryKey(this.getFieldName(pcx.fieldName()));
         return this.astAt(node, pcx);
@@ -495,16 +485,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         return this.astAt(timezoneStatement, cx);
     }
     visitQueryProperties(pcx) {
-        const qProps = pcx
-            .queryStatement()
-            .map(qcx => this.astAt(this.visit(qcx), qcx))
-            .filter((p) => {
-            if (ast.isQueryProperty(p)) {
-                return true;
-            }
-            p.log(`Unexpected statement type '${p.elementType}' in query`);
-            return false;
-        });
+        const qProps = this.only(pcx.queryStatement().map(qcx => this.astAt(this.visit(qcx), qcx)), x => ast.isQueryProperty(x) && x, 'query statement');
         const fcx = pcx.filterShortcut();
         if (fcx) {
             qProps.push(this.getFilterShortcut(fcx));
@@ -519,18 +500,10 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         const dim = this.getFieldDef(pcx, makeFieldDef);
         return this.astAt(dim, pcx);
     }
-    // visitQueryFieldNameless(
-    //   pcx: parse.QueryFieldNamelessContext
-    // ): ast.MalloyElement {
-    //   this.contextError(pcx, `Expressions in queries must have names`);
-    //   const noItem = new ast.Unimplemented();
-    //   noItem.reported = true;
-    //   return noItem;
-    // }
     getQueryFieldEntry(ctx, makeFieldDef, makeFieldRef) {
-        const fieldPath = ctx.fieldPath();
-        if (fieldPath) {
-            return this.getFieldPath(fieldPath, makeFieldRef);
+        const refCx = ctx.taggedRef();
+        if (refCx) {
+            return this.getTaggedRef(refCx, makeFieldRef);
         }
         const def = ctx.fieldDef();
         if (def) {
@@ -539,28 +512,40 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         throw new Error('Expected query field entry to be a field reference or definition');
     }
     getQueryItems(pcx, makeFieldDef, makeFieldRef) {
-        const itemList = pcx
+        return this.only(pcx
             .queryFieldEntry()
-            .map(e => this.getQueryFieldEntry(e, makeFieldDef, makeFieldRef));
-        return this.onlyQueryRefs(itemList);
+            .map(e => this.getQueryFieldEntry(e, makeFieldDef, makeFieldRef)), x => x instanceof ast.FieldReference || x instanceof ast.FieldDeclaration
+            ? x
+            : false, 'query field');
     }
     visitAggregateStatement(pcx) {
-        return new ast.Aggregate(this.getQueryItems(pcx.queryFieldList(), ast.AggregateFieldDeclaration, ast.AggregateFieldReference));
+        const agStmt = new ast.Aggregate(this.getQueryItems(pcx.queryFieldList(), ast.AggregateFieldDeclaration, ast.AggregateFieldReference));
+        agStmt.extendNote({ blockNotes: getNotes(pcx.tags()) });
+        return agStmt;
     }
     visitGroupByStatement(pcx) {
-        return new ast.GroupBy(this.getQueryItems(pcx.queryFieldList(), ast.GroupByFieldDeclaration, ast.GroupByFieldReference));
+        const groupBy = new ast.GroupBy(this.getQueryItems(pcx.queryFieldList(), ast.GroupByFieldDeclaration, ast.GroupByFieldReference));
+        groupBy.extendNote({ blockNotes: getNotes(pcx.tags()) });
+        return groupBy;
     }
     visitCalculateStatement(pcx) {
-        return new ast.Calculate(this.getQueryItems(pcx.queryFieldList(), ast.CalculateFieldDeclaration, ast.CalculateFieldReference));
+        const stmt = new ast.Calculate(this.getQueryItems(pcx.queryFieldList(), ast.CalculateFieldDeclaration, ast.CalculateFieldReference));
+        stmt.extendNote({ blockNotes: getNotes(pcx.tags()) });
+        return stmt;
+    }
+    getTaggedRef(pcx, makeFieldRef) {
+        const ref = this.getFieldPath(pcx.fieldPath(), makeFieldRef);
+        ref.extendNote({ notes: getNotes(pcx.tags()) });
+        return ref;
     }
     getFieldCollectionMember(pcx, makeFieldDef, makeFieldRef) {
         const fieldDef = pcx.fieldDef();
         if (fieldDef) {
             return this.getFieldDef(fieldDef, makeFieldDef);
         }
-        const fieldPath = pcx.fieldPath();
-        if (fieldPath) {
-            return this.getFieldPath(fieldPath, makeFieldRef);
+        const refCx = pcx.taggedRef();
+        if (refCx) {
+            return this.getTaggedRef(refCx, makeFieldRef);
         }
         const collectionWildcard = pcx.collectionWildCard();
         if (collectionWildcard) {
@@ -575,6 +560,11 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
             .map(c => this.getFieldCollectionMember(c, ast.ProjectFieldDeclaration, ast.ProjectFieldReference));
         return this.astAt(new ast.ProjectStatement(fields), pcx);
     }
+    visitProjectStatement(pcx) {
+        const stmt = this.visitFieldCollection(pcx.fieldCollection());
+        stmt.extendNote({ blockNotes: getNotes(pcx.tags()) });
+        return stmt;
+    }
     visitCollectionWildCard(pcx) {
         const nameCx = pcx.fieldPath();
         const stars = pcx.STAR() ? '*' : '**';
@@ -689,28 +679,34 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         const stmts = pcx
             .topLevelQueryDef()
             .map(cx => this.visitTopLevelQueryDef(cx));
-        if (stmts.length === 1) {
-            return stmts[0];
-        }
-        return new ast.DefineQueryList(stmts);
+        const blockNotes = getNotes(pcx.tags());
+        const queryDefs = new ast.DefineQueryList(stmts);
+        queryDefs.extendNote({ blockNotes });
+        return queryDefs;
     }
     visitTopLevelQueryDef(pcx) {
         const queryName = this.getIdText(pcx.queryName());
-        const queryDef = this.visit(pcx.query());
-        if (ast.isQueryElement(queryDef)) {
-            return this.astAt(new ast.DefineQuery(queryName, queryDef), pcx);
+        const queryExpr = this.visit(pcx.query());
+        if (ast.isQueryElement(queryExpr)) {
+            const notes = getNotes(pcx.tags()).concat(getIsNotes(pcx.isDefine()));
+            const queryDef = new ast.DefineQuery(queryName, queryExpr);
+            queryDef.extendNote({ notes });
+            return this.astAt(queryDef, pcx);
         }
-        throw this.internalError(pcx, `Expect query definition, got a '${queryDef.elementType}'`);
+        throw this.internalError(pcx, `Expected query definition, got a '${queryExpr.elementType}'`);
     }
     visitAnonymousQuery(pcx) {
         const defCx = pcx.topLevelAnonQueryDef();
         const query = this.visit(defCx.query());
         if (ast.isQueryElement(query)) {
-            const el = this.astAt(new ast.AnonymousQuery(query), defCx);
+            const theQuery = new ast.AnonymousQuery(query);
+            const notes = getNotes(pcx.topLevelAnonQueryDef().tags());
+            const blockNotes = getNotes(pcx.tags());
+            theQuery.extendNote({ notes, blockNotes });
             if (ENABLE_M4_WARNINGS) {
-                this.astError(el, 'Anonymous `query:` statements are deprecated, use `run:` instead', 'warn');
+                this.astError(theQuery, 'Anonymous `query:` statements are deprecated, use `run:` instead', 'warn');
             }
-            return el;
+            return this.astAt(theQuery, pcx);
         }
         throw this.internalError(pcx, `Anonymous query matched, but ${query.elementType} found`);
     }
@@ -718,6 +714,8 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         const query = this.visit(pcx.topLevelAnonQueryDef().query());
         if (ast.isQueryElement(query)) {
             const el = new ast.RunQueryDef(query);
+            el.extendNote({ blockNotes: getNotes(pcx._blockTags) });
+            el.extendNote({ notes: getNotes(pcx._noteTags) });
             return this.astAt(el, pcx);
         }
         throw this.internalError(pcx, `Run query matched, but ${query.elementType} found`);
@@ -727,33 +725,43 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         const el = this.astAt(new ast.RunQueryRef(name), pcx.queryName());
         return this.astAt(el, pcx);
     }
+    visitNestStatement(pcx) {
+        const nests = this.visitNestedQueryList(pcx.nestedQueryList());
+        nests.extendNote({ blockNotes: getNotes(pcx.tags()) });
+        return nests;
+    }
     visitNestedQueryList(pcx) {
-        const nestedList = pcx.nestEntry().map(cx => this.visit(cx));
-        if (nestedList.length === 1) {
-            return nestedList[0];
-        }
-        return new ast.Nests(this.onlyNestedQueries(nestedList));
+        return new ast.Nests(this.only(pcx.nestEntry().map(cx => this.visit(cx)), x => ast.isNestedQuery(x) && x, 'query'));
     }
     visitNestExisting(pcx) {
         const name = this.getFieldName(pcx.queryName());
         const propsCx = pcx.queryProperties();
+        const notes = getNotes(pcx.tags());
         if (propsCx) {
             const nestRefine = new ast.NestRefinement(name);
             const queryDesc = this.visitQueryProperties(propsCx);
             nestRefine.refineHead(queryDesc);
+            nestRefine.extendNote({ notes });
             return this.astAt(nestRefine, pcx);
         }
-        return this.astAt(new ast.NestReference(name), pcx);
+        const nestRef = this.astAt(new ast.NestReference(name), pcx);
+        nestRef.extendNote({ notes });
+        return nestRef;
     }
     visitNestDef(pcx) {
         const name = this.getIdText(pcx.queryName());
         const nestDef = new ast.NestDefinition(name);
         this.buildPipelineFromName(nestDef, pcx.pipelineFromName());
+        nestDef.extendNote({
+            notes: getNotes(pcx.tags()).concat(getIsNotes(pcx.isDefine())),
+        });
         return this.astAt(nestDef, pcx);
     }
     visitExploreQueryDef(pcx) {
         const name = this.getIdText(pcx.exploreQueryNameDef());
         const queryDef = new ast.TurtleDecl(name);
+        const notes = getNotes(pcx).concat(getIsNotes(pcx.isDefine()));
+        queryDef.extendNote({ notes });
         this.buildPipelineFromName(queryDef, pcx.pipelineFromName());
         return this.astAt(queryDef, pcx);
     }
@@ -1102,6 +1110,20 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         const enabled = pcx.sampleSpec().TRUE() !== undefined;
         return new ast.SampleProperty({ enable: enabled });
     }
+    visitDocAnnotations(pcx) {
+        const allNotes = pcx.DOC_ANNOTATION().map(note => note.text);
+        return new ast.ModelAnnotation(allNotes);
+    }
+    visitIgnoredObjectAnnotations(pcx) {
+        return new IgnoredElement(pcx.text);
+    }
+    visitIgnoredModelAnnotations(pcx) {
+        return new IgnoredElement(pcx.text);
+    }
+    visitDefExploreAnnotation(pcx) {
+        const allNotes = pcx.ANNOTATION().map(note => note.text);
+        return new ast.ObjectAnnotation(allNotes);
+    }
 }
 exports.MalloyToAST = MalloyToAST;
 //# sourceMappingURL=malloy-to-ast.js.map

package/dist/lang/parse-tree-walkers/document-symbol-walker.js

@@ -135,7 +135,8 @@ class DocumentSymbolWalker {
         }
     }
     enterQueryFieldEntry(pcx) {
-        const fieldRef = pcx.fieldPath();
+        var _a;
+        const fieldRef = (_a = pcx.taggedRef()) === null || _a === void 0 ? void 0 : _a.fieldPath();
         if (fieldRef === undefined)
             return;
         const symbol = {

package/dist/lang/test/annotation.spec.d.ts

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