@malloydata/malloy 0.0.22-dev230207144036 → 0.0.22-dev230207171614

package/dist/lang/ast/types/explore-field.js

@@ -0,0 +1,32 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExploreField = void 0;
+const renames_1 = require("../source-properties/renames");
+const field_decl_1 = require("./field-decl");
+function isExploreField(f) {
+    return (0, field_decl_1.isFieldDecl)(f) || f instanceof renames_1.RenameField;
+}
+exports.isExploreField = isExploreField;
+//# sourceMappingURL=explore-field.js.map

package/dist/lang/ast/types/expr-result.d.ts

@@ -0,0 +1,5 @@
+import { Fragment } from "../../../model/malloy_types";
+import { TypeDesc } from "./type-desc";
+export interface ExprResult extends TypeDesc {
+    value: Fragment[];
+}

package/dist/lang/ast/types/expr-result.js

@@ -0,0 +1,25 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=expr-result.js.map

package/dist/lang/ast/types/expr-value.d.ts

@@ -0,0 +1,3 @@
+import { GranularResult } from "./granular-result";
+import { ExprResult } from "./expr-result";
+export declare type ExprValue = ExprResult | GranularResult;

package/dist/lang/ast/types/expr-value.js

@@ -0,0 +1,25 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=expr-value.js.map

package/dist/lang/ast/types/expression-def.d.ts

@@ -0,0 +1,69 @@
+import { TimestampUnit } from "../../../model/malloy_types";
+import { ExprValue } from "./expr-value";
+import { FieldSpace } from "./field-space";
+import { MalloyElement } from "./malloy-element";
+/**
+ * Root node for any element in an expression. These essentially
+ * create a sub-tree in the larger AST. Expression nodes know
+ * how to write themselves as SQL (or rather, generate the
+ * template for SQL required by the query writer)
+ */
+export declare abstract class ExpressionDef extends MalloyElement {
+    abstract elementType: string;
+    granular(): boolean;
+    /**
+     * Returns the "translation" or template for SQL generation. When asking
+     * for a tranlsation you may pass the types you can accept, allowing
+     * the translation code a chance to convert to match your expectations
+     * @param space Namespace for looking up field references
+     */
+    abstract getExpression(fs: FieldSpace): ExprValue;
+    legalChildTypes: import("./type-desc").TypeDesc[];
+    /**
+     * Some operators want to give the right hand value a chance to
+     * rewrite itself. This requests a translation for a rewrite,
+     * or returns undefined if that request should be denied.
+     * @param fs FieldSpace
+     * @returns Translated expression or undefined
+     */
+    requestExpression(fs: FieldSpace): ExprValue | undefined;
+    defaultFieldName(): string | undefined;
+    /**
+     * Check an expression for type compatibility
+     * @param _eNode currently unused, will be used to get error location
+     * @param eVal ...list of expressions that must match legalChildTypes
+     */
+    typeCheck(eNode: ExpressionDef, eVal: ExprValue): boolean;
+    /**
+     * This is the operation which makes partial comparison and value trees work
+     * The default implemention merely constructs LEFT OP RIGHT, but specialized
+     * nodes like alternation trees or or partial comparison can control how
+     * the appplication gets generated
+     * @param fs The symbol table
+     * @param op The operator being applied
+     * @param expr The "other" (besdies 'this') value
+     * @returns The translated expression
+     */
+    apply(fs: FieldSpace, op: string, left: ExpressionDef): ExprValue;
+}
+export declare class ExprDuration extends ExpressionDef {
+    readonly n: ExpressionDef;
+    readonly timeframe: TimestampUnit;
+    elementType: string;
+    legalChildTypes: import("./type-desc").TypeDesc[];
+    constructor(n: ExpressionDef, timeframe: TimestampUnit);
+    apply(fs: FieldSpace, op: string, left: ExpressionDef): ExprValue;
+    getExpression(_fs: FieldSpace): ExprValue;
+}
+/**
+ * All of the magic of malloy expressions eventually flows to here,
+ * where an operator is applied to two values. Depending on the
+ * operator and value types this may involve transformations of
+ * the values or even the operator.
+ * @param fs FieldSpace for the symbols
+ * @param left Left value
+ * @param op The operator
+ * @param right Right Value
+ * @returns ExprValue of the expression
+ */
+export declare function applyBinary(fs: FieldSpace, left: ExpressionDef, op: string, right: ExpressionDef): ExprValue;

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

@@ -0,0 +1,346 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyBinary = exports.ExprDuration = exports.ExpressionDef = void 0;
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+const malloy_types_1 = require("../../../model/malloy_types");
+const ast_utils_1 = require("../ast-utils");
+const utils_1 = require("../expressions/utils");
+const fragtype_utils_1 = require("../fragtype-utils");
+const time_utils_1 = require("../time-utils");
+const comparison_1 = require("./comparison");
+const equality_1 = require("./equality");
+const granular_result_1 = require("./granular-result");
+const malloy_element_1 = require("./malloy-element");
+class TypeMismatch extends Error {
+}
+/**
+ * Root node for any element in an expression. These essentially
+ * create a sub-tree in the larger AST. Expression nodes know
+ * how to write themselves as SQL (or rather, generate the
+ * template for SQL required by the query writer)
+ */
+class ExpressionDef extends malloy_element_1.MalloyElement {
+    constructor() {
+        super(...arguments);
+        this.legalChildTypes = fragtype_utils_1.FT.anyAtomicT;
+    }
+    granular() {
+        return false;
+    }
+    /**
+     * Some operators want to give the right hand value a chance to
+     * rewrite itself. This requests a translation for a rewrite,
+     * or returns undefined if that request should be denied.
+     * @param fs FieldSpace
+     * @returns Translated expression or undefined
+     */
+    requestExpression(fs) {
+        return this.getExpression(fs);
+    }
+    defaultFieldName() {
+        return undefined;
+    }
+    /**
+     * Check an expression for type compatibility
+     * @param _eNode currently unused, will be used to get error location
+     * @param eVal ...list of expressions that must match legalChildTypes
+     */
+    typeCheck(eNode, eVal) {
+        if (!fragtype_utils_1.FT.in(eVal, this.legalChildTypes)) {
+            eNode.log(`'${this.elementType}' Can't use type ${fragtype_utils_1.FT.inspect(eVal)}`);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * This is the operation which makes partial comparison and value trees work
+     * The default implemention merely constructs LEFT OP RIGHT, but specialized
+     * nodes like alternation trees or or partial comparison can control how
+     * the appplication gets generated
+     * @param fs The symbol table
+     * @param op The operator being applied
+     * @param expr The "other" (besdies 'this') value
+     * @returns The translated expression
+     */
+    apply(fs, op, left) {
+        return applyBinary(fs, left, op, this);
+    }
+}
+exports.ExpressionDef = ExpressionDef;
+class ExprDuration extends ExpressionDef {
+    constructor(n, timeframe) {
+        super({ n });
+        this.n = n;
+        this.timeframe = timeframe;
+        this.elementType = "duration";
+        this.legalChildTypes = [fragtype_utils_1.FT.timestampT, fragtype_utils_1.FT.dateT];
+    }
+    apply(fs, op, left) {
+        const lhs = left.getExpression(fs);
+        this.typeCheck(this, lhs);
+        if ((0, malloy_types_1.isTimeFieldType)(lhs.dataType) && (op === "+" || op === "-")) {
+            const num = this.n.getExpression(fs);
+            if (!fragtype_utils_1.FT.typeEq(num, fragtype_utils_1.FT.numberT)) {
+                this.log(`Duration units needs number not '${num.dataType}`);
+                return (0, ast_utils_1.errorFor)("illegal unit expression");
+            }
+            let resultGranularity;
+            // Only allow the output of this to be granular if the
+            // granularities match, this is still an area where
+            // more thought is required.
+            if ((0, granular_result_1.isGranularResult)(lhs) && lhs.timeframe == this.timeframe) {
+                resultGranularity = lhs.timeframe;
+            }
+            if (lhs.dataType === "timestamp") {
+                const result = (0, time_utils_1.timeOffset)("timestamp", lhs.value, op, num.value, this.timeframe);
+                return (0, time_utils_1.timeResult)({
+                    dataType: "timestamp",
+                    expressionType: (0, malloy_types_1.maxExpressionType)(lhs.expressionType, num.expressionType),
+                    value: result,
+                }, resultGranularity);
+            }
+            return (0, time_utils_1.timeResult)({
+                dataType: "date",
+                expressionType: (0, malloy_types_1.maxExpressionType)(lhs.expressionType, num.expressionType),
+                value: (0, time_utils_1.timeOffset)("date", lhs.value, op, num.value, this.timeframe),
+            }, resultGranularity);
+        }
+        return super.apply(fs, op, left);
+    }
+    getExpression(_fs) {
+        return {
+            dataType: "duration",
+            expressionType: "scalar",
+            value: ["__ERROR_DURATION_IS_NOT_A_VALUE__"],
+        };
+    }
+}
+exports.ExprDuration = ExprDuration;
+function timeCompare(lhs, op, rhs) {
+    if ((0, malloy_types_1.isTimeFieldType)(lhs.dataType) && (0, malloy_types_1.isTimeFieldType)(rhs.dataType)) {
+        if (lhs.dataType !== rhs.dataType) {
+            let lval = lhs.value;
+            let rval = rhs.value;
+            if (lhs.dataType === "timestamp") {
+                lval = (0, time_utils_1.castTimestampToDate)(lval);
+            }
+            else {
+                rval = (0, time_utils_1.castTimestampToDate)(rval);
+            }
+            return (0, utils_1.compose)(lval, op, rval);
+        }
+    }
+    return undefined;
+}
+function regexEqual(left, right) {
+    if (left.dataType === "string") {
+        if (right.dataType === "regular expression") {
+            return [
+                {
+                    type: "dialect",
+                    function: "regexpMatch",
+                    expr: left.value,
+                    regexp: right.value[0].replace(/^r'/, "'"),
+                },
+            ];
+        }
+    }
+    else if (right.dataType === "string") {
+        if (left.dataType === "regular expression") {
+            return [
+                {
+                    type: "dialect",
+                    function: "regexpMatch",
+                    expr: right.value,
+                    regexp: left.value[0].replace(/^r'/, "'"),
+                },
+            ];
+        }
+    }
+    return undefined;
+}
+function nullCompare(left, op, right) {
+    const not = op === "!=" || op === "!~";
+    if (left.dataType === "null" || right.dataType === "null") {
+        const maybeNot = not ? " NOT" : "";
+        if (left.dataType !== "null") {
+            return [...left.value, ` IS${maybeNot} NULL`];
+        }
+        if (right.dataType !== "null") {
+            return [...right.value, `IS${maybeNot} NULL`];
+        }
+        return [not ? "false" : "true"];
+    }
+    return undefined;
+}
+function equality(fs, left, op, right) {
+    const lhs = left.getExpression(fs);
+    const rhs = right.getExpression(fs);
+    let value = timeCompare(lhs, op, rhs) || (0, utils_1.compose)(lhs.value, op, rhs.value);
+    if (lhs.dataType != "unknown" && rhs.dataType != "unknown") {
+        switch (op) {
+            case "~":
+            case "!~": {
+                if (lhs.dataType === "string" && rhs.dataType === "string") {
+                    value = (0, utils_1.compose)(lhs.value, "LIKE", rhs.value);
+                }
+                else {
+                    const regexCmp = regexEqual(lhs, rhs);
+                    if (regexCmp === undefined) {
+                        throw new TypeMismatch("Incompatible types for match('~') operator");
+                    }
+                    value = regexCmp;
+                }
+                value = (0, utils_1.nullsafeNot)(value, op);
+                break;
+            }
+            case "=":
+            case "!=": {
+                const nullCmp = nullCompare(lhs, op, rhs);
+                if (nullCmp) {
+                    value = nullCmp;
+                }
+                else {
+                    value = (0, utils_1.nullsafeNot)(regexEqual(lhs, rhs) || (0, utils_1.compose)(lhs.value, "=", rhs.value), op);
+                }
+                break;
+            }
+        }
+    }
+    return {
+        dataType: "boolean",
+        expressionType: (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType),
+        value,
+    };
+}
+function compare(fs, left, op, right) {
+    const lhs = left.getExpression(fs);
+    const rhs = right.getExpression(fs);
+    const expressionType = (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType);
+    const value = timeCompare(lhs, op, rhs) || (0, utils_1.compose)(lhs.value, op, rhs.value);
+    return {
+        dataType: "boolean",
+        expressionType,
+        value: value,
+    };
+}
+function oneOf(op, ...operators) {
+    return operators.includes(op);
+}
+function allAre(oneType, ...values) {
+    for (const v of values) {
+        if (v.dataType !== oneType) {
+            return false;
+        }
+    }
+    return true;
+}
+function numeric(fs, left, op, right) {
+    const lhs = left.getExpression(fs);
+    const rhs = right.getExpression(fs);
+    const expressionType = (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType);
+    if (allAre("number", lhs, rhs)) {
+        return {
+            dataType: "number",
+            expressionType,
+            value: (0, utils_1.compose)(lhs.value, op, rhs.value),
+        };
+    }
+    left.log(`Non numeric('${lhs.dataType},${rhs.dataType}') value with '${op}'`);
+    return (0, ast_utils_1.errorFor)("numbers required");
+}
+function delta(fs, left, op, right) {
+    const lhs = left.getExpression(fs);
+    const rhs = right.getExpression(fs);
+    if ((0, malloy_types_1.isTimeFieldType)(lhs.dataType)) {
+        let duration = right;
+        if (rhs.dataType !== "duration") {
+            if ((0, granular_result_1.isGranularResult)(lhs)) {
+                duration = new ExprDuration(right, lhs.timeframe);
+            }
+            else if (lhs.dataType === "date") {
+                duration = new ExprDuration(right, "day");
+            }
+            else {
+                left.log(`Can not offset time by '${rhs.dataType}'`);
+                return (0, ast_utils_1.errorFor)(`time plus ${rhs.dataType}`);
+            }
+        }
+        return duration.apply(fs, op, left);
+    }
+    return numeric(fs, left, op, right);
+}
+/**
+ * All of the magic of malloy expressions eventually flows to here,
+ * where an operator is applied to two values. Depending on the
+ * operator and value types this may involve transformations of
+ * the values or even the operator.
+ * @param fs FieldSpace for the symbols
+ * @param left Left value
+ * @param op The operator
+ * @param right Right Value
+ * @returns ExprValue of the expression
+ */
+function applyBinary(fs, left, op, right) {
+    if ((0, equality_1.isEquality)(op)) {
+        return equality(fs, left, op, right);
+    }
+    if ((0, comparison_1.isComparison)(op)) {
+        return compare(fs, left, op, right);
+    }
+    if (oneOf(op, "+", "-")) {
+        return delta(fs, left, op, right);
+    }
+    if (oneOf(op, "*", "%")) {
+        return numeric(fs, left, op, right);
+    }
+    if (oneOf(op, "/")) {
+        const num = left.getExpression(fs);
+        const denom = right.getExpression(fs);
+        if (num.dataType != "number") {
+            left.log("Numerator for division must be a number");
+        }
+        else if (denom.dataType != "number") {
+            right.log("Denominator for division must be a number");
+        }
+        else {
+            const div = {
+                type: "dialect",
+                function: "div",
+                numerator: num.value,
+                denominator: denom.value,
+            };
+            return {
+                dataType: "number",
+                expressionType: (0, malloy_types_1.maxExpressionType)(num.expressionType, denom.expressionType),
+                value: [div],
+            };
+        }
+        return (0, ast_utils_1.errorFor)("divide type mismatch");
+    }
+    left.log(`Canot use ${op} operator here`);
+    return (0, ast_utils_1.errorFor)("applybinary bad operator");
+}
+exports.applyBinary = applyBinary;
+//# sourceMappingURL=expression-def.js.map

package/dist/lang/ast/types/field-collection-member.d.ts

@@ -0,0 +1,5 @@
+import { FieldDeclaration } from "../query-items/field-declaration";
+import { FieldReferenceElement } from "../query-items/field-references";
+import { MalloyElement } from "./malloy-element";
+export declare type FieldCollectionMember = FieldReferenceElement | FieldDeclaration;
+export declare function isFieldCollectionMember(el: MalloyElement): el is FieldCollectionMember;

package/dist/lang/ast/types/field-collection-member.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFieldCollectionMember = void 0;
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+const field_declaration_1 = require("../query-items/field-declaration");
+const field_references_1 = require("../query-items/field-references");
+function isFieldCollectionMember(el) {
+    return (el instanceof field_references_1.FieldReference ||
+        el instanceof field_references_1.WildcardFieldReference ||
+        el instanceof field_declaration_1.FieldDeclaration);
+}
+exports.isFieldCollectionMember = isFieldCollectionMember;
+//# sourceMappingURL=field-collection-member.js.map

package/dist/lang/ast/types/field-decl.d.ts

@@ -0,0 +1,7 @@
+import { TurtleDecl } from "../query-properties/nest";
+import { Turtles } from "../source-properties/turtles";
+import { FieldDeclaration } from "../query-items/field-declaration";
+import { Join } from "../query-properties/joins";
+import { MalloyElement } from "./malloy-element";
+export declare type FieldDecl = FieldDeclaration | Join | TurtleDecl | Turtles;
+export declare function isFieldDecl(f: MalloyElement): f is FieldDecl;

package/dist/lang/ast/types/field-decl.js

@@ -0,0 +1,37 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFieldDecl = void 0;
+const nest_1 = require("../query-properties/nest");
+const turtles_1 = require("../source-properties/turtles");
+const field_declaration_1 = require("../query-items/field-declaration");
+const joins_1 = require("../query-properties/joins");
+function isFieldDecl(f) {
+    return (f instanceof field_declaration_1.FieldDeclaration ||
+        f instanceof joins_1.Join ||
+        f instanceof nest_1.TurtleDecl ||
+        f instanceof turtles_1.Turtles);
+}
+exports.isFieldDecl = isFieldDecl;
+//# sourceMappingURL=field-decl.js.map

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

@@ -0,0 +1,24 @@
+import { Dialect } from "../../../dialect/dialect";
+import { StructDef } from "../../../model/malloy_types";
+import { LookupResult } from "./lookup-result";
+import { MalloyElement } from "./malloy-element";
+/**
+ * A FieldSpace is a hierarchy of namespaces, where the leaf nodes
+ * are fields. A FieldSpace can lookup fields, and generate a StructDef
+ */
+export interface FieldSpace {
+    type: "fieldSpace";
+    structDef(): StructDef;
+    emptyStructDef(): StructDef;
+    lookup(symbol: FieldName[]): LookupResult;
+    dialectObj(): Dialect | undefined;
+    whenComplete: (step: () => void) => void;
+}
+export declare class FieldName extends MalloyElement {
+    readonly name: string;
+    elementType: string;
+    constructor(name: string);
+    get refString(): string;
+    toString(): string;
+    getField(fs: FieldSpace): LookupResult;
+}

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

@@ -0,0 +1,44 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldName = void 0;
+const malloy_element_1 = require("./malloy-element");
+class FieldName extends malloy_element_1.MalloyElement {
+    constructor(name) {
+        super();
+        this.name = name;
+        this.elementType = "fieldName";
+    }
+    get refString() {
+        return this.name;
+    }
+    toString() {
+        return this.refString;
+    }
+    getField(fs) {
+        return fs.lookup([this]);
+    }
+}
+exports.FieldName = FieldName;
+//# sourceMappingURL=field-space.js.map