@malloydata/malloy 0.0.215 → 0.0.216-dev241118202522

package/dist/dialect/functions/util.d.ts

@@ -17,9 +17,9 @@ export interface DialectFunctionOverloadDef {
 export declare function arg(name: string): Expr;
 export declare function spread(e: Expr, prefix?: string | undefined, suffix?: string | undefined): Expr;
 export declare function sql(strings: TemplateStringsArray, ...subExprs: SQLExprElement[]): Expr;
-export declare function constant(type: TypeDesc): TypeDesc;
-export declare function output(type: TypeDesc): TypeDesc;
-export declare function literal(type: TypeDesc): TypeDesc;
+export declare function constant(type: FunctionParamTypeDesc): FunctionParamTypeDesc;
+export declare function output(type: FunctionParamTypeDesc): FunctionParamTypeDesc;
+export declare function literal(type: FunctionParamTypeDesc): FunctionParamTypeDesc;
 export declare function variadicParam(name: string, ...allowedTypes: FunctionParamTypeDesc[]): FunctionParameterDef;
 /**
  * Prefer `makeParam` for future function definitions
@@ -29,14 +29,14 @@ export declare function makeParam(name: string, ...allowedTypes: FunctionParamTy
     param: FunctionParameterDef;
     arg: Expr;
 };
-export declare function maxScalar(type: LeafExpressionType): TypeDesc;
-export declare function maxAggregate(type: LeafExpressionType): TypeDesc;
+export declare function maxScalar(type: LeafExpressionType): FunctionParamTypeDesc;
+export declare function maxAggregate(type: LeafExpressionType): FunctionParamTypeDesc;
 export declare function anyExprType(type: LeafExpressionType): FunctionParamTypeDesc;
 export declare function maxUngroupedAggregate(type: LeafExpressionType): FunctionParamTypeDesc;
 export declare function maxAnalytic(type: LeafExpressionType): FunctionParamTypeDesc;
-export declare function minScalar(type: LeafExpressionType): TypeDesc;
-export declare function minAggregate(type: LeafExpressionType): TypeDesc;
-export declare function minAnalytic(type: LeafExpressionType): TypeDesc;
+export declare function minScalar(type: LeafExpressionType): FunctionParamTypeDesc;
+export declare function minAggregate(type: LeafExpressionType): FunctionParamTypeDesc;
+export declare function minAnalytic(type: LeafExpressionType): FunctionParamTypeDesc;
 export declare function overload(returnType: TypeDesc, params: FunctionParameterDef[], e: Expr, options?: {
     needsWindowOrderBy?: boolean;
     between?: {

package/dist/dialect/functions/util.js

@@ -23,6 +23,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.expandOverrideMapFromBase = exports.expandBlueprintMap = exports.overload = exports.minAnalytic = exports.minAggregate = exports.minScalar = exports.maxAnalytic = exports.maxUngroupedAggregate = exports.anyExprType = exports.maxAggregate = exports.maxScalar = exports.makeParam = exports.param = exports.variadicParam = exports.literal = exports.output = exports.constant = exports.sql = exports.spread = exports.arg = void 0;
+const composite_source_utils_1 = require("../../model/composite_source_utils");
 function arg(name) {
     return { node: 'function_parameter', name };
 }
@@ -159,27 +160,34 @@ function removeGeneric(type, generic) {
     return generic.type;
 }
 function expandReturnTypeBlueprint(blueprint, generic) {
+    var _a;
+    let base;
     if (typeof blueprint === 'string') {
-        return minScalar(blueprint);
+        base = minScalar(blueprint);
     }
     else if ('generic' in blueprint) {
-        return minScalar(removeGeneric(blueprint, generic));
+        base = minScalar(removeGeneric(blueprint, generic));
     }
     else if ('literal' in blueprint) {
-        return literal(minScalar(removeGeneric(blueprint.literal, generic)));
+        base = literal(minScalar(removeGeneric(blueprint.literal, generic)));
     }
     else if ('constant' in blueprint) {
-        return constant(minScalar(removeGeneric(blueprint.constant, generic)));
+        base = constant(minScalar(removeGeneric(blueprint.constant, generic)));
     }
     else if ('dimension' in blueprint) {
-        return minScalar(removeGeneric(blueprint.dimension, generic));
+        base = minScalar(removeGeneric(blueprint.dimension, generic));
     }
     else if ('measure' in blueprint) {
-        return minAggregate(removeGeneric(blueprint.measure, generic));
+        base = minAggregate(removeGeneric(blueprint.measure, generic));
     }
     else {
-        return minAnalytic(removeGeneric(blueprint.calculation, generic));
+        base = minAnalytic(removeGeneric(blueprint.calculation, generic));
     }
+    return {
+        ...base,
+        compositeFieldUsage: (0, composite_source_utils_1.emptyCompositeFieldUsage)(),
+        expressionType: (_a = base.expressionType) !== null && _a !== void 0 ? _a : 'scalar',
+    };
 }
 function isTypeDescBlueprint(blueprint) {
     return (typeof blueprint === 'string' ||

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

@@ -23,6 +23,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.errorFor = void 0;
+const composite_source_utils_1 = require("../../model/composite_source_utils");
 /**
  * When a translation hits an error, log and return one of these as a value.
  * This will allow the rest of the translation walk to complete. The
@@ -37,6 +38,7 @@ function errorFor(reason) {
         expressionType: 'scalar',
         value: { node: 'error', message: reason },
         evalSpace: 'constant',
+        compositeFieldUsage: (0, composite_source_utils_1.emptyCompositeFieldUsage)(),
     };
 }
 exports.errorFor = errorFor;

package/dist/lang/ast/expressions/expr-aggregate-function.js

@@ -92,6 +92,7 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
                                 ? { node: 'outputField', name: this.source.refString }
                                 : { node: 'field', path: this.source.path },
                             evalSpace: footType.evalSpace,
+                            compositeFieldUsage: footType.compositeFieldUsage,
                         };
                         structPath = this.source.path;
                         // Here we handle a special case where you write `foo.agg()` and `foo` is a

package/dist/lang/ast/expressions/expr-compare.js

@@ -46,8 +46,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprLegacyIn = exports.ExprEquality = exports.ExprCompare = void 0;
-const model_1 = require("../../../model");
 const TDU = __importStar(require("../typedesc-utils"));
+const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 const binary_boolean_1 = require("./binary-boolean");
 const compareTypes = {
@@ -101,23 +101,16 @@ class ExprLegacyIn extends expression_def_1.ExpressionDef {
     }
     getExpression(fs) {
         const lookFor = this.expr.getExpression(fs);
-        let { evalSpace, expressionType } = lookFor;
-        const oneOf = this.choices.map(e => {
-            const choice = e.getExpression(fs);
-            expressionType = (0, model_1.maxExpressionType)(expressionType, choice.expressionType);
-            evalSpace = (0, model_1.mergeEvalSpaces)(evalSpace, choice.evalSpace);
-            return choice.value;
-        });
-        return {
-            type: 'boolean',
-            expressionType,
-            evalSpace,
+        const oneOf = this.choices.map(e => e.getExpression(fs));
+        return (0, expr_value_1.computedExprValue)({
+            dataType: { type: 'boolean' },
             value: {
                 node: 'in',
                 not: this.notIn,
-                kids: { e: lookFor.value, oneOf },
+                kids: { e: lookFor.value, oneOf: oneOf.map(v => v.value) },
             },
-        };
+            from: [lookFor, ...oneOf],
+        });
     }
 }
 exports.ExprLegacyIn = ExprLegacyIn;

package/dist/lang/ast/expressions/expr-count-distinct.js

@@ -60,6 +60,7 @@ class ExprCountDistinct extends expr_aggregate_function_1.ExprAggregateFunction
             evalSpace: ev.evalSpace,
             expressionType: 'aggregate',
             value: ev.value,
+            compositeFieldUsage: ev.compositeFieldUsage,
         };
     }
 }

package/dist/lang/ast/expressions/expr-count.js

@@ -23,6 +23,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprCount = void 0;
+const composite_source_utils_1 = require("../../../model/composite_source_utils");
 const expr_aggregate_function_1 = require("./expr-aggregate-function");
 class ExprCount extends expr_aggregate_function_1.ExprAggregateFunction {
     constructor(source) {
@@ -44,6 +45,7 @@ class ExprCount extends expr_aggregate_function_1.ExprAggregateFunction {
             evalSpace: ev.evalSpace,
             expressionType: 'aggregate',
             value: ev.value,
+            compositeFieldUsage: ev.compositeFieldUsage,
         };
     }
     getExpression(_fs) {
@@ -61,6 +63,7 @@ class ExprCount extends expr_aggregate_function_1.ExprAggregateFunction {
             expressionType: 'aggregate',
             value: ret,
             evalSpace: 'output',
+            compositeFieldUsage: (0, composite_source_utils_1.emptyCompositeFieldUsage)(),
         };
     }
 }

package/dist/lang/ast/expressions/expr-func.js

@@ -54,6 +54,7 @@ const expression_def_1 = require("../types/expression-def");
 const field_space_1 = require("../types/field-space");
 const utils_1 = require("../../../model/utils");
 const TDU = __importStar(require("../typedesc-utils"));
+const composite_source_utils_1 = require("../../../model/composite_source_utils");
 class ExprFunc extends expression_def_1.ExpressionDef {
     constructor(name, args, isRaw, rawType, source) {
         super({ args: args });
@@ -141,6 +142,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
                         expressionType: footType.expressionType,
                         value: { node: 'field', path: this.source.path },
                         evalSpace: footType.evalSpace,
+                        compositeFieldUsage: footType.compositeFieldUsage,
                     };
                     structPath = this.source.path.slice(0, -1);
                 }
@@ -335,6 +337,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
             expressionType,
             value: funcCall,
             evalSpace,
+            compositeFieldUsage: (0, composite_source_utils_1.mergeCompositeFieldUsage)(...argExprs.map(e => e.compositeFieldUsage)),
         };
     }
 }

package/dist/lang/ast/expressions/expr-id-reference.js

@@ -25,6 +25,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprIdReference = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
 const expression_def_1 = require("../types/expression-def");
+const composite_source_utils_1 = require("../../../model/composite_source_utils");
 class ExprIdReference extends expression_def_1.ExpressionDef {
     constructor(fieldReference) {
         super();
@@ -37,14 +38,22 @@ class ExprIdReference extends expression_def_1.ExpressionDef {
     }
     getExpression(fs) {
         const def = this.fieldReference.getField(fs);
+        // TODO Currently the join usage is always equivalent to the reference path here;
+        // if/when we add namespaces, this will not be the case, and we will need to get the
+        // join path from `getField` / `lookup`
+        const compositeJoinUsage = this.fieldReference.list
+            .map(n => n.name)
+            .slice(0, -1);
         if (def.found) {
             const td = def.found.typeDesc();
+            const compositeFieldUsage = (0, composite_source_utils_1.joinedCompositeFieldUsage)(compositeJoinUsage, td.compositeFieldUsage);
             if (def.isOutputField) {
                 return {
                     ...td,
                     // TODO what about literal??
                     evalSpace: td.evalSpace === 'constant' ? 'constant' : 'output',
                     value: { node: 'outputField', name: this.refString },
+                    compositeFieldUsage,
                 };
             }
             const value = { node: def.found.refType, path: this.fieldReference.path };
@@ -52,7 +61,7 @@ class ExprIdReference extends expression_def_1.ExpressionDef {
             const evalSpace = (0, malloy_types_1.expressionIsAggregate)(td.expressionType)
                 ? 'output'
                 : td.evalSpace;
-            return { ...td, value, evalSpace };
+            return { ...td, value, evalSpace, compositeFieldUsage };
         }
         return this.loggedErrorExpr(def.error.code, def.error.message);
     }

package/dist/lang/ast/expressions/expr-now.js

@@ -24,6 +24,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprNow = void 0;
 const expression_def_1 = require("../types/expression-def");
+const composite_source_utils_1 = require("../../../model/composite_source_utils");
 class ExprNow extends expression_def_1.ExpressionDef {
     constructor() {
         super(...arguments);
@@ -36,6 +37,7 @@ class ExprNow extends expression_def_1.ExpressionDef {
             // `now` is considered to be a constant, at least in the dialects we support today
             evalSpace: 'constant',
             value: { node: 'now' },
+            compositeFieldUsage: (0, composite_source_utils_1.emptyCompositeFieldUsage)(),
         };
     }
 }

package/dist/lang/ast/expressions/expr-ungroup.js

@@ -106,6 +106,7 @@ class ExprUngroup extends expression_def_1.ExpressionDef {
                 expressionType: 'ungrouped_aggregate',
                 value: ungroup,
                 evalSpace: 'output',
+                compositeFieldUsage: exprVal.compositeFieldUsage,
             };
         }
         return this.loggedErrorExpr('ungroup-with-non-scalar', `${this.control}() incompatible type`);

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

@@ -7,14 +7,12 @@ import { ParameterSpace } from './parameter-space';
 import { SourceDef } from '../../../model/malloy_types';
 import { SourceFieldSpace } from '../types/field-space';
 export declare abstract class DynamicSpace extends StaticSpace implements SourceFieldSpace {
-    protected final: model.SourceDef | undefined;
+    protected sourceDef: model.SourceDef | undefined;
     protected fromSource: model.SourceDef;
-    completions: (() => void)[];
     private complete;
     private parameters;
     protected newTimezone?: string;
     constructor(extending: SourceDef);
-    isComplete(): void;
     protected setEntry(name: string, value: SpaceEntry): void;
     addParameters(parameters: HasParameter[]): DynamicSpace;
     parameterSpace(): ParameterSpace;

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

@@ -59,17 +59,13 @@ const parameter_space_1 = require("./parameter-space");
 class DynamicSpace extends static_space_1.StaticSpace {
     constructor(extending) {
         super(structuredClone(extending));
-        this.completions = [];
         this.complete = false;
         this.parameters = [];
         this.fromSource = extending;
-        this.final = undefined;
-    }
-    isComplete() {
-        this.complete = true;
+        this.sourceDef = undefined;
     }
     setEntry(name, value) {
-        if (this.final) {
+        if (this.complete) {
             throw new Error('Space already final');
         }
         super.setEntry(name, value);
@@ -104,7 +100,8 @@ class DynamicSpace extends static_space_1.StaticSpace {
         this.newTimezone = tz;
     }
     structDef() {
-        if (this.final === undefined) {
+        this.complete = true;
+        if (this.sourceDef === undefined) {
             // Grab all the parameters so that we can populate the "final" structDef
             // with parameters immediately so that views can see them when they are translating
             const parameters = {};
@@ -113,8 +110,8 @@ class DynamicSpace extends static_space_1.StaticSpace {
                     parameters[name] = entry.parameter();
                 }
             }
-            this.final = { ...this.fromSource, fields: [] };
-            this.final.parameters = parameters;
+            this.sourceDef = { ...this.fromSource, fields: [] };
+            this.sourceDef.parameters = parameters;
             // Need to process the entities in specific order
             const fields = [];
             const joins = [];
@@ -137,14 +134,14 @@ class DynamicSpace extends static_space_1.StaticSpace {
                 if (field instanceof join_space_field_1.JoinSpaceField) {
                     const joinStruct = field.join.structDef(parameterSpace);
                     if (!error_factory_1.ErrorFactory.didCreate(joinStruct)) {
-                        this.final.fields.push(joinStruct);
+                        this.sourceDef.fields.push(joinStruct);
                         fixupJoins.push([field.join, joinStruct]);
                     }
                 }
                 else {
                     const fieldDef = field.fieldDef();
                     if (fieldDef) {
-                        this.final.fields.push(fieldDef);
+                        this.sourceDef.fields.push(fieldDef);
                     }
                     // TODO I'm just removing this, but perhaps instead I should just filter
                     // out ReferenceFields and still make this check.
@@ -158,11 +155,10 @@ class DynamicSpace extends static_space_1.StaticSpace {
                 join.fixupJoinOn(this, missingOn);
             }
         }
-        if (this.newTimezone && model.isSourceDef(this.final)) {
-            this.final.queryTimezone = this.newTimezone;
+        if (this.newTimezone && model.isSourceDef(this.sourceDef)) {
+            this.sourceDef.queryTimezone = this.newTimezone;
         }
-        this.isComplete();
-        return this.final;
+        return this.sourceDef;
     }
     emptyStructDef() {
         const ret = { ...this.fromSource };

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

@@ -1,10 +1,12 @@
 import * as model from '../../../model/malloy_types';
 import { FieldName, QueryFieldSpace, SourceFieldSpace } from '../types/field-space';
 import { MalloyElement } from '../types/malloy-element';
+import { SpaceField } from '../types/space-field';
 import { WildcardFieldReference } from '../query-items/field-references';
 import { RefinedSpace } from './refined-space';
 import { LookupResult } from '../types/lookup-result';
 import { QueryInputSpace } from './query-input-space';
+import { SpaceEntry } from '../types/space-entry';
 import { LogMessageOptions, MessageCode, MessageParameterType } from '../../parse-log';
 /**
  * The output space of a query operation. It is not named "QueryOutputSpace"
@@ -19,12 +21,29 @@ export declare abstract class QueryOperationSpace extends RefinedSpace implement
     protected exprSpace: QueryInputSpace;
     abstract readonly segmentType: 'reduce' | 'project' | 'index';
     expandedWild: Record<string, string[]>;
+    compositeFieldUsers: ({
+        type: 'filter';
+        filter: model.FilterCondition;
+        logTo: MalloyElement;
+    } | {
+        type: 'field';
+        name: string;
+        field: SpaceField;
+        logTo: MalloyElement | undefined;
+    })[];
+    _compositeFieldUsage: model.CompositeFieldUsage | undefined;
+    get compositeFieldUsage(): model.CompositeFieldUsage;
     constructor(queryInputSpace: SourceFieldSpace, refineThis: model.PipeSegment | undefined, nestParent: QueryOperationSpace | undefined, astEl: MalloyElement);
     abstract addRefineFromFields(refineThis: model.PipeSegment): void;
     logError<T extends MessageCode>(code: T, parameters: MessageParameterType<T>, options?: Omit<LogMessageOptions, 'severity'>): T;
     inputSpace(): QueryInputSpace;
     outputSpace(): QueryOperationSpace;
     protected addWild(wild: WildcardFieldReference): void;
+    protected addValidatedCompositeFieldUserFromEntry(name: string, entry: SpaceEntry): void;
+    private getJoinOnCompositeFieldUsage;
+    protected getCompositeFieldUsageIncludingJoinOns(compositeFieldUsage: model.CompositeFieldUsage): model.CompositeFieldUsage;
+    addCompositeFieldUserFromFilter(filter: model.FilterCondition, logTo: MalloyElement): void;
+    newEntry(name: string, logTo: MalloyElement, entry: SpaceEntry): void;
 }
 export declare abstract class QuerySpace extends QueryOperationSpace {
     addRefineFromFields(refineThis: model.PipeSegment): void;

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

@@ -55,6 +55,8 @@ const refined_space_1 = require("./refined-space");
 const column_space_field_1 = require("./column-space-field");
 const static_space_1 = require("./static-space");
 const query_input_space_1 = require("./query-input-space");
+const composite_source_utils_1 = require("../../../model/composite_source_utils");
+const struct_space_field_base_1 = require("./struct-space-field-base");
 /**
  * The output space of a query operation. It is not named "QueryOutputSpace"
  * because this is the namespace of the Query which is a layer of an output and
@@ -62,12 +64,22 @@ const query_input_space_1 = require("./query-input-space");
  * created and paired when a QueryOperationSpace is created.
  */
 class QueryOperationSpace extends refined_space_1.RefinedSpace {
+    get compositeFieldUsage() {
+        if (this._compositeFieldUsage === undefined) {
+            throw new Error('Composite field usage accessed before computed');
+        }
+        return this._compositeFieldUsage;
+    }
     constructor(queryInputSpace, refineThis, nestParent, astEl) {
         super(queryInputSpace.emptyStructDef());
         this.queryInputSpace = queryInputSpace;
         this.nestParent = nestParent;
         this.astEl = astEl;
         this.expandedWild = {};
+        this.compositeFieldUsers = [];
+        // Composite field usage is not computed until `queryFieldDefs` is called; if anyone
+        // tries to access it before that, they'll get an error
+        this._compositeFieldUsage = undefined;
         this.exprSpace = new query_input_space_1.QueryInputSpace(queryInputSpace.structDef(), this);
         if (refineThis)
             this.addRefineFromFields(refineThis);
@@ -134,8 +146,48 @@ class QueryOperationSpace extends refined_space_1.RefinedSpace {
         }
         // There were tests which expected these to be sorted, and that seems reasonable
         for (const x of expandEntries.sort((a, b) => a.name.localeCompare(b.name))) {
-            this.setEntry(x.name, x.entry);
+            this.newEntry(x.name, wild, x.entry);
+        }
+    }
+    addValidatedCompositeFieldUserFromEntry(name, entry) {
+        if (entry instanceof space_field_1.SpaceField) {
+            this.compositeFieldUsers.push({
+                type: 'field',
+                name,
+                field: entry,
+                logTo: undefined,
+            });
+        }
+    }
+    getJoinOnCompositeFieldUsage(joinPath) {
+        var _a;
+        const reference = joinPath.map(n => new field_space_1.FieldName(n));
+        this.astEl.has({ reference });
+        const lookup = this.queryInputSpace.lookup(reference);
+        // Should always be found...
+        if (lookup.found && lookup.found instanceof struct_space_field_base_1.StructSpaceFieldBase) {
+            return ((_a = lookup.found.fieldDef().onCompositeFieldUsage) !== null && _a !== void 0 ? _a : (0, composite_source_utils_1.emptyCompositeFieldUsage)());
         }
+        throw new Error('Unexpected join lookup was not found or not a struct');
+    }
+    getCompositeFieldUsageIncludingJoinOns(compositeFieldUsage) {
+        let compositeFieldUsageIncludingJoinOns = compositeFieldUsage;
+        const joinPaths = (0, composite_source_utils_1.compositeFieldUsageJoinPaths)(compositeFieldUsage);
+        for (const joinPath of joinPaths) {
+            compositeFieldUsageIncludingJoinOns = (0, composite_source_utils_1.mergeCompositeFieldUsage)(this.getJoinOnCompositeFieldUsage(joinPath), compositeFieldUsageIncludingJoinOns);
+        }
+        return compositeFieldUsageIncludingJoinOns;
+    }
+    addCompositeFieldUserFromFilter(filter, logTo) {
+        if (filter.compositeFieldUsage !== undefined) {
+            this.compositeFieldUsers.push({ type: 'filter', filter, logTo });
+        }
+    }
+    newEntry(name, logTo, entry) {
+        if (entry instanceof space_field_1.SpaceField) {
+            this.compositeFieldUsers.push({ type: 'field', name, field: entry, logTo });
+        }
+        super.newEntry(name, logTo, entry);
     }
 }
 exports.QueryOperationSpace = QueryOperationSpace;
@@ -147,17 +199,27 @@ class QuerySpace extends QueryOperationSpace {
             // TODO mtoy raw,partial,index
             return;
         }
+        if (refineThis === null || refineThis === void 0 ? void 0 : refineThis.extendSource) {
+            for (const xField of refineThis.extendSource) {
+                this.exprSpace.addFieldDef(xField);
+            }
+        }
         for (const field of refineThis.queryFields) {
             if (field.type === 'fieldref') {
                 const refTo = this.exprSpace.lookup(field.path.map(f => new field_space_1.FieldName(f)));
                 if (refTo.found) {
-                    this.setEntry(field.path[field.path.length - 1], refTo.found);
+                    const name = field.path[field.path.length - 1];
+                    this.setEntry(name, refTo.found);
+                    this.addValidatedCompositeFieldUserFromEntry(name, refTo.found);
                 }
             }
             else if (field.type !== 'turtle') {
                 // 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)
-                this.setEntry((_a = field.as) !== null && _a !== void 0 ? _a : field.name, new column_space_field_1.ColumnSpaceField(field));
+                const entry = new column_space_field_1.ColumnSpaceField(field);
+                const name = (_a = field.as) !== null && _a !== void 0 ? _a : field.name;
+                this.setEntry(name, entry);
+                this.addValidatedCompositeFieldUserFromEntry(name, entry);
             }
         }
     }
@@ -176,16 +238,28 @@ class QuerySpace extends QueryOperationSpace {
     }
     queryFieldDefs() {
         const fields = [];
-        for (const [name, field] of this.entries()) {
-            if (field instanceof space_field_1.SpaceField) {
+        let compositeFieldUsage = (0, composite_source_utils_1.emptyCompositeFieldUsage)();
+        let narrowedCompositeFieldResolution = (0, composite_source_utils_1.emptyNarrowedCompositeFieldResolution)();
+        const source = this.inputSpace().structDef();
+        for (const user of this.compositeFieldUsers) {
+            let nextCompositeFieldUsage = undefined;
+            if (user.type === 'filter') {
+                if (user.filter.compositeFieldUsage) {
+                    nextCompositeFieldUsage = user.filter.compositeFieldUsage;
+                }
+            }
+            else {
+                const { name, field } = user;
                 const wildPath = this.expandedWild[name];
                 if (wildPath) {
                     fields.push({ type: 'fieldref', path: wildPath });
                     continue;
                 }
+                // TODO handle wildcards for composite sources
                 const fieldQueryDef = field.getQueryFieldDef(this.exprSpace);
                 if (fieldQueryDef) {
                     const typeDesc = field.typeDesc();
+                    nextCompositeFieldUsage = typeDesc.compositeFieldUsage;
                     // Filter out fields whose type is 'error', which means that a totally bad field
                     // isn't sent to the compiler, where it will wig out.
                     // TODO Figure out how to make errors generated by `canContain` go in the right place,
@@ -205,8 +279,32 @@ class QuerySpace extends QueryOperationSpace {
                 // project statements, where we added "*" as a field and also all the individual
                 // fields, but the individual fields didn't have field defs.
             }
+            if (nextCompositeFieldUsage) {
+                const newCompositeFieldUsage = this.getCompositeFieldUsageIncludingJoinOns((0, composite_source_utils_1.compositeFieldUsageDifference)(nextCompositeFieldUsage, compositeFieldUsage));
+                compositeFieldUsage = (0, composite_source_utils_1.mergeCompositeFieldUsage)(compositeFieldUsage, newCompositeFieldUsage);
+                if (!(0, composite_source_utils_1.isEmptyCompositeFieldUsage)(newCompositeFieldUsage)) {
+                    const result = (0, composite_source_utils_1.narrowCompositeFieldResolution)(source, compositeFieldUsage, narrowedCompositeFieldResolution);
+                    if (result.error) {
+                        if (user.logTo) {
+                            user.logTo.logError('invalid-composite-field-usage', {
+                                newUsage: newCompositeFieldUsage,
+                                allUsage: compositeFieldUsage,
+                            });
+                        }
+                        else {
+                            // This should not happen; logTo should only be not set for a field from a refinement,
+                            // which should never fail the composite resolution
+                            throw new Error('Unexpected invalid composite field resolution');
+                        }
+                    }
+                    else {
+                        narrowedCompositeFieldResolution =
+                            result.narrowedCompositeFieldResolution;
+                    }
+                }
+            }
         }
-        this.isComplete();
+        this._compositeFieldUsage = compositeFieldUsage;
         return fields;
     }
     getQuerySegment(rf) {
@@ -222,11 +320,6 @@ class QuerySpace extends QueryOperationSpace {
             this.logError('unexpected-index-segment', 'internal error generating index segment from non index query');
             return { type: 'reduce', queryFields: [] };
         }
-        if (refineFrom === null || refineFrom === void 0 ? void 0 : refineFrom.extendSource) {
-            for (const xField of refineFrom.extendSource) {
-                this.exprSpace.addFieldDef(xField);
-            }
-        }
         const segment = {
             type: this.segmentType,
             queryFields: this.queryFieldDefs(),
@@ -249,7 +342,6 @@ class QuerySpace extends QueryOperationSpace {
         if (this.newTimezone) {
             segment.queryTimezone = this.newTimezone;
         }
-        this.isComplete();
         return segment;
     }
     lookup(path) {

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

@@ -49,6 +49,7 @@ exports.ReferenceField = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
 const TDU = __importStar(require("../typedesc-utils"));
 const space_field_1 = require("../types/space-field");
+const composite_source_utils_1 = require("../../../model/composite_source_utils");
 class ReferenceField extends space_field_1.SpaceField {
     constructor(fieldRef, inFS) {
         super();
@@ -112,7 +113,12 @@ class ReferenceField extends space_field_1.SpaceField {
             return this.memoTypeDesc;
         const refTo = this.referenceTo;
         if (refTo) {
-            this.memoTypeDesc = refTo.typeDesc();
+            const joinPath = this.fieldRef.list.slice(0, -1).map(x => x.refString);
+            const typeDesc = refTo.typeDesc();
+            this.memoTypeDesc = {
+                ...typeDesc,
+                compositeFieldUsage: (0, composite_source_utils_1.joinedCompositeFieldUsage)(joinPath, typeDesc.compositeFieldUsage),
+            };
             return this.memoTypeDesc;
         }
         return TDU.errorT;

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

@@ -11,4 +11,5 @@ export declare class RefinedSpace extends DynamicSpace {
      */
     static filteredFrom(from: SourceDef, choose: FieldListEdit | undefined, parameters: ParameterSpace | undefined): RefinedSpace;
     pushFields(...defs: MalloyElement[]): void;
+    addField(def: MalloyElement): void;
 }

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

@@ -60,12 +60,15 @@ class RefinedSpace extends dynamic_space_1.DynamicSpace {
     }
     pushFields(...defs) {
         for (const me of defs) {
-            if ((0, space_entry_1.canMakeEntry)(me)) {
-                me.makeEntry(this);
-            }
-            else {
-                me.logError('unexpected-element-type', `Internal error, ${me.elementType} not expected in this context`);
-            }
+            this.addField(me);
+        }
+    }
+    addField(def) {
+        if ((0, space_entry_1.canMakeEntry)(def)) {
+            def.makeEntry(this);
+        }
+        else {
+            def.logError('unexpected-element-type', `Internal error, ${def.elementType} not expected in this context`);
         }
     }
 }