@malloydata/malloy 0.0.39-dev230613161129 → 0.0.39

package/dist/lang/ast/expressions/pick-when.js

@@ -62,12 +62,14 @@ class Pick extends expression_def_1.ExpressionDef {
         const caseValue = ['CASE'];
         let returnType;
         let anyExpressionType = 'scalar';
+        let anyEvalSpace = 'constant';
         for (const choice of this.choices) {
             const whenExpr = choice.when.apply(fs, '=', expr);
             const thenExpr = choice.pick
                 ? choice.pick.getExpression(fs)
                 : expr.getExpression(fs);
             anyExpressionType = (0, malloy_types_1.maxExpressionType)(anyExpressionType, (0, malloy_types_1.maxExpressionType)(whenExpr.expressionType, thenExpr.expressionType));
+            anyEvalSpace = (0, malloy_types_1.mergeEvalSpaces)(anyEvalSpace, whenExpr.evalSpace, thenExpr.evalSpace);
             if (returnType && !fragtype_utils_1.FT.typeEq(returnType, thenExpr, true)) {
                 const whenType = fragtype_utils_1.FT.inspect(thenExpr);
                 this.log(`pick type '${whenType}', expected '${returnType.dataType}'`);
@@ -87,6 +89,7 @@ class Pick extends expression_def_1.ExpressionDef {
         return {
             dataType: returnType.dataType,
             expressionType: (0, malloy_types_1.maxExpressionType)(anyExpressionType, elseVal.expressionType),
+            evalSpace: (0, malloy_types_1.mergeEvalSpaces)(anyEvalSpace, elseVal.evalSpace),
             value: (0, utils_1.compressExpr)([...caseValue, ' ELSE ', ...elseVal.value, ' END']),
         };
     }
@@ -114,6 +117,7 @@ class Pick extends expression_def_1.ExpressionDef {
         let returnType;
         const caseValue = ['CASE'];
         let anyExpressionType = 'scalar';
+        let anyEvalSpace = 'constant';
         for (const aChoice of choiceValues) {
             if (!fragtype_utils_1.FT.typeEq(aChoice.when, fragtype_utils_1.FT.boolT)) {
                 this.log(`when expression must be boolean, not '${fragtype_utils_1.FT.inspect(aChoice.when)}`);
@@ -126,10 +130,12 @@ class Pick extends expression_def_1.ExpressionDef {
             }
             returnType = typeCoalesce(returnType, aChoice.pick);
             anyExpressionType = (0, malloy_types_1.maxExpressionType)(anyExpressionType, (0, malloy_types_1.maxExpressionType)(aChoice.pick.expressionType, aChoice.when.expressionType));
+            anyEvalSpace = (0, malloy_types_1.mergeEvalSpaces)(anyEvalSpace, aChoice.pick.evalSpace, aChoice.when.evalSpace);
             caseValue.push(' WHEN ', ...aChoice.when.value, ' THEN ', ...aChoice.pick.value);
         }
         const defVal = this.elsePick.getExpression(fs);
         anyExpressionType = (0, malloy_types_1.maxExpressionType)(anyExpressionType, defVal.expressionType);
+        anyEvalSpace = (0, malloy_types_1.mergeEvalSpaces)(anyEvalSpace, defVal.evalSpace);
         returnType = typeCoalesce(returnType, defVal);
         if (!fragtype_utils_1.FT.typeEq(returnType, defVal, true)) {
             this.elsePick.log(`else type '${fragtype_utils_1.FT.inspect(defVal)}', expected '${returnType.dataType}'`);
@@ -140,6 +146,7 @@ class Pick extends expression_def_1.ExpressionDef {
             dataType: returnType.dataType,
             expressionType: anyExpressionType,
             value: (0, utils_1.compressExpr)(caseValue),
+            evalSpace: anyEvalSpace,
         };
     }
 }

package/dist/lang/ast/expressions/range.js

@@ -46,6 +46,7 @@ class Range extends expression_def_1.ExpressionDef {
                 return {
                     dataType: 'boolean',
                     expressionType: (0, malloy_types_1.maxExpressionType)(fromValue.expressionType, toValue.expressionType),
+                    evalSpace: (0, malloy_types_1.mergeEvalSpaces)(fromValue.evalSpace, toValue.evalSpace),
                     value: (0, utils_1.compose)(fromValue.value, op2, toValue.value),
                 };
             }

package/dist/lang/ast/expressions/time-literal.js

@@ -85,9 +85,15 @@ class TimeLiteral extends expression_def_1.ExpressionDef {
         const expressionType = 'scalar';
         const value = [timeFrag];
         if (this.units) {
-            return { dataType, expressionType, value, timeframe: this.units };
+            return {
+                dataType,
+                expressionType,
+                value,
+                timeframe: this.units,
+                evalSpace: 'literal',
+            };
         }
-        return { dataType, expressionType, value };
+        return { dataType, expressionType, value, evalSpace: 'literal' };
     }
     getExpression(_fs) {
         return this.makeValue(this.literalPart, this.timeType);
@@ -211,7 +217,7 @@ class DateBasedLiteral extends GranularLiteral {
         const timestamp = [
             this.makeLiteral(`${this.literalPart} 00:00:00`, 'timestamp'),
         ];
-        return { ...dateValue, morphic: { timestamp } };
+        return { ...dateValue, morphic: { timestamp }, evalSpace: 'literal' };
     }
     getNext() {
         const dateValue = this.makeValue(this.nextLit, 'date');

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

@@ -1,6 +1,5 @@
-import { FieldDef, FieldTypeDef } from '../../../model/malloy_types';
+import { FieldDef, FieldTypeDef, TypeDesc } from '../../../model/malloy_types';
 import { SpaceField } from '../types/space-field';
-import { TypeDesc } from '../types/type-desc';
 export declare class ColumnSpaceField extends SpaceField {
     protected def: FieldTypeDef;
     constructor(def: FieldTypeDef);

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

@@ -112,7 +112,7 @@ class DynamicSpace extends static_space_1.StaticSpace {
                 }
             }
             const reorderFields = [...fields, ...joins, ...turtles];
-            for (const [fieldName, field] of reorderFields) {
+            for (const [, field] of reorderFields) {
                 if (field instanceof join_space_field_1.JoinSpaceField) {
                     const joinStruct = field.join.structDef();
                     if (!error_factory_1.ErrorFactory.isErrorStructDef(joinStruct)) {
@@ -125,9 +125,11 @@ class DynamicSpace extends static_space_1.StaticSpace {
                     if (fieldDef) {
                         this.final.fields.push(fieldDef);
                     }
-                    else {
-                        throw new Error(`'${fieldName}' doesn't have a FieldDef`);
-                    }
+                    // TODO I'm just removing this, but perhaps instead I should just filter
+                    // out ReferenceFields and still make this check.
+                    // else {
+                    //   throw new Error(`'${fieldName}' doesn't have a FieldDef`);
+                    // }
                 }
             }
             if (Object.entries(parameters).length > 0) {

package/dist/lang/ast/field-space/field-definition-value.d.ts

@@ -2,7 +2,7 @@ import * as model from '../../../model/malloy_types';
 import { FieldDeclaration } from '../query-items/field-declaration';
 import { FieldSpace } from '../types/field-space';
 import { SpaceField } from '../types/space-field';
-import { TypeDesc } from '../types/type-desc';
+import { TypeDesc } from '../../../model/malloy_types';
 export declare class FieldDefinitionValue extends SpaceField {
     readonly space: FieldSpace;
     readonly exprDef: FieldDeclaration;

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

@@ -1,6 +1,6 @@
-import { QueryFieldDef } from '../../../model/malloy_types';
+import { TypeDesc } from '../../../model/malloy_types';
 import { QuerySpace } from './query-spaces';
 export declare class ProjectFieldSpace extends QuerySpace {
     readonly segmentType = "project";
-    canContain(qd: QueryFieldDef): boolean;
+    canContain(typeDesc: TypeDesc): boolean;
 }

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

@@ -30,19 +30,18 @@ class ProjectFieldSpace extends query_spaces_1.QuerySpace {
         super(...arguments);
         this.segmentType = 'project';
     }
-    canContain(qd) {
-        if (typeof qd !== 'string') {
-            if ((0, malloy_types_1.isFilteredAliasedName)(qd)) {
-                return true;
-            }
-            if (qd.type === 'turtle') {
-                this.log('Cannot nest queries in project');
-                return false;
-            }
-            if ((0, malloy_types_1.expressionIsAggregate)(qd.expressionType)) {
-                this.log('Cannot add aggregate measures to project');
-                return false;
-            }
+    canContain(typeDesc) {
+        if (typeDesc.dataType === 'turtle' ||
+            (0, malloy_types_1.expressionIsAggregate)(typeDesc.expressionType)) {
+            // We don't need to log here, because an error should have already been logged.
+            return false;
+        }
+        // TODO it would be really nice to attach this error message to the specific field,
+        // rather than the whole query.
+        if ((0, malloy_types_1.expressionInvolvesAggregate)(typeDesc.expressionType) &&
+            (0, malloy_types_1.expressionIsAnalytic)(typeDesc.expressionType)) {
+            this.log('Cannot add aggregate analyics to project');
+            return false;
         }
         return true;
     }

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

@@ -1,7 +1,6 @@
-import { FieldDef, QueryFieldDef } from '../../../model/malloy_types';
+import { FieldDef, QueryFieldDef, TypeDesc } from '../../../model/malloy_types';
 import { FieldSpace } from '../types/field-space';
 import { SpaceField } from '../types/space-field';
-import { TypeDesc } from '../types/type-desc';
 export declare abstract class QueryField extends SpaceField {
     protected inSpace: FieldSpace;
     constructor(inSpace: FieldSpace);

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

@@ -30,7 +30,7 @@ class QueryField extends space_field_1.SpaceField {
         this.inSpace = inSpace;
     }
     typeDesc() {
-        return { dataType: 'turtle', expressionType: 'scalar' };
+        return { dataType: 'turtle', expressionType: 'scalar', evalSpace: 'input' };
     }
 }
 exports.QueryField = QueryField;

package/dist/lang/ast/field-space/query-spaces.d.ts

@@ -8,6 +8,8 @@ import { FieldReference, WildcardFieldReference } from '../query-items/field-ref
 import { FieldCollectionMember } from '../types/field-collection-member';
 import { QueryItem } from '../types/query-item';
 import { RefinedSpace } from './refined-space';
+import { LookupResult } from '../types/lookup-result';
+import { SpaceEntry } from '../types/space-entry';
 /**
  * Unlike a source, which is a refinement of a namespace, a query
  * is creating a new unrelated namespace. The query starts with a
@@ -21,13 +23,16 @@ export declare class QueryInputSpace extends RefinedSpace {
     extendList: string[];
     constructor(input: SourceSpec, result: QuerySpace);
     extendSource(extendField: Join | FieldDeclaration): void;
+    isQueryFieldSpace(): boolean;
+    outputSpace(): QuerySpace;
 }
 export declare abstract class QuerySpace extends RefinedSpace {
     readonly queryInputSpace: FieldSpace;
     readonly exprSpace: QueryInputSpace;
     astEl?: MalloyElement | undefined;
     abstract readonly segmentType: 'reduce' | 'project' | 'index';
-    constructor(queryInputSpace: FieldSpace);
+    constructor(queryInputSpace: FieldSpace, refineThis: model.PipeSegment | undefined);
+    private addRefineFromFields;
     log(s: string): void;
     addMembers(members: FieldCollectionMember[]): void;
     addReference(ref: FieldReference): void;
@@ -40,11 +45,20 @@ export declare abstract class QuerySpace extends RefinedSpace {
      */
     checkUngroup(fn: FieldName, isExclude: boolean): void;
     addQueryItems(...qiList: QueryItem[]): void;
-    canContain(_qd: model.QueryFieldDef): boolean;
+    canContain(_typeDesc: model.TypeDesc): boolean;
     protected queryFieldDefs(): model.QueryFieldDef[];
     getQuerySegment(rf: model.QuerySegment | undefined): model.QuerySegment;
     getPipeSegment(refineFrom: model.QuerySegment | undefined): model.PipeSegment;
+    lookup(path: FieldName[]): LookupResult;
+    isQueryFieldSpace(): boolean;
+    outputSpace(): this;
 }
 export declare class ReduceFieldSpace extends QuerySpace {
     readonly segmentType = "reduce";
 }
+export declare class OutputSpaceEntry extends SpaceEntry {
+    readonly inputSpaceEntry: SpaceEntry;
+    refType: 'field' | 'parameter';
+    constructor(inputSpaceEntry: SpaceEntry);
+    typeDesc(): model.TypeDesc;
+}

package/dist/lang/ast/field-space/query-spaces.js

@@ -45,7 +45,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReduceFieldSpace = exports.QuerySpace = exports.QueryInputSpace = void 0;
+exports.OutputSpaceEntry = exports.ReduceFieldSpace = exports.QuerySpace = exports.QueryInputSpace = void 0;
 const model = __importStar(require("../../../model/malloy_types"));
 const field_utils_1 = require("../../field-utils");
 const field_declaration_1 = require("../query-items/field-declaration");
@@ -58,6 +58,9 @@ const field_references_1 = require("../query-items/field-references");
 const reference_field_1 = require("./reference-field");
 const wild_space_field_1 = require("./wild-space-field");
 const refined_space_1 = require("./refined-space");
+const space_entry_1 = require("../types/space-entry");
+const column_space_field_1 = require("./column-space-field");
+const static_space_1 = require("./static-space");
 /**
  * Unlike a source, which is a refinement of a namespace, a query
  * is creating a new unrelated namespace. The query starts with a
@@ -81,13 +84,47 @@ class QueryInputSpace extends refined_space_1.RefinedSpace {
             this.extendList.push(extendField.defineName);
         }
     }
+    isQueryFieldSpace() {
+        return true;
+    }
+    outputSpace() {
+        return this.result;
+    }
 }
 exports.QueryInputSpace = QueryInputSpace;
+// TODO maybe rename QueryOutputSpace
 class QuerySpace extends refined_space_1.RefinedSpace {
-    constructor(queryInputSpace) {
+    constructor(queryInputSpace, refineThis) {
         super(queryInputSpace.emptyStructDef());
         this.queryInputSpace = queryInputSpace;
         this.exprSpace = new QueryInputSpace(queryInputSpace, this);
+        if (refineThis)
+            this.addRefineFromFields(refineThis);
+    }
+    addRefineFromFields(refineThis) {
+        var _a, _b;
+        for (const field of refineThis.fields) {
+            if (typeof field === 'string') {
+                const ent = this.exprSpace.entry(field);
+                if (ent) {
+                    this.setEntry(field, ent);
+                }
+            }
+            else if (model.isFilteredAliasedName(field)) {
+                const name = (_a = field.as) !== null && _a !== void 0 ? _a : field.name;
+                const ent = this.exprSpace.entry(name);
+                if (ent) {
+                    this.setEntry(name, ent);
+                }
+            }
+            else {
+                // TODO can you reference fields in a turtle as fields in the output space,
+                // e.g. order_by: my_turtle.foo, or lag(my_turtle.foo)
+                if (field.type !== 'turtle') {
+                    this.setEntry((_b = field.as) !== null && _b !== void 0 ? _b : field.name, new column_space_field_1.ColumnSpaceField(field));
+                }
+            }
+        }
     }
     log(s) {
         if (this.astEl) {
@@ -117,7 +154,90 @@ class QuerySpace extends refined_space_1.RefinedSpace {
         }
     }
     addWild(wild) {
-        this.setEntry(wild.refString, new wild_space_field_1.WildSpaceField(wild.refString));
+        let success = true;
+        let current = this.exprSpace;
+        const parts = wild.refString.split('.');
+        const conflictMap = {};
+        function logConflict(name, parentRef) {
+            const conflict = conflictMap[name];
+            wild.log(`Cannot expand '${name}'${parentRef ? ` in ${parentRef}` : ''} because a field with that name already exists${conflict ? ` (conflicts with ${conflict})` : ''}`);
+            success = false;
+        }
+        for (let pi = 0; pi < parts.length; pi++) {
+            const part = parts[pi];
+            const prevParts = parts.slice(0, pi);
+            const parentRef = pi > 0 ? prevParts.join('.') : undefined;
+            const fullName = [...prevParts.join('.'), part].join('.');
+            if (part === '*') {
+                for (const [name, entry] of current.entries()) {
+                    if (this.entry(name)) {
+                        logConflict(name, parentRef);
+                        success = false;
+                    }
+                    if (model.expressionIsScalar(entry.typeDesc().expressionType)) {
+                        this.setEntry(name, entry);
+                        conflictMap[name] = fullName;
+                    }
+                }
+            }
+            else if (part === '**') {
+                // TODO actually handle **
+                wild.log('** is currently broken');
+                success = false;
+                // const spaces: {space: FieldSpace; ref: string | undefined}[] = [
+                //   {space: current, ref: undefined},
+                // ];
+                // let toExpand: {space: FieldSpace; ref: string | undefined} | undefined;
+                // while ((toExpand = spaces.pop())) {
+                //   for (const [name, entry] of toExpand.space.entries()) {
+                //     if (this.entry(name)) {
+                //       logConflict(name, toExpand.ref);
+                //       success = false;
+                //     }
+                //     if (model.expressionIsScalar(entry.typeDesc().expressionType)) {
+                //       this.setEntry(name, entry);
+                //       conflictMap[name] = toExpand.ref
+                //         ? `${toExpand.ref}.${name}`
+                //         : name;
+                //     }
+                //     if (entry instanceof StructSpaceField) {
+                //       spaces.push({
+                //         space: entry.fieldSpace,
+                //         ref: [
+                //           ...(parentRef ? [parentRef] : []),
+                //           ...(toExpand.ref ? [toExpand.ref] : []),
+                //           name,
+                //         ].join('.'),
+                //       });
+                //     }
+                //   }
+                // }
+            }
+            else {
+                const ent = current.entry(part);
+                if (ent) {
+                    if (ent instanceof static_space_1.StructSpaceField) {
+                        current = ent.fieldSpace;
+                    }
+                    else {
+                        wild.log(`Field '${part}'${parentRef ? ` in ${parentRef}` : ''} is not a struct`);
+                        success = false;
+                    }
+                }
+                else {
+                    wild.log(`No such field '${part}'${parentRef ? ` in ${parentRef}` : ''}`);
+                    success = false;
+                }
+            }
+        }
+        if (success) {
+            // TODO perform the entire replacement of * and ** here in the parser.
+            // Today, we add all the fields to the output space, and then still add * to
+            // the query. The compiler then does a second * expansion. Instead, we should
+            // just add all the fields to the query here and then remove the code in the compiler
+            // for expanding the *.
+            this.setEntry(wild.refString, new wild_space_field_1.WildSpaceField(wild.refString));
+        }
     }
     /**
      * Check for the definition of an ungrouping reference in the result space,
@@ -158,25 +278,39 @@ class QuerySpace extends refined_space_1.RefinedSpace {
             }
         }
     }
-    canContain(_qd) {
+    canContain(_typeDesc) {
         return true;
     }
     queryFieldDefs() {
         const fields = [];
-        for (const [name, field] of this.entries()) {
+        for (const [, field] of this.entries()) {
             if (field instanceof space_field_1.SpaceField) {
                 const fieldQueryDef = field.getQueryFieldDef(this.exprSpace);
                 if (fieldQueryDef) {
-                    if (this.canContain(fieldQueryDef)) {
+                    if (field instanceof wild_space_field_1.WildSpaceField) {
                         fields.push(fieldQueryDef);
                     }
                     else {
-                        this.log(`'${name}' not legal in ${this.segmentType}`);
+                        const typeDesc = field.typeDesc();
+                        // Filter out fields whose type is unknown, which means that a totally bad field
+                        // isn't sent to the compiler, where it will wig out. The downside is that in
+                        // subsequent stages of a query, the field is not in the input struct. But since
+                        // the error message says "Cannot define x which has unknown type", it makes sense
+                        // that it wouldn't be "defined" in later stages.
+                        // TODO Figure out how to make errors generated by `canContain` go in the right place,
+                        // maybe by adding a logable element to SpaceFields.
+                        if (typeDesc.dataType !== 'unknown' && this.canContain(typeDesc)) {
+                            fields.push(fieldQueryDef);
+                        }
                     }
                 }
-                else {
-                    throw new Error(`'${name}' does not have a QueryFieldDef`);
-                }
+                // TODO I removed the error here because during calculation of the refinement space,
+                // (see creation of a QuerySpace) we add references to all the fields from
+                // the refinement, but they don't have definitions. So in the case where we
+                // don't have a field def, we "know" that that field is already in the query,
+                // and we don't need to worry about actually adding it. This is also true for
+                // project statements, where we add "*" as a field and also all the individuala
+                // fields, but the individual fields don't have field defs.
             }
         }
         this.isComplete();
@@ -224,6 +358,22 @@ class QuerySpace extends refined_space_1.RefinedSpace {
         this.isComplete();
         return segment;
     }
+    lookup(path) {
+        const result = super.lookup(path);
+        if (result.found) {
+            return {
+                error: undefined,
+                found: new OutputSpaceEntry(result.found),
+            };
+        }
+        return this.exprSpace.lookup(path);
+    }
+    isQueryFieldSpace() {
+        return true;
+    }
+    outputSpace() {
+        return this;
+    }
 }
 exports.QuerySpace = QuerySpace;
 class ReduceFieldSpace extends QuerySpace {
@@ -233,4 +383,19 @@ class ReduceFieldSpace extends QuerySpace {
     }
 }
 exports.ReduceFieldSpace = ReduceFieldSpace;
+class OutputSpaceEntry extends space_entry_1.SpaceEntry {
+    constructor(inputSpaceEntry) {
+        super();
+        this.inputSpaceEntry = inputSpaceEntry;
+        this.refType = inputSpaceEntry.refType;
+    }
+    typeDesc() {
+        const type = this.inputSpaceEntry.typeDesc();
+        return {
+            ...type,
+            evalSpace: type.evalSpace === 'constant' ? 'constant' : 'output',
+        };
+    }
+}
+exports.OutputSpaceEntry = OutputSpaceEntry;
 //# sourceMappingURL=query-spaces.js.map

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

@@ -1,10 +1,11 @@
-import { QueryFieldDef } from '../../../model/malloy_types';
+import { QueryFieldDef, TypeDesc } from '../../../model/malloy_types';
 import { FieldReference } from '../query-items/field-references';
 import { FieldSpace } from '../types/field-space';
+import { LookupResult } from '../types/lookup-result';
 import { SpaceField } from '../types/space-field';
-import { TypeDesc } from '../types/type-desc';
 export declare class ReferenceField extends SpaceField {
     readonly fieldRef: FieldReference;
+    res: LookupResult | undefined;
     constructor(fieldRef: FieldReference);
     getQueryFieldDef(fs: FieldSpace): QueryFieldDef | undefined;
     typeDesc(): TypeDesc;

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

@@ -28,6 +28,7 @@ class ReferenceField extends space_field_1.SpaceField {
     constructor(fieldRef) {
         super();
         this.fieldRef = fieldRef;
+        this.res = undefined;
     }
     getQueryFieldDef(fs) {
         // Lookup string and generate error if it isn't defined.
@@ -35,10 +36,16 @@ class ReferenceField extends space_field_1.SpaceField {
         if (check.error) {
             this.fieldRef.log(check.error);
         }
+        this.res = check;
         return this.fieldRef.refString;
     }
     typeDesc() {
-        return { dataType: 'unknown', expressionType: 'scalar' };
+        // Remember the actual type of the field that was looked up so it can be used for
+        // type checking.
+        if (this.res !== undefined && this.res.found) {
+            return this.res.found.typeDesc();
+        }
+        return { dataType: 'unknown', expressionType: 'scalar', evalSpace: 'input' };
     }
 }
 exports.ReferenceField = ReferenceField;

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

@@ -1,6 +1,5 @@
-import { DocumentLocation, FieldDef } from '../../../model/malloy_types';
+import { DocumentLocation, FieldDef, TypeDesc } from '../../../model/malloy_types';
 import { SpaceField } from '../types/space-field';
-import { TypeDesc } from '../types/type-desc';
 export declare class RenameSpaceField extends SpaceField {
     private readonly otherField;
     private readonly newName;

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

@@ -2,7 +2,7 @@ import { Dialect } from '../../../dialect/dialect';
 import { FieldDef, StructDef } from '../../../model/malloy_types';
 import { SpaceEntry } from '../types/space-entry';
 import { LookupResult } from '../types/lookup-result';
-import { FieldName, FieldSpace } from '../types/field-space';
+import { FieldName, FieldSpace, QueryFieldSpace } from '../types/field-space';
 import { SpaceField } from '../types/space-field';
 import { StructSpaceFieldBase } from './struct-space-field-base';
 export declare class StaticSpace implements FieldSpace {
@@ -16,12 +16,13 @@ export declare class StaticSpace implements FieldSpace {
     private get map();
     protected dropEntries(): void;
     protected dropEntry(name: string): void;
-    protected entry(name: string): SpaceEntry | undefined;
+    entry(name: string): SpaceEntry | undefined;
     protected setEntry(name: string, value: SpaceEntry): void;
-    protected entries(): [string, SpaceEntry][];
+    entries(): [string, SpaceEntry][];
     structDef(): StructDef;
     emptyStructDef(): StructDef;
     lookup(path: FieldName[]): LookupResult;
+    isQueryFieldSpace(): this is QueryFieldSpace;
 }
 export declare class StructSpaceField extends StructSpaceFieldBase {
     constructor(def: StructDef);

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

@@ -80,6 +80,7 @@ class StaticSpace {
     dropEntry(name) {
         delete this.map[name];
     }
+    // TODO this was protected
     entry(name) {
         return this.map[name];
     }
@@ -142,6 +143,9 @@ class StaticSpace {
         }
         return { found, error: undefined };
     }
+    isQueryFieldSpace() {
+        return false;
+    }
 }
 exports.StaticSpace = StaticSpace;
 class StructSpaceField extends struct_space_field_base_1.StructSpaceFieldBase {

package/dist/lang/ast/field-space/struct-space-field-base.d.ts

@@ -1,7 +1,6 @@
-import { FieldDef, StructDef } from '../../../model/malloy_types';
+import { FieldDef, StructDef, TypeDesc } from '../../../model/malloy_types';
 import { FieldSpace } from '../types/field-space';
 import { SpaceField } from '../types/space-field';
-import { TypeDesc } from '../types/type-desc';
 export declare abstract class StructSpaceFieldBase extends SpaceField {
     protected sourceDef: StructDef;
     constructor(sourceDef: StructDef);

package/dist/lang/ast/field-space/struct-space-field-base.js

@@ -33,7 +33,7 @@ class StructSpaceFieldBase extends space_field_1.SpaceField {
         return this.sourceDef;
     }
     typeDesc() {
-        return { dataType: 'struct', expressionType: 'scalar' };
+        return { dataType: 'struct', expressionType: 'scalar', evalSpace: 'input' };
     }
 }
 exports.StructSpaceFieldBase = StructSpaceFieldBase;

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

@@ -1,7 +1,6 @@
-import { QueryFieldDef } from '../../../model/malloy_types';
+import { QueryFieldDef, TypeDesc } from '../../../model/malloy_types';
 import { FieldSpace } from '../types/field-space';
 import { SpaceField } from '../types/space-field';
-import { TypeDesc } from '../types/type-desc';
 export declare class WildSpaceField extends SpaceField {
     readonly wildText: string;
     constructor(wildText: string);

package/dist/lang/ast/fragtype-utils.d.ts

@@ -1,4 +1,4 @@
-import { TypeDesc } from './types/type-desc';
+import { TypeDesc } from '../../model';
 /**
  * Collects functions which operate on fragtype compatible objects
  */

package/dist/lang/ast/fragtype-utils.js

@@ -23,8 +23,9 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FT = void 0;
-function mkFragType(dataType, expressionType = 'scalar') {
-    return { dataType, expressionType };
+const model_1 = require("../../model");
+function mkFragType(dataType, expressionType = 'scalar', evalSpace = 'constant') {
+    return { dataType, expressionType, evalSpace };
 }
 /**
  * Collects functions which operate on fragtype compatible objects
@@ -73,7 +74,7 @@ class FT {
         const strings = types.map(type => {
             if (type) {
                 let inspected = type.dataType;
-                if (type.expressionType !== 'scalar') {
+                if (!(0, model_1.expressionIsScalar)(type.expressionType)) {
                     inspected = `${type.expressionType} ${inspected}`;
                 }
                 return inspected;