@malloydata/malloy 0.0.262 → 0.0.263-dev250414184158

package/dist/lang/ast/expressions/expr-filter-expr.d.ts

@@ -1,11 +1,8 @@
-import type { BinaryMalloyOperator } from '../types/binary_operators';
 import type { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
-import type { FieldSpace } from '../types/field-space';
 export declare class ExprFilterExpression extends ExpressionDef {
     readonly filterText: string;
     elementType: string;
     constructor(filterText: string);
     getExpression(): ExprValue;
-    apply(fs: FieldSpace, op: BinaryMalloyOperator, left: ExpressionDef, _warnOnComplexTree?: boolean): ExprValue;
 }

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

@@ -7,9 +7,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprFilterExpression = void 0;
-const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
-const malloy_filter_1 = require("@malloydata/malloy-filter");
 class ExprFilterExpression extends expression_def_1.ExpressionDef {
     constructor(filterText) {
         super();
@@ -17,63 +15,13 @@ class ExprFilterExpression extends expression_def_1.ExpressionDef {
         this.elementType = 'filter expression literal';
     }
     getExpression() {
-        return this.loggedErrorExpr('filter-expression-type', 'Filter expression illegal here');
-    }
-    apply(fs, op, left, _warnOnComplexTree = false) {
-        var _a;
-        if (op === '~' || op === '!~') {
-            const matchExpr = left.getExpression(fs);
-            if (matchExpr.type === 'error') {
-                return matchExpr;
-            }
-            let fParse;
-            switch (matchExpr.type) {
-                case 'string':
-                    fParse = malloy_filter_1.StringFilterExpression.parse(this.filterText);
-                    break;
-                case 'number':
-                    fParse = malloy_filter_1.NumberFilterExpression.parse(this.filterText);
-                    break;
-                case 'boolean':
-                    if ((_a = fs.dialectObj()) === null || _a === void 0 ? void 0 : _a.booleanAsNumbers) {
-                        return this.loggedErrorExpr('filter-expression-type', 'Boolean filters not supported on this connection type');
-                    }
-                    fParse = malloy_filter_1.BooleanFilterExpression.parse(this.filterText);
-                    break;
-                case 'date':
-                case 'timestamp':
-                    fParse = malloy_filter_1.TemporalFilterExpression.parse(this.filterText);
-                    break;
-                default:
-                    return left.loggedErrorExpr('filter-expression-type', `Cannot use filter expressions with type '${matchExpr.type}'`);
-            }
-            if (fParse.log.length > 0) {
-                for (const err of fParse.log) {
-                    // Current parser only ever returns one error, it doesn't recover
-                    // Theoretically possible to user the startIndex to point to the
-                    // error inside the filter string, but I don't know if this is an
-                    // f' string or an f''' string, and I think the startOffset is from
-                    // the first non blank space in the filter (it was at one point)
-                    // so for now, we just flag the entire filter source token.
-                    return this.loggedErrorExpr('filter-expression-error', `Filter parse error: ${err.message}`);
-                }
-            }
-            const filterMatch = {
-                node: 'filterMatch',
-                dataType: matchExpr.type,
-                filter: fParse.parsed,
-                e: matchExpr.value,
-            };
-            if (op === '!~') {
-                filterMatch.notMatch = true;
-            }
-            return (0, expr_value_1.computedExprValue)({
-                value: filterMatch,
-                dataType: { type: 'boolean' },
-                from: [matchExpr],
-            });
-        }
-        return this.loggedErrorExpr('filter-expression-type', `Cannot use the '${op}' operator with a filter expression`);
+        return {
+            type: 'filter expression',
+            value: { node: 'filterLiteral', filterSrc: this.filterText },
+            expressionType: 'scalar',
+            evalSpace: 'constant',
+            compositeFieldUsage: { fields: [], joinedUsage: {} },
+        };
     }
 }
 exports.ExprFilterExpression = ExprFilterExpression;

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

@@ -309,6 +309,9 @@ class ExprFunc extends expression_def_1.ExpressionDef {
                         if (result.found === undefined) {
                             return this.loggedErrorExpr('sql-function-interpolation-not-found', `Invalid interpolation: ${result.error.message}`);
                         }
+                        if (result.found.typeDesc().type === 'filter expression') {
+                            return this.loggedErrorExpr('filter-expression-error', 'Filter expressions cannot be used in sql_ functions');
+                        }
                         if (result.found.refType === 'parameter') {
                             expr.push({ node: 'parameter', path: [part.name] });
                         }

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

@@ -129,6 +129,9 @@ class Pick extends expression_def_1.ExpressionDef {
                 });
             }
         }
+        if (definedReturnType.type === 'filter expression') {
+            return this.loggedErrorExpr('filter-expression-error', 'Pick statments cannot have filter expression values');
+        }
         caseValue.kids.caseElse = defaultVal.value;
         return (0, expr_value_1.computedExprValue)({
             dataType: definedReturnType,
@@ -188,6 +191,9 @@ class Pick extends expression_def_1.ExpressionDef {
                 returnType: definedReturnType.type,
             });
         }
+        if (definedReturnType.type === 'filter expression') {
+            return this.loggedErrorExpr('filter-expression-error', 'Pick statments cannot have filter expression values');
+        }
         pick.kids.caseElse = defVal.value;
         return (0, expr_value_1.computedExprValue)({
             dataType: definedReturnType,

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

@@ -134,7 +134,7 @@ class DynamicSpace extends static_space_1.StaticSpace {
             const parameterSpace = this.parameterSpace();
             for (const [name, field] of reorderFields) {
                 if (field instanceof join_space_field_1.JoinSpaceField) {
-                    const joinStruct = field.join.structDef(parameterSpace);
+                    const joinStruct = field.join.getStructDef(parameterSpace);
                     if (!error_factory_1.ErrorFactory.didCreate(joinStruct)) {
                         fieldIndices.set(name, this.sourceDef.fields.length);
                         this.sourceDef.fields.push(joinStruct);

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

@@ -26,7 +26,7 @@ exports.JoinSpaceField = void 0;
 const static_space_1 = require("./static-space");
 class JoinSpaceField extends static_space_1.StructSpaceField {
     constructor(parameterSpace, join, forDialect) {
-        super(join.structDef(parameterSpace), forDialect);
+        super(join.getStructDef(parameterSpace), forDialect);
         this.parameterSpace = parameterSpace;
         this.join = join;
     }

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

@@ -19,6 +19,7 @@ export * from './source-properties/timezone-statement';
 export * from './expressions/apply';
 export * from './expressions/binary-numeric';
 export * from './expressions/boolean';
+export * from './expressions/constant-expression';
 export * from './expressions/function-ordering';
 export * from './expressions/expr-add-sub';
 export * from './expressions/expr-aggregate-function';

package/dist/lang/ast/index.js

@@ -57,6 +57,7 @@ __exportStar(require("./source-properties/timezone-statement"), exports);
 __exportStar(require("./expressions/apply"), exports);
 __exportStar(require("./expressions/binary-numeric"), exports);
 __exportStar(require("./expressions/boolean"), exports);
+__exportStar(require("./expressions/constant-expression"), exports);
 __exportStar(require("./expressions/function-ordering"), exports);
 __exportStar(require("./expressions/expr-add-sub"), exports);
 __exportStar(require("./expressions/expr-aggregate-function"), exports);

package/dist/lang/ast/parameters/has-parameter.d.ts

@@ -1,16 +1,19 @@
-import type { Parameter, CastType } from '../../../model/malloy_types';
+import type { FilterableType } from '@malloydata/malloy-filter';
+import type { Parameter, ParameterType } from '../../../model/malloy_types';
 import type { ConstantExpression } from '../expressions/constant-expression';
 import { MalloyElement } from '../types/malloy-element';
 interface HasInit {
     name: string;
-    type?: CastType;
+    type?: ParameterType;
+    filterType?: FilterableType;
     default?: ConstantExpression;
 }
 export declare class HasParameter extends MalloyElement {
     elementType: string;
     readonly name: string;
-    readonly type?: CastType;
+    readonly type?: ParameterType;
     readonly default?: ConstantExpression;
+    readonly filterType?: FilterableType;
     constructor(init: HasInit);
     parameter(): Parameter;
 }

package/dist/lang/ast/parameters/has-parameter.js

@@ -25,21 +25,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HasParameter = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
 const malloy_element_1 = require("../types/malloy-element");
+const expression_def_1 = require("../types/expression-def");
 class HasParameter extends malloy_element_1.MalloyElement {
     constructor(init) {
         super();
         this.elementType = 'hasParameter';
         this.name = init.name;
-        if (init.type && (0, malloy_types_1.isCastType)(init.type)) {
+        if (init.type && (0, malloy_types_1.isParameterType)(init.type)) {
             this.type = init.type;
         }
         if (init.default) {
             this.default = init.default;
             this.has({ default: this.default });
         }
+        if (init.filterType)
+            this.filterType = init.filterType;
     }
     parameter() {
         var _a;
+        let paramReturn;
         if (this.default !== undefined) {
             const constant = this.default.constantValue();
             if (this.type &&
@@ -65,6 +69,19 @@ class HasParameter extends malloy_element_1.MalloyElement {
                     };
                 }
             }
+            if (constant.type === 'filter expression') {
+                if (this.type !== 'filter expression') {
+                    this.logError('parameter-missing-default-or-type', `Filter expression parameters must have expicit filter type, for example '${this.name}::filter<string>'`);
+                }
+                if (this.filterType) {
+                    (0, expression_def_1.checkFilterExpression)(this, this.filterType, constant.value);
+                }
+                return {
+                    value: constant.value,
+                    name: this.name,
+                    type: constant.type,
+                };
+            }
             if (!(0, malloy_types_1.isCastType)(constant.type) && constant.type !== 'error') {
                 this.default.logError('parameter-illegal-default-type', `Default value cannot have type \`${constant.type}\``);
                 return {
@@ -73,20 +90,22 @@ class HasParameter extends malloy_element_1.MalloyElement {
                     type: 'error',
                 };
             }
-            return {
+            paramReturn = {
                 value: constant.value,
                 name: this.name,
                 type: constant.type,
             };
         }
-        if (this.type === undefined) {
-            this.logError('parameter-missing-default-or-type', 'Parameter must have default value or declared type');
+        else {
+            if (this.type === undefined) {
+                this.logError('parameter-missing-default-or-type', 'Parameter must have default value or declared type');
+            }
+            paramReturn = { value: null, name: this.name, type: (_a = this.type) !== null && _a !== void 0 ? _a : 'error' };
+        }
+        if (paramReturn.type === 'filter expression' && this.filterType) {
+            paramReturn.filterType = this.filterType;
         }
-        return {
-            value: null,
-            name: this.name,
-            type: (_a = this.type) !== null && _a !== void 0 ? _a : 'error',
-        };
+        return paramReturn;
     }
 }
 exports.HasParameter = HasParameter;

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

@@ -1,5 +1,5 @@
 import type { Dialect } from '../../../dialect/dialect';
-import type { Annotation, StructDef, TypeDesc, FieldDef, AtomicFieldDef, FieldDefType } from '../../../model/malloy_types';
+import type { Annotation, StructDef, TypeDesc, FieldDef, AtomicFieldDef } from '../../../model/malloy_types';
 import type { ExprValue } from '../types/expr-value';
 import type { ExpressionDef } from '../types/expression-def';
 import type { FieldName, FieldSpace, QueryFieldSpace } from '../types/field-space';
@@ -87,5 +87,4 @@ export declare class FieldDefinitionValue extends SpaceField {
     private defInQuery?;
     getQueryFieldDef(fs: FieldSpace): AtomicFieldDef;
     typeDesc(): TypeDesc;
-    entryType(): FieldDefType;
 }

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

@@ -316,10 +316,6 @@ class FieldDefinitionValue extends space_field_1.SpaceField {
         }
         throw new Error(`Can't get typeDesc for ${typeFrom.type}`);
     }
-    entryType() {
-        const typeFrom = this.defInQuery || this.fieldDef();
-        return typeFrom.type;
-    }
 }
 exports.FieldDefinitionValue = FieldDefinitionValue;
 //# sourceMappingURL=field-declaration.js.map

package/dist/lang/ast/source-elements/named-source.js

@@ -31,6 +31,7 @@ const time_utils_1 = require("../time-utils");
 const malloy_element_1 = require("../types/malloy-element");
 const expr_id_reference_1 = require("../expressions/expr-id-reference");
 const parameter_space_1 = require("../field-space/parameter-space");
+const expression_def_1 = require("../types/expression-def");
 class NamedSource extends source_1.Source {
     constructor(ref, sourceArguments, args) {
         super();
@@ -140,6 +141,11 @@ class NamedSource extends source_1.Source {
                 const paramSpace = parameterSpace !== null && parameterSpace !== void 0 ? parameterSpace : new parameter_space_1.ParameterSpace(parametersOut !== null && parametersOut !== void 0 ? parametersOut : []);
                 const pVal = argument.value.getExpression(paramSpace);
                 let value = pVal.value;
+                if (pVal.type === 'filter expression' &&
+                    parameter.type === 'filter expression' &&
+                    parameter.filterType) {
+                    (0, expression_def_1.checkFilterExpression)(argument.value, parameter.filterType, value);
+                }
                 if (pVal.type !== parameter.type && (0, malloy_types_1.isCastType)(parameter.type)) {
                     value = (0, time_utils_1.castTo)(parameter.type, pVal.value, pVal.type, true);
                 }

package/dist/lang/ast/source-properties/join.d.ts

@@ -15,7 +15,7 @@ import type { QueryPropertyInterface } from '../types/query-property-interface';
 import { LegalRefinementStage } from '../types/query-property-interface';
 export declare abstract class Join extends MalloyElement implements Noteable, MakeEntry {
     abstract name: ModelEntryReference;
-    abstract structDef(parameterSpace: ParameterSpace): JoinFieldDef;
+    abstract getStructDef(parameterSpace: ParameterSpace): JoinFieldDef;
     abstract fixupJoinOn(outer: FieldSpace, inStruct: JoinFieldDef): void;
     readonly isNoteableObj = true;
     extendNote: typeof extendNoteMethod;
@@ -31,7 +31,7 @@ export declare class KeyJoin extends Join {
     readonly keyExpr: ExpressionDef;
     elementType: string;
     constructor(name: ModelEntryReference, sourceExpr: SourceQueryElement, keyExpr: ExpressionDef);
-    structDef(parameterSpace: ParameterSpace): JoinFieldDef;
+    getStructDef(parameterSpace: ParameterSpace): JoinFieldDef;
     fixupJoinOn(outer: FieldSpace, inStruct: JoinFieldDef): void;
 }
 export declare class ExpressionJoin extends Join {
@@ -45,7 +45,7 @@ export declare class ExpressionJoin extends Join {
     set joinOn(joinExpr: ExpressionDef | undefined);
     get joinOn(): ExpressionDef | undefined;
     fixupJoinOn(outer: FieldSpace, inStruct: JoinFieldDef): void;
-    structDef(parameterSpace: ParameterSpace): JoinFieldDef;
+    getStructDef(parameterSpace: ParameterSpace): JoinFieldDef;
 }
 export declare class JoinStatement extends DefinitionList<Join> implements QueryPropertyInterface {
     readonly accessModifier: AccessModifierLabel | undefined;

package/dist/lang/ast/source-properties/join.js

@@ -60,7 +60,7 @@ class KeyJoin extends Join {
         this.keyExpr = keyExpr;
         this.elementType = 'joinOnKey';
     }
-    structDef(parameterSpace) {
+    getStructDef(parameterSpace) {
         var _a;
         const sourceDef = this.getStructDefFromExpr(parameterSpace);
         if (!(0, malloy_types_1.isJoinable)(sourceDef)) {
@@ -143,7 +143,7 @@ class ExpressionJoin extends Join {
         inStruct.onExpression = exprX.value;
         inStruct.onCompositeFieldUsage = exprX.compositeFieldUsage;
     }
-    structDef(parameterSpace) {
+    getStructDef(parameterSpace) {
         var _a;
         const source = this.sourceExpr.getSource();
         if (!source) {

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

@@ -1,4 +1,4 @@
-import type { TimestampUnit } from '../../../model/malloy_types';
+import type { Expr, TimestampUnit } from '../../../model/malloy_types';
 import type { ExprValue } from './expr-value';
 import type { FieldSpace } from './field-space';
 import { MalloyElement } from './malloy-element';
@@ -83,3 +83,4 @@ export declare function getMorphicValue(mv: ExprValue, mt: MorphicType): ExprVal
  * @return ExprValue of the expression
  */
 export declare function applyBinary(fs: FieldSpace, left: ExpressionDef, op: BinaryMalloyOperator, right: ExpressionDef): ExprValue;
+export declare function checkFilterExpression(logTo: MalloyElement, ft: string, fexpr: Expr): void;

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

@@ -45,7 +45,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyBinary = exports.getMorphicValue = exports.ExprDuration = exports.ExpressionDef = exports.ATNodeType = void 0;
+exports.checkFilterExpression = exports.applyBinary = exports.getMorphicValue = exports.ExprDuration = exports.ExpressionDef = exports.ATNodeType = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
 const TDU = __importStar(require("../typedesc-utils"));
 const ast_utils_1 = require("../ast-utils");
@@ -54,6 +54,7 @@ const time_utils_1 = require("../time-utils");
 const granular_result_1 = require("./granular-result");
 const malloy_element_1 = require("./malloy-element");
 const binary_operators_1 = require("./binary_operators");
+const malloy_filter_1 = require("@malloydata/malloy-filter");
 class TypeMismatch extends Error {
 }
 /** Node types in an alternation tree */
@@ -270,24 +271,54 @@ function equality(fs, left, op, right) {
             }
         }
     }
-    let value = timeCompare(left, lhs, op, rhs) || {
-        node,
-        kids: { left: lhs.value, right: rhs.value },
-    };
-    if (lhs.type !== 'error' &&
-        rhs.type !== 'error' &&
-        (op === '~' || op === '!~')) {
-        if (lhs.type !== 'string' || rhs.type !== 'string') {
-            let regexCmp = regexEqual(lhs, rhs);
-            if (regexCmp) {
-                if (op[0] === '!') {
-                    regexCmp = { node: 'not', e: { ...regexCmp } };
-                }
+    let value;
+    if (rhs.type === 'filter expression') {
+        if (op !== '~' && op !== '!~') {
+            return right.loggedErrorExpr('filter-expression-error', `Cannot use the '${op}' operator with a filter expression`);
+        }
+        if ((0, malloy_filter_1.isFilterable)(lhs.type)) {
+            let actualFilter = rhs.value;
+            while (actualFilter.node === '()') {
+                actualFilter = actualFilter.e;
             }
-            else {
-                throw new TypeMismatch("Incompatible types for match('~') operator");
+            if (actualFilter.node !== 'parameter') {
+                // Parameters are checked when parameter value is parsed
+                checkFilterExpression(right, lhs.type, actualFilter);
+            }
+            const filterMatch = {
+                node: 'filterMatch',
+                dataType: lhs.type,
+                kids: { filterExpr: rhs.value, expr: lhs.value },
+            };
+            if (op === '!~') {
+                filterMatch.notMatch = true;
+            }
+            value = filterMatch;
+        }
+        else {
+            return left.loggedErrorExpr('filter-expression-type', `Cannot use filter expressions with type '${lhs.type}'`);
+        }
+    }
+    else {
+        value = timeCompare(left, lhs, op, rhs) || {
+            node,
+            kids: { left: lhs.value, right: rhs.value },
+        };
+        if (lhs.type !== 'error' &&
+            rhs.type !== 'error' &&
+            (op === '~' || op === '!~')) {
+            if (lhs.type !== 'string' || rhs.type !== 'string') {
+                let regexCmp = regexEqual(lhs, rhs);
+                if (regexCmp) {
+                    if (op[0] === '!') {
+                        regexCmp = { node: 'not', e: { ...regexCmp } };
+                    }
+                }
+                else {
+                    throw new TypeMismatch("Incompatible types for match('~') operator");
+                }
+                value = regexCmp;
             }
-            value = regexCmp;
         }
     }
     return (0, expr_value_1.computedExprValue)({
@@ -452,4 +483,35 @@ function unsupportError(l, lhs, r, rhs) {
     }
     return undefined;
 }
+function checkFilterExpression(logTo, ft, fexpr) {
+    var _a, _b, _c, _d;
+    while (fexpr.node === '()') {
+        fexpr = fexpr.e;
+    }
+    if (fexpr.node !== 'filterLiteral') {
+        logTo.logError('filter-expression-error', 'Expected a filter expression literal here');
+        return;
+    }
+    const fsrc = fexpr.filterSrc;
+    let err;
+    if (ft === 'date' || ft === 'timestamp') {
+        err = (_a = malloy_filter_1.TemporalFilterExpression.parse(fsrc).log[0]) === null || _a === void 0 ? void 0 : _a.message;
+    }
+    else if (ft === 'string') {
+        err = (_b = malloy_filter_1.StringFilterExpression.parse(fsrc).log[0]) === null || _b === void 0 ? void 0 : _b.message;
+    }
+    else if (ft === 'number') {
+        err = (_c = malloy_filter_1.NumberFilterExpression.parse(fsrc).log[0]) === null || _c === void 0 ? void 0 : _c.message;
+    }
+    else if (ft === 'boolean') {
+        err = (_d = malloy_filter_1.BooleanFilterExpression.parse(fsrc).log[0]) === null || _d === void 0 ? void 0 : _d.message;
+    }
+    else {
+        logTo.logError('filter-expression-type', `Cannot apply filter expression to type ${ft}`);
+    }
+    if (err !== undefined) {
+        logTo.logError('filter-expression-error', `Filter syntax error: ${err}`);
+    }
+}
+exports.checkFilterExpression = checkFilterExpression;
 //# sourceMappingURL=expression-def.js.map

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

@@ -1,4 +1,4 @@
-import type { FieldDefType, Parameter, TypeDesc } from '../../../model/malloy_types';
+import { type Parameter, type TypeDesc } from '../../../model/malloy_types';
 import { SpaceEntry } from './space-entry';
 import type { HasParameter } from '../parameters/has-parameter';
 export declare abstract class SpaceParam extends SpaceEntry {
@@ -11,12 +11,10 @@ export declare class AbstractParameter extends SpaceParam {
     _parameter: Parameter | undefined;
     parameter(): Parameter;
     typeDesc(): TypeDesc;
-    entryType(): FieldDefType;
 }
 export declare class DefinedParameter extends SpaceParam {
     readonly paramDef: Parameter;
     constructor(paramDef: Parameter);
     parameter(): Parameter;
     typeDesc(): TypeDesc;
-    entryType(): FieldDefType;
 }

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

@@ -69,16 +69,16 @@ class AbstractParameter extends SpaceParam {
         return this._parameter;
     }
     typeDesc() {
+        const p = this.parameter();
+        const t = p.type;
+        const theType = t === 'filter expression' ? { type: t } : TDU.atomicDef(p);
         return {
-            ...TDU.atomicDef(this.parameter()),
+            ...theType,
             expressionType: 'scalar',
             evalSpace: 'constant',
             compositeFieldUsage: (0, composite_source_utils_1.emptyCompositeFieldUsage)(),
         };
     }
-    entryType() {
-        return this.parameter().type;
-    }
 }
 exports.AbstractParameter = AbstractParameter;
 class DefinedParameter extends SpaceParam {
@@ -90,8 +90,11 @@ class DefinedParameter extends SpaceParam {
         return this.paramDef;
     }
     typeDesc() {
+        const p = this.parameter();
+        const t = p.type;
+        const theType = t === 'filter expression' ? { type: t } : TDU.atomicDef(p);
         return {
-            ...TDU.atomicDef(this.paramDef),
+            ...theType,
             expressionType: 'scalar',
             // TODO Not sure whether params are considered "input space". It seems like they
             // could be input or constant, depending on usage (same as above).
@@ -99,9 +102,6 @@ class DefinedParameter extends SpaceParam {
             compositeFieldUsage: (0, composite_source_utils_1.emptyCompositeFieldUsage)(),
         };
     }
-    entryType() {
-        return this.paramDef.type;
-    }
 }
 exports.DefinedParameter = DefinedParameter;
 //# sourceMappingURL=space-param.js.map