@malloydata/malloy 0.0.1

package/dist/lang/parse-tree-walkers/find-external-references.js

@@ -0,0 +1,51 @@
+"use strict";
+/*
+ * Copyright 2021 Google LLC
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findReferences = void 0;
+const ParseTreeWalker_1 = require("antlr4ts/tree/ParseTreeWalker");
+class FindExternalReferences {
+    constructor(trans, tokens) {
+        this.trans = trans;
+        this.tokens = tokens;
+        this.needTables = {};
+        this.needImports = {};
+    }
+    enterTableName(pcx) {
+        const tableName = this.tokens.getText(pcx).slice(1, -1);
+        if (!this.needTables[tableName]) {
+            this.needTables[tableName] = this.trans.rangeFromContext(pcx);
+        }
+    }
+    enterImportURL(pcx) {
+        const url = JSON.parse(pcx.JSON_STRING().text);
+        if (!this.needImports[url]) {
+            this.needImports[url] = this.trans.rangeFromContext(pcx);
+        }
+    }
+}
+function findReferences(trans, tokens, parseTree) {
+    const finder = new FindExternalReferences(trans, tokens);
+    const listener = finder;
+    ParseTreeWalker_1.ParseTreeWalker.DEFAULT.walk(listener, parseTree);
+    let refs = {};
+    if (Object.keys(finder.needTables).length > 0) {
+        refs = { tables: finder.needTables };
+    }
+    if (Object.keys(finder.needImports).length > 0) {
+        refs = { ...refs, urls: finder.needImports };
+    }
+    return Object.keys(refs).length > 0 ? refs : null;
+}
+exports.findReferences = findReferences;
+//# sourceMappingURL=find-external-references.js.map

package/dist/lang/reference-list.d.ts

@@ -0,0 +1,10 @@
+import { DocumentReference, DocumentPosition } from "../model";
+export declare class ReferenceList {
+    private readonly sourceURL;
+    constructor(sourceURL: string);
+    private readonly references;
+    private findIndexBefore;
+    add(reference: DocumentReference): void;
+    private isPositionEqual;
+    find(position: DocumentPosition): DocumentReference | undefined;
+}

package/dist/lang/reference-list.js

@@ -0,0 +1,80 @@
+"use strict";
+/*
+ * Copyright 2022 Google LLC
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReferenceList = void 0;
+class ReferenceList {
+    constructor(sourceURL) {
+        this.sourceURL = sourceURL;
+        // These should always be sorted by their end positions
+        this.references = [];
+    }
+    findIndexBefore(position) {
+        let low = 0;
+        let high = this.references.length;
+        while (low < high) {
+            const middle = Math.floor((low + high) / 2);
+            const compare = this.references[middle].location.range.end;
+            if (compare.line < position.line ||
+                (compare.line === position.line &&
+                    compare.character < position.character)) {
+                low = middle + 1;
+            }
+            else {
+                high = middle;
+            }
+        }
+        return low;
+    }
+    add(reference) {
+        // Ignore any reference in another file
+        if (reference.location.url !== this.sourceURL) {
+            return;
+        }
+        const insertIndex = this.findIndexBefore(reference.location.range.end);
+        // Ignore duplicate references
+        if (insertIndex < this.references.length &&
+            this.isPositionEqual(reference, this.references[insertIndex])) {
+            return;
+        }
+        this.references.splice(insertIndex, 0, reference);
+    }
+    isPositionEqual(referenceA, referenceB) {
+        const rangeA = referenceA.location.range;
+        const rangeB = referenceB.location.range;
+        return (rangeA.start.line === rangeB.start.line &&
+            rangeA.start.character === rangeB.start.character &&
+            rangeA.end.line === rangeB.end.line &&
+            rangeA.end.character === rangeB.end.character);
+    }
+    find(position) {
+        // Here we assume that references DO NOT overlap. And then we do a binary
+        // search to find the one we're looking for.
+        const index = this.findIndexBefore(position);
+        if (index === this.references.length) {
+            return undefined;
+        }
+        const reference = this.references[index];
+        if (reference.location.range.start.line <= position.line &&
+            reference.location.range.end.line >= position.line &&
+            (position.line !== reference.location.range.start.line ||
+                position.character >= reference.location.range.start.character) &&
+            (position.line !== reference.location.range.end.line ||
+                position.character <= reference.location.range.end.character)) {
+            return reference;
+        }
+        return undefined;
+    }
+}
+exports.ReferenceList = ReferenceList;
+//# sourceMappingURL=reference-list.js.map

package/dist/lang/space-field.d.ts

@@ -0,0 +1,119 @@
+import * as model from "../model/malloy_types";
+import { FieldSpace, FSPair, DynamicSpace, QuerySpace } from "./field-space";
+import { FieldValueType, FieldDeclaration, TurtleDecl, HasParameter, Join, FieldReference } from "./ast";
+interface FieldType {
+    type: FieldValueType;
+    aggregate?: boolean;
+}
+export declare abstract class SpaceEntry {
+    abstract type(): FieldType;
+    abstract refType: "field" | "parameter";
+}
+export declare abstract class SpaceParam extends SpaceEntry {
+    abstract parameter(): model.Parameter;
+    readonly refType = "parameter";
+}
+export declare class DefinedParameter extends SpaceParam {
+    readonly paramDef: model.Parameter;
+    constructor(paramDef: model.Parameter);
+    parameter(): model.Parameter;
+    type(): FieldType;
+}
+export declare class AbstractParameter extends SpaceParam {
+    readonly astParam: HasParameter;
+    constructor(astParam: HasParameter);
+    parameter(): model.Parameter;
+    type(): FieldType;
+}
+export declare abstract class SpaceField extends SpaceEntry {
+    readonly refType = "field";
+    protected fieldTypeFromFieldDef(def: model.FieldDef): FieldType;
+    getQueryFieldDef(_fs: FSPair): model.QueryFieldDef | undefined;
+    fieldDef(): model.FieldDef | undefined;
+}
+export declare class RenameSpaceField extends SpaceField {
+    private readonly otherField;
+    private readonly newName;
+    private readonly location;
+    constructor(otherField: SpaceField, newName: string, location: model.DocumentLocation);
+    fieldDef(): model.FieldDef | undefined;
+    type(): FieldType;
+}
+export declare class WildSpaceField extends SpaceField {
+    readonly wildText: string;
+    constructor(wildText: string);
+    type(): FieldType;
+    getQueryFieldDef(_fs: FSPair): model.QueryFieldDef;
+}
+export declare class StructSpaceField extends SpaceField {
+    protected sourceDef: model.StructDef;
+    protected space?: FieldSpace;
+    constructor(sourceDef: model.StructDef);
+    get fieldSpace(): FieldSpace;
+    fieldDef(): model.FieldDef;
+    type(): FieldType;
+}
+export declare class JoinSpaceField extends StructSpaceField {
+    readonly intoFS: FieldSpace;
+    readonly join: Join;
+    constructor(intoFS: FieldSpace, join: Join);
+}
+export declare class ColumnSpaceField extends SpaceField {
+    protected def: model.FieldTypeDef;
+    constructor(def: model.FieldTypeDef);
+    fieldDef(): model.FieldDef;
+    type(): FieldType;
+}
+export declare abstract class QueryField extends SpaceField {
+    protected inSpace: FieldSpace;
+    constructor(inSpace: FieldSpace);
+    getQueryFieldDef(_fs: FSPair): model.QueryFieldDef | undefined;
+    type(): FieldType;
+}
+export declare class QueryFieldAST extends QueryField {
+    readonly turtle: TurtleDecl;
+    protected name: string;
+    renameAs?: string;
+    nestParent?: QuerySpace;
+    constructor(fs: FieldSpace, turtle: TurtleDecl, name: string);
+    fieldDef(): model.TurtleDef;
+}
+export declare class QueryFieldStruct extends QueryField {
+    protected turtleDef: model.TurtleDef;
+    constructor(fs: FieldSpace, turtleDef: model.TurtleDef);
+    rename(name: string): void;
+    fieldDef(): model.TurtleDef;
+}
+/**
+ * FilteredAliasedName
+ */
+export declare class FANSPaceField extends SpaceField {
+    readonly ref: FieldReference;
+    readonly inSpace: FieldSpace;
+    as?: string;
+    filterList?: model.FilterExpression[];
+    constructor(ref: FieldReference, inSpace: FieldSpace, refInit?: Partial<model.FilteredAliasedName>);
+    name(): string;
+    private filtersPresent;
+    fieldDef(): model.FieldDef | undefined;
+    getQueryFieldDef(_fs: FSPair): model.QueryFieldDef;
+    type(): FieldType;
+}
+export declare class ReferenceField extends SpaceField {
+    readonly fieldRef: FieldReference;
+    constructor(fieldRef: FieldReference);
+    getQueryFieldDef(fs: FSPair): model.QueryFieldDef | undefined;
+    type(): FieldType;
+}
+export declare class ExpressionFieldFromAst extends SpaceField {
+    readonly space: DynamicSpace;
+    readonly exprDef: FieldDeclaration;
+    fieldName: string;
+    defType?: FieldType;
+    constructor(space: DynamicSpace, exprDef: FieldDeclaration);
+    get name(): string;
+    fieldDef(): model.FieldDef;
+    getQueryFieldDef(fs: FSPair): model.QueryFieldDef;
+    type(): FieldType;
+}
+export {};

package/dist/lang/space-field.js

@@ -0,0 +1,339 @@
+"use strict";
+/*
+ * Copyright 2021 Google LLC
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressionFieldFromAst = exports.ReferenceField = exports.FANSPaceField = exports.QueryFieldStruct = exports.QueryFieldAST = exports.QueryField = exports.ColumnSpaceField = exports.JoinSpaceField = exports.StructSpaceField = exports.WildSpaceField = exports.RenameSpaceField = exports.SpaceField = exports.AbstractParameter = exports.DefinedParameter = exports.SpaceParam = exports.SpaceEntry = void 0;
+const model = __importStar(require("../model/malloy_types"));
+const field_space_1 = require("./field-space");
+class SpaceEntry {
+}
+exports.SpaceEntry = SpaceEntry;
+class SpaceParam extends SpaceEntry {
+    constructor() {
+        super(...arguments);
+        this.refType = "parameter";
+    }
+}
+exports.SpaceParam = SpaceParam;
+class DefinedParameter extends SpaceParam {
+    constructor(paramDef) {
+        super();
+        this.paramDef = paramDef;
+    }
+    parameter() {
+        return this.paramDef;
+    }
+    type() {
+        return { type: this.paramDef.type };
+    }
+}
+exports.DefinedParameter = DefinedParameter;
+class AbstractParameter extends SpaceParam {
+    constructor(astParam) {
+        super();
+        this.astParam = astParam;
+    }
+    parameter() {
+        return this.astParam.parameter();
+    }
+    type() {
+        const type = this.astParam.type || "unknown";
+        return { type };
+    }
+}
+exports.AbstractParameter = AbstractParameter;
+class SpaceField extends SpaceEntry {
+    constructor() {
+        super(...arguments);
+        this.refType = "field";
+    }
+    fieldTypeFromFieldDef(def) {
+        const ref = { type: def.type };
+        if (model.isFieldTypeDef(def) && def.aggregate) {
+            ref.aggregate = true;
+        }
+        return ref;
+    }
+    getQueryFieldDef(_fs) {
+        return undefined;
+    }
+    fieldDef() {
+        return undefined;
+    }
+}
+exports.SpaceField = SpaceField;
+class RenameSpaceField extends SpaceField {
+    constructor(otherField, newName, location) {
+        super();
+        this.otherField = otherField;
+        this.newName = newName;
+        this.location = location;
+    }
+    fieldDef() {
+        const renamedFieldRaw = this.otherField.fieldDef();
+        if (renamedFieldRaw === undefined) {
+            return undefined;
+        }
+        return {
+            ...renamedFieldRaw,
+            as: this.newName,
+            location: this.location,
+        };
+    }
+    type() {
+        return this.otherField.type();
+    }
+}
+exports.RenameSpaceField = RenameSpaceField;
+class WildSpaceField extends SpaceField {
+    constructor(wildText) {
+        super();
+        this.wildText = wildText;
+    }
+    type() {
+        throw new Error("should never ask a wild field for its type");
+    }
+    getQueryFieldDef(_fs) {
+        return this.wildText;
+    }
+}
+exports.WildSpaceField = WildSpaceField;
+class StructSpaceField extends SpaceField {
+    constructor(sourceDef) {
+        super();
+        this.sourceDef = sourceDef;
+    }
+    get fieldSpace() {
+        if (!this.space) {
+            this.space = new field_space_1.StaticSpace(this.sourceDef);
+        }
+        return this.space;
+    }
+    fieldDef() {
+        return this.sourceDef;
+    }
+    type() {
+        return { type: "struct" };
+    }
+}
+exports.StructSpaceField = StructSpaceField;
+class JoinSpaceField extends StructSpaceField {
+    constructor(intoFS, join) {
+        super(join.structDef());
+        this.intoFS = intoFS;
+        this.join = join;
+    }
+}
+exports.JoinSpaceField = JoinSpaceField;
+class ColumnSpaceField extends SpaceField {
+    constructor(def) {
+        super();
+        this.def = def;
+    }
+    fieldDef() {
+        return this.def;
+    }
+    type() {
+        return this.fieldTypeFromFieldDef(this.def);
+    }
+}
+exports.ColumnSpaceField = ColumnSpaceField;
+class QueryField extends SpaceField {
+    constructor(inSpace) {
+        super();
+        this.inSpace = inSpace;
+    }
+    getQueryFieldDef(_fs) {
+        return this.fieldDef();
+    }
+    type() {
+        return { type: "turtle" };
+    }
+}
+exports.QueryField = QueryField;
+class QueryFieldAST extends QueryField {
+    constructor(fs, turtle, name) {
+        super(fs);
+        this.turtle = turtle;
+        this.name = name;
+    }
+    fieldDef() {
+        const def = this.turtle.getFieldDef(this.inSpace, this.nestParent);
+        if (this.renameAs) {
+            def.as = this.renameAs;
+        }
+        return def;
+    }
+}
+exports.QueryFieldAST = QueryFieldAST;
+class QueryFieldStruct extends QueryField {
+    constructor(fs, turtleDef) {
+        super(fs);
+        this.turtleDef = turtleDef;
+    }
+    rename(name) {
+        this.turtleDef = {
+            ...this.turtleDef,
+            as: name,
+        };
+    }
+    fieldDef() {
+        return this.turtleDef;
+    }
+}
+exports.QueryFieldStruct = QueryFieldStruct;
+/**
+ * FilteredAliasedName
+ */
+class FANSPaceField extends SpaceField {
+    constructor(ref, inSpace, refInit) {
+        super();
+        this.ref = ref;
+        this.inSpace = inSpace;
+        Object.assign(this, refInit);
+    }
+    name() {
+        return this.as || this.ref.refString;
+    }
+    filtersPresent() {
+        return this.filterList && this.filterList.length > 0;
+    }
+    fieldDef() {
+        if (this.as === undefined) {
+            return undefined;
+        }
+        const fromField = this.ref.getField(this.inSpace).found;
+        if (fromField === undefined) {
+            // TODO should errror
+            return undefined;
+        }
+        const fieldTypeInfo = fromField.type();
+        const fieldType = fieldTypeInfo.type;
+        // TODO starting to feel like this should be a method call on a spaceentry
+        if (model.isAtomicFieldType(fieldType)) {
+            if (fromField instanceof SpaceParam) {
+                return {
+                    type: fieldType,
+                    name: this.as,
+                    e: [{ type: "parameter", path: this.ref.refString }],
+                    aggregate: false,
+                };
+            }
+            let fieldExpr = [{ type: "field", path: this.ref.refString }];
+            if (this.filtersPresent() && this.filterList) {
+                const newfieldExpr = [
+                    {
+                        type: "filterExpression",
+                        filterList: this.filterList,
+                        e: fieldExpr,
+                    },
+                ];
+                fieldExpr = newfieldExpr;
+            }
+            return {
+                type: fieldType,
+                name: this.as,
+                e: fieldExpr,
+                aggregate: fieldTypeInfo.aggregate,
+            };
+        }
+        return undefined;
+    }
+    getQueryFieldDef(_fs) {
+        // TODO if this reference is to a field which does not exist
+        // it needs to be an error SOMEWHERE
+        const n = { name: this.ref.refString };
+        if (this.filtersPresent()) {
+            n.filterList = this.filterList;
+        }
+        if (this.as) {
+            n.as = this.as;
+        }
+        return n.as || n.filterList ? n : this.ref.refString;
+    }
+    type() {
+        const field = this.ref.getField(this.inSpace).found;
+        return (field === null || field === void 0 ? void 0 : field.type()) || { type: "unknown" };
+    }
+}
+exports.FANSPaceField = FANSPaceField;
+class ReferenceField extends SpaceField {
+    constructor(fieldRef) {
+        super();
+        this.fieldRef = fieldRef;
+    }
+    getQueryFieldDef(fs) {
+        // Lookup string and generate error if it isn't defined.
+        const check = this.fieldRef.getField(fs.in);
+        if (check.error) {
+            this.fieldRef.log(check.error);
+        }
+        return this.fieldRef.refString;
+    }
+    type() {
+        return { type: "unknown" };
+    }
+}
+exports.ReferenceField = ReferenceField;
+class ExpressionFieldFromAst extends SpaceField {
+    constructor(space, exprDef) {
+        super();
+        this.space = space;
+        this.exprDef = exprDef;
+        this.fieldName = exprDef.defineName;
+    }
+    get name() {
+        return this.fieldName;
+    }
+    fieldDef() {
+        const def = this.exprDef.fieldDef(this.space, this.name);
+        this.defType = this.fieldTypeFromFieldDef(def);
+        return def;
+    }
+    getQueryFieldDef(fs) {
+        const def = this.exprDef.queryFieldDef(fs, this.name);
+        this.defType = this.fieldTypeFromFieldDef(def);
+        return def;
+    }
+    type() {
+        if (this.defType) {
+            return this.defType;
+        }
+        return this.fieldTypeFromFieldDef(this.fieldDef());
+    }
+}
+exports.ExpressionFieldFromAst = ExpressionFieldFromAst;
+//# sourceMappingURL=space-field.js.map

package/dist/lang/test/document-help-context-walker.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lang/test/document-help-context-walker.spec.js

@@ -0,0 +1,45 @@
+"use strict";
+/*
+ * Copyright 2022 Google LLC
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_translator_1 = require("./test-translator");
+function testHelpContext(source, position, type, token) {
+    const doc = new test_translator_1.TestTranslator(source.code);
+    expect(doc.logger.hasErrors()).toBeFalsy();
+    const helpContext = doc.helpContext(position).helpContext;
+    expect(helpContext).toEqual({ type, token });
+}
+const source = `source: foo is table('bar') {
+  where: bazz ~ 'biff'
+  query: foo is {
+    group_by: bazz
+    where: bop ~ 'blat'
+  }
+}
+
+query: bar {
+  group_by: bazz
+}`;
+test("Supports model properties", () => {
+    testHelpContext((0, test_translator_1.markSource) `${source}`, { line: 0, character: 1 }, "model_property", "source:");
+    testHelpContext((0, test_translator_1.markSource) `${source}`, { line: 8, character: 1 }, "model_property", "query:");
+});
+test("Supports explore properties", () => {
+    testHelpContext((0, test_translator_1.markSource) `${source}`, { line: 1, character: 3 }, "explore_property", "where:");
+    testHelpContext((0, test_translator_1.markSource) `${source}`, { line: 2, character: 3 }, "explore_property", "query:");
+});
+test("Supports query properties", () => {
+    testHelpContext((0, test_translator_1.markSource) `${source}`, { line: 3, character: 5 }, "query_property", "group_by:");
+    testHelpContext((0, test_translator_1.markSource) `${source}`, { line: 4, character: 5 }, "query_property", "where:");
+});
+//# sourceMappingURL=document-help-context-walker.spec.js.map

package/dist/lang/test/document-symbol-walker.spec.d.ts

@@ -0,0 +1 @@
+export {};