@malloydata/malloy 0.0.39-dev230613161129 → 0.0.39

package/dist/lang/ast/index.d.ts

@@ -58,6 +58,7 @@ export * from './query-elements/full-query';
 export * from './query-items/field-declaration';
 export * from './query-items/field-references';
 export * from './query-properties/aggregate';
+export * from './query-properties/calculate';
 export * from './query-properties/declare-fields';
 export * from './query-properties/dimmensions';
 export * from './query-properties/filters';

package/dist/lang/ast/index.js

@@ -96,6 +96,7 @@ __exportStar(require("./query-elements/full-query"), exports);
 __exportStar(require("./query-items/field-declaration"), exports);
 __exportStar(require("./query-items/field-references"), exports);
 __exportStar(require("./query-properties/aggregate"), exports);
+__exportStar(require("./query-properties/calculate"), exports);
 __exportStar(require("./query-properties/declare-fields"), exports);
 __exportStar(require("./query-properties/dimmensions"), exports);
 __exportStar(require("./query-properties/filters"), exports);

package/dist/lang/ast/query-items/field-declaration.d.ts

@@ -1,19 +1,51 @@
 import { Dialect } from '../../../dialect/dialect';
 import { FieldTypeDef, StructDef } from '../../../model/malloy_types';
+import { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
-import { FieldName, FieldSpace } from '../types/field-space';
+import { FieldName, FieldSpace, QueryFieldSpace } from '../types/field-space';
 import { LookupResult } from '../types/lookup-result';
 import { MalloyElement } from '../types/malloy-element';
-export declare class FieldDeclaration extends MalloyElement {
+import { SpaceEntry } from '../types/space-entry';
+export declare type FieldDeclarationConstructor = new (expr: ExpressionDef, defineName: string, exprSrc?: string) => FieldDeclaration;
+export declare abstract class FieldDeclaration extends MalloyElement {
     readonly expr: ExpressionDef;
     readonly defineName: string;
     readonly exprSrc?: string | undefined;
-    elementType: string;
-    isMeasure?: boolean;
     constructor(expr: ExpressionDef, defineName: string, exprSrc?: string | undefined);
     fieldDef(fs: FieldSpace, exprName: string): FieldTypeDef;
+    abstract typecheckExprValue(expr: ExprValue): void;
+    executesInOutputSpace(): boolean;
     queryFieldDef(exprFS: FieldSpace, exprName: string): FieldTypeDef;
 }
+export declare class CalculateFieldDeclaration extends FieldDeclaration {
+    elementType: string;
+    typecheckExprValue(expr: ExprValue): void;
+    executesInOutputSpace(): boolean;
+}
+export declare class AggregateFieldDeclaration extends FieldDeclaration {
+    elementType: string;
+    typecheckExprValue(expr: ExprValue): void;
+}
+export declare class GroupByFieldDeclaration extends FieldDeclaration {
+    elementType: string;
+    typecheckExprValue(expr: ExprValue): void;
+}
+export declare class ProjectFieldDeclaration extends FieldDeclaration {
+    elementType: string;
+    typecheckExprValue(expr: ExprValue): void;
+}
+export declare class DeclareFieldDeclaration extends FieldDeclaration {
+    elementType: string;
+    typecheckExprValue(expr: ExprValue): void;
+}
+export declare class MeasureFieldDeclaration extends FieldDeclaration {
+    elementType: string;
+    typecheckExprValue(expr: ExprValue): void;
+}
+export declare class DimensionFieldDeclaration extends FieldDeclaration {
+    elementType: string;
+    typecheckExprValue(expr: ExprValue): void;
+}
 /**
  * Used to detect references to fields in the statement which defines them
  */
@@ -25,7 +57,11 @@ export declare class DefSpace implements FieldSpace {
     constructor(realFS: FieldSpace, circular: FieldDeclaration);
     structDef(): StructDef;
     emptyStructDef(): StructDef;
+    entry(name: string): SpaceEntry | undefined;
     lookup(symbol: FieldName[]): LookupResult;
+    entries(): [string, SpaceEntry][];
     dialectObj(): Dialect | undefined;
     whenComplete(step: () => void): void;
+    isQueryFieldSpace(): this is QueryFieldSpace;
+    outputSpace(): FieldSpace;
 }

package/dist/lang/ast/query-items/field-declaration.js

@@ -22,19 +22,19 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefSpace = exports.FieldDeclaration = void 0;
+exports.DefSpace = exports.DimensionFieldDeclaration = exports.MeasureFieldDeclaration = exports.DeclareFieldDeclaration = exports.ProjectFieldDeclaration = exports.GroupByFieldDeclaration = exports.AggregateFieldDeclaration = exports.CalculateFieldDeclaration = exports.FieldDeclaration = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
 const utils_1 = require("../expressions/utils");
 const fragtype_utils_1 = require("../fragtype-utils");
 const granular_result_1 = require("../types/granular-result");
 const malloy_element_1 = require("../types/malloy-element");
+const typecheck_utils_1 = require("./typecheck_utils");
 class FieldDeclaration extends malloy_element_1.MalloyElement {
     constructor(expr, defineName, exprSrc) {
         super({ expr: expr });
         this.expr = expr;
         this.defineName = defineName;
         this.exprSrc = exprSrc;
-        this.elementType = 'fieldDeclaration';
     }
     fieldDef(fs, exprName) {
         /*
@@ -48,10 +48,20 @@ class FieldDeclaration extends malloy_element_1.MalloyElement {
          */
         return this.queryFieldDef(new DefSpace(fs, this), exprName);
     }
+    executesInOutputSpace() {
+        return false;
+    }
     queryFieldDef(exprFS, exprName) {
         let exprValue;
+        function getOutputFS() {
+            if (exprFS.isQueryFieldSpace()) {
+                return exprFS.outputSpace();
+            }
+            throw new Error('must be in a query -- weird internal error');
+        }
         try {
-            exprValue = this.expr.getExpression(exprFS);
+            const fs = this.executesInOutputSpace() ? getOutputFS() : exprFS;
+            exprValue = this.expr.getExpression(fs);
         }
         catch (error) {
             this.log(`Cannot define '${exprName}', ${error.message}`);
@@ -74,6 +84,7 @@ class FieldDeclaration extends malloy_element_1.MalloyElement {
             if (exprValue.expressionType) {
                 template.expressionType = exprValue.expressionType;
             }
+            this.typecheckExprValue(exprValue);
             if (this.exprSrc) {
                 template.code = this.exprSrc;
             }
@@ -100,6 +111,79 @@ class FieldDeclaration extends malloy_element_1.MalloyElement {
     }
 }
 exports.FieldDeclaration = FieldDeclaration;
+class CalculateFieldDeclaration extends FieldDeclaration {
+    constructor() {
+        super(...arguments);
+        this.elementType = 'calculateFieldDeclaration';
+    }
+    typecheckExprValue(expr) {
+        (0, typecheck_utils_1.typecheckCalculate)(expr, this);
+    }
+    executesInOutputSpace() {
+        return true;
+    }
+}
+exports.CalculateFieldDeclaration = CalculateFieldDeclaration;
+class AggregateFieldDeclaration extends FieldDeclaration {
+    constructor() {
+        super(...arguments);
+        this.elementType = 'aggregateFieldDeclaration';
+    }
+    typecheckExprValue(expr) {
+        (0, typecheck_utils_1.typecheckAggregate)(expr, this);
+    }
+}
+exports.AggregateFieldDeclaration = AggregateFieldDeclaration;
+class GroupByFieldDeclaration extends FieldDeclaration {
+    constructor() {
+        super(...arguments);
+        this.elementType = 'groupByFieldDeclaration';
+    }
+    typecheckExprValue(expr) {
+        (0, typecheck_utils_1.typecheckGroupBy)(expr, this);
+    }
+}
+exports.GroupByFieldDeclaration = GroupByFieldDeclaration;
+class ProjectFieldDeclaration extends FieldDeclaration {
+    constructor() {
+        super(...arguments);
+        this.elementType = 'projectFieldDeclaration';
+    }
+    typecheckExprValue(expr) {
+        (0, typecheck_utils_1.typecheckProject)(expr, this);
+    }
+}
+exports.ProjectFieldDeclaration = ProjectFieldDeclaration;
+class DeclareFieldDeclaration extends FieldDeclaration {
+    constructor() {
+        super(...arguments);
+        this.elementType = 'declareFieldDeclaration';
+    }
+    typecheckExprValue(expr) {
+        (0, typecheck_utils_1.typecheckDeclare)(expr, this);
+    }
+}
+exports.DeclareFieldDeclaration = DeclareFieldDeclaration;
+class MeasureFieldDeclaration extends FieldDeclaration {
+    constructor() {
+        super(...arguments);
+        this.elementType = 'measureFieldDeclaration';
+    }
+    typecheckExprValue(expr) {
+        (0, typecheck_utils_1.typecheckMeasure)(expr, this);
+    }
+}
+exports.MeasureFieldDeclaration = MeasureFieldDeclaration;
+class DimensionFieldDeclaration extends FieldDeclaration {
+    constructor() {
+        super(...arguments);
+        this.elementType = 'dimensionFieldDeclaration';
+    }
+    typecheckExprValue(expr) {
+        (0, typecheck_utils_1.typecheckDimension)(expr, this);
+    }
+}
+exports.DimensionFieldDeclaration = DimensionFieldDeclaration;
 /**
  * Used to detect references to fields in the statement which defines them
  */
@@ -116,6 +200,9 @@ class DefSpace {
     emptyStructDef() {
         return this.realFS.emptyStructDef();
     }
+    entry(name) {
+        return this.realFS.entry(name);
+    }
     lookup(symbol) {
         if (symbol[0] && symbol[0].refString === this.circular.defineName) {
             this.foundCircle = true;
@@ -126,12 +213,24 @@ class DefSpace {
         }
         return this.realFS.lookup(symbol);
     }
+    entries() {
+        return this.realFS.entries();
+    }
     dialectObj() {
         return this.realFS.dialectObj();
     }
     whenComplete(step) {
         this.realFS.whenComplete(step);
     }
+    isQueryFieldSpace() {
+        return this.realFS.isQueryFieldSpace();
+    }
+    outputSpace() {
+        if (this.realFS.isQueryFieldSpace()) {
+            return this.realFS.outputSpace();
+        }
+        throw new Error('Not a query field space');
+    }
 }
 exports.DefSpace = DefSpace;
 //# sourceMappingURL=field-declaration.js.map

package/dist/lang/ast/query-items/field-references.d.ts

@@ -1,16 +1,58 @@
-import { FieldDef } from '../../../model/malloy_types';
+import { FieldDef, TypeDesc } from '../../../model/malloy_types';
 import { FieldName, FieldSpace } from '../types/field-space';
 import { LookupResult } from '../types/lookup-result';
 import { ListOf, MalloyElement } from '../types/malloy-element';
-export declare class FieldReference extends ListOf<FieldName> {
+export declare type FieldReferenceConstructor = new (names: FieldName[]) => FieldReference;
+export declare abstract class FieldReference extends ListOf<FieldName> {
     elementType: string;
     constructor(names: FieldName[]);
     get refString(): string;
     get outputName(): string;
     get sourceString(): string | undefined;
     get nameString(): string;
+    abstract typecheck(type: TypeDesc): any;
     getField(fs: FieldSpace): LookupResult;
 }
+export declare class AcceptExceptFieldReference extends FieldReference {
+    elementType: string;
+    typecheck(): void;
+}
+export declare class ExpressionFieldReference extends FieldReference {
+    elementType: string;
+    typecheck(): void;
+}
+export declare class CalculateFieldReference extends FieldReference {
+    elementType: string;
+    typecheck(type: TypeDesc): void;
+}
+export declare class IndexFieldReference extends FieldReference {
+    elementType: string;
+    typecheck(type: TypeDesc): void;
+}
+export declare class AggregateFieldReference extends FieldReference {
+    elementType: string;
+    typecheck(type: TypeDesc): void;
+}
+export declare class GroupByFieldReference extends FieldReference {
+    elementType: string;
+    typecheck(type: TypeDesc): void;
+}
+export declare class ProjectFieldReference extends FieldReference {
+    elementType: string;
+    typecheck(type: TypeDesc): void;
+}
+export declare class DeclareFieldReference extends FieldReference {
+    elementType: string;
+    typecheck(type: TypeDesc): void;
+}
+export declare class MeasureFieldReference extends FieldReference {
+    elementType: string;
+    typecheck(type: TypeDesc): void;
+}
+export declare class DimensionFieldReference extends FieldReference {
+    elementType: string;
+    typecheck(type: TypeDesc): void;
+}
 export declare class WildcardFieldReference extends MalloyElement {
     readonly joinPath: FieldReference | undefined;
     readonly star: '*' | '**';

package/dist/lang/ast/query-items/field-references.js

@@ -22,8 +22,9 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FieldReferences = exports.WildcardFieldReference = exports.FieldReference = void 0;
+exports.FieldReferences = exports.WildcardFieldReference = exports.DimensionFieldReference = exports.MeasureFieldReference = exports.DeclareFieldReference = exports.ProjectFieldReference = exports.GroupByFieldReference = exports.AggregateFieldReference = exports.IndexFieldReference = exports.CalculateFieldReference = exports.ExpressionFieldReference = exports.AcceptExceptFieldReference = exports.FieldReference = void 0;
 const malloy_element_1 = require("../types/malloy-element");
+const typecheck_utils_1 = require("./typecheck_utils");
 class FieldReference extends malloy_element_1.ListOf {
     constructor(names) {
         super('fieldReference', names);
@@ -49,10 +50,117 @@ class FieldReference extends malloy_element_1.ListOf {
         return this.list[this.list.length - 1].refString;
     }
     getField(fs) {
-        return fs.lookup(this.list);
+        const result = fs.lookup(this.list);
+        if (result.found) {
+            const actualType = result.found.typeDesc();
+            this.typecheck(actualType);
+        }
+        return result;
     }
 }
 exports.FieldReference = FieldReference;
+class AcceptExceptFieldReference extends FieldReference {
+    constructor() {
+        super(...arguments);
+        this.elementType = 'acceptExceptFieldReference';
+    }
+    // Nothing to typecheck here
+    typecheck() {
+        return;
+    }
+}
+exports.AcceptExceptFieldReference = AcceptExceptFieldReference;
+class ExpressionFieldReference extends FieldReference {
+    constructor() {
+        super(...arguments);
+        this.elementType = 'expressionFieldReference';
+    }
+    // We assume that the outer expression will typecheck this
+    typecheck() {
+        return;
+    }
+}
+exports.ExpressionFieldReference = ExpressionFieldReference;
+class CalculateFieldReference extends FieldReference {
+    constructor() {
+        super(...arguments);
+        this.elementType = 'calculateFieldReference';
+    }
+    typecheck(type) {
+        (0, typecheck_utils_1.typecheckCalculate)(type, this);
+    }
+}
+exports.CalculateFieldReference = CalculateFieldReference;
+class IndexFieldReference extends FieldReference {
+    constructor() {
+        super(...arguments);
+        this.elementType = 'indexFieldReference';
+    }
+    typecheck(type) {
+        (0, typecheck_utils_1.typecheckIndex)(type, this);
+    }
+}
+exports.IndexFieldReference = IndexFieldReference;
+class AggregateFieldReference extends FieldReference {
+    constructor() {
+        super(...arguments);
+        this.elementType = 'aggregateFieldReference';
+    }
+    typecheck(type) {
+        (0, typecheck_utils_1.typecheckAggregate)(type, this);
+    }
+}
+exports.AggregateFieldReference = AggregateFieldReference;
+class GroupByFieldReference extends FieldReference {
+    constructor() {
+        super(...arguments);
+        this.elementType = 'groupByFieldReference';
+    }
+    typecheck(type) {
+        (0, typecheck_utils_1.typecheckGroupBy)(type, this);
+    }
+}
+exports.GroupByFieldReference = GroupByFieldReference;
+class ProjectFieldReference extends FieldReference {
+    constructor() {
+        super(...arguments);
+        this.elementType = 'projectFieldReference';
+    }
+    typecheck(type) {
+        (0, typecheck_utils_1.typecheckProject)(type, this);
+    }
+}
+exports.ProjectFieldReference = ProjectFieldReference;
+class DeclareFieldReference extends FieldReference {
+    constructor() {
+        super(...arguments);
+        this.elementType = 'declareFieldReference';
+    }
+    typecheck(type) {
+        (0, typecheck_utils_1.typecheckDeclare)(type, this);
+    }
+}
+exports.DeclareFieldReference = DeclareFieldReference;
+class MeasureFieldReference extends FieldReference {
+    constructor() {
+        super(...arguments);
+        this.elementType = 'measureFieldReference';
+    }
+    typecheck(type) {
+        (0, typecheck_utils_1.typecheckMeasure)(type, this);
+    }
+}
+exports.MeasureFieldReference = MeasureFieldReference;
+class DimensionFieldReference extends FieldReference {
+    constructor() {
+        super(...arguments);
+        this.elementType = 'dimensionFieldReference';
+    }
+    typecheck(type) {
+        (0, typecheck_utils_1.typecheckDimension)(type, this);
+    }
+}
+exports.DimensionFieldReference = DimensionFieldReference;
 class WildcardFieldReference extends malloy_element_1.MalloyElement {
     constructor(joinPath, star) {
         super();

package/dist/lang/ast/query-items/typecheck_utils.d.ts

@@ -0,0 +1,10 @@
+import { TypeDesc } from '../../../model';
+import { MalloyElement } from '../types/malloy-element';
+export declare function typecheckProject(type: TypeDesc, logTo: MalloyElement): void;
+export declare function typecheckIndex(type: TypeDesc, logTo: MalloyElement): void;
+export declare function typecheckDimension(type: TypeDesc, logTo: MalloyElement): void;
+export declare function typecheckMeasure(type: TypeDesc, logTo: MalloyElement): void;
+export declare function typecheckDeclare(type: TypeDesc, logTo: MalloyElement): void;
+export declare function typecheckCalculate(type: TypeDesc, logTo: MalloyElement): void;
+export declare function typecheckAggregate(type: TypeDesc, logTo: MalloyElement): void;
+export declare function typecheckGroupBy(type: TypeDesc, logTo: MalloyElement): void;

package/dist/lang/ast/query-items/typecheck_utils.js

@@ -0,0 +1,177 @@
+"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.typecheckGroupBy = exports.typecheckAggregate = exports.typecheckCalculate = exports.typecheckDeclare = exports.typecheckMeasure = exports.typecheckDimension = exports.typecheckIndex = exports.typecheckProject = void 0;
+const model_1 = require("../../../model");
+function typecheckProject(type, logTo) {
+    if (type.dataType === 'turtle' || !(0, model_1.expressionIsScalar)(type.expressionType)) {
+        let useInstead;
+        let kind;
+        if (type.dataType === 'turtle') {
+            useInstead = 'a nest';
+            kind = 'a query';
+        }
+        else if ((0, model_1.expressionIsAnalytic)(type.expressionType)) {
+            useInstead = 'a calculate';
+            kind = 'an analytic';
+        }
+        else if ((0, model_1.expressionIsAggregate)(type.expressionType)) {
+            useInstead = 'an aggregate';
+            kind = 'an aggregate';
+        }
+        else {
+            throw new Error(`Unexpected expression type ${type.expressionType} not handled here`);
+        }
+        logTo.log(`Cannot use ${kind} field in a project operation, did you mean to use ${useInstead} operation instead?`);
+    }
+}
+exports.typecheckProject = typecheckProject;
+function typecheckIndex(type, logTo) {
+    if (type.dataType === 'turtle' || !(0, model_1.expressionIsScalar)(type.expressionType)) {
+        let kind;
+        if (type.dataType === 'turtle') {
+            kind = 'a query';
+        }
+        else if ((0, model_1.expressionIsAnalytic)(type.expressionType)) {
+            kind = 'an analytic';
+        }
+        else if ((0, model_1.expressionIsAggregate)(type.expressionType)) {
+            kind = 'an aggregate';
+        }
+        else {
+            throw new Error(`Unexpected expression type ${type.expressionType} not handled here`);
+        }
+        logTo.log(`Cannot use ${kind} field in an index operation`);
+    }
+}
+exports.typecheckIndex = typecheckIndex;
+function typecheckDimension(type, logTo) {
+    if (!(0, model_1.expressionIsScalar)(type.expressionType)) {
+        if ((0, model_1.expressionIsAggregate)(type.expressionType)) {
+            logTo.log('Cannot use an aggregate field in a dimension declaration, did you mean to use a measure declaration instead?');
+        }
+        else if ((0, model_1.expressionIsAnalytic)(type.expressionType)) {
+            logTo.log('Cannot use an analytic field in a dimension declaration');
+        }
+        else {
+            throw new Error(`Unexpected expression type ${type.expressionType} not handled here`);
+        }
+    }
+}
+exports.typecheckDimension = typecheckDimension;
+function typecheckMeasure(type, logTo) {
+    if (!(0, model_1.expressionIsAggregate)(type.expressionType)) {
+        if ((0, model_1.expressionIsScalar)(type.expressionType)) {
+            logTo.log('Cannot use a scalar field in a measure declaration, did you mean to use a dimension declaration instead?');
+        }
+        else if ((0, model_1.expressionIsAnalytic)(type.expressionType)) {
+            logTo.log('Cannot use an analytic field in a measure declaration');
+        }
+        else {
+            throw new Error(`Unexpected expression type ${type.expressionType} not handled here`);
+        }
+    }
+}
+exports.typecheckMeasure = typecheckMeasure;
+function typecheckDeclare(type, logTo) {
+    if (type.dataType === 'turtle') {
+        logTo.log('Query fields cannot be used in a declare block');
+    }
+    else if ((0, model_1.expressionIsAnalytic)(type.expressionType)) {
+        logTo.log('Analytic expressions can not be used in a declare block');
+    }
+}
+exports.typecheckDeclare = typecheckDeclare;
+function typecheckCalculate(type, logTo) {
+    if (type.dataType === 'turtle' ||
+        !(0, model_1.expressionIsAnalytic)(type.expressionType)) {
+        let useInstead;
+        let kind;
+        if (type.dataType === 'turtle') {
+            useInstead = 'a nest';
+            kind = 'a query';
+        }
+        else if ((0, model_1.expressionIsAggregate)(type.expressionType)) {
+            useInstead = 'an aggregate';
+            kind = 'an aggregate';
+        }
+        else if ((0, model_1.expressionIsScalar)(type.expressionType)) {
+            useInstead = 'a group_by or project';
+            kind = 'a scalar';
+        }
+        else {
+            throw new Error(`Unexpected expression type ${type.expressionType} not handled here`);
+        }
+        logTo.log(`Cannot use ${kind} field in a calculate operation, did you mean to use ${useInstead} operation instead?`);
+    }
+}
+exports.typecheckCalculate = typecheckCalculate;
+function typecheckAggregate(type, logTo) {
+    if (type.dataType === 'turtle' ||
+        !(0, model_1.expressionIsAggregate)(type.expressionType)) {
+        let useInstead;
+        let kind;
+        if (type.dataType === 'turtle') {
+            useInstead = 'a nest';
+            kind = 'a query';
+        }
+        else if ((0, model_1.expressionIsAnalytic)(type.expressionType)) {
+            useInstead = 'a calculate';
+            kind = 'an analytic';
+        }
+        else if ((0, model_1.expressionIsScalar)(type.expressionType)) {
+            useInstead = 'a group_by or project';
+            kind = 'a scalar';
+        }
+        else {
+            throw new Error(`Unexpected expression type ${type} not handled here`);
+        }
+        logTo.log(`Cannot use ${kind} field in an aggregate operation, did you mean to use ${useInstead} operation instead?`);
+    }
+}
+exports.typecheckAggregate = typecheckAggregate;
+function typecheckGroupBy(type, logTo) {
+    if (type.dataType === 'turtle' || !(0, model_1.expressionIsScalar)(type.expressionType)) {
+        let useInstead;
+        let kind;
+        if (type.dataType === 'turtle') {
+            useInstead = 'a nest';
+            kind = 'a query';
+        }
+        else if ((0, model_1.expressionIsAnalytic)(type.expressionType)) {
+            useInstead = 'a calculate';
+            kind = 'an analytic';
+        }
+        else if ((0, model_1.expressionIsAggregate)(type.expressionType)) {
+            useInstead = 'an aggregate';
+            kind = 'an aggregate';
+        }
+        else {
+            throw new Error(`Unexpected expression type ${type.expressionType} not handled here`);
+        }
+        logTo.log(`Cannot use ${kind} field in a group_by operation, did you mean to use ${useInstead} operation instead?`);
+    }
+}
+exports.typecheckGroupBy = typecheckGroupBy;
+//# sourceMappingURL=typecheck_utils.js.map

package/dist/lang/ast/query-properties/aggregate.js

@@ -23,16 +23,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Aggregate = void 0;
-const field_declaration_1 = require("../query-items/field-declaration");
 const malloy_element_1 = require("../types/malloy-element");
 class Aggregate extends malloy_element_1.ListOf {
     constructor(members) {
         super('aggregate', members);
-        for (const el of members) {
-            if (el instanceof field_declaration_1.FieldDeclaration) {
-                el.isMeasure = true;
-            }
-        }
     }
 }
 exports.Aggregate = Aggregate;

package/dist/lang/ast/query-properties/calculate.d.ts

@@ -0,0 +1,5 @@
+import { ListOf } from '../types/malloy-element';
+import { QueryItem } from '../types/query-item';
+export declare class Calculate extends ListOf<QueryItem> {
+    constructor(members: QueryItem[]);
+}