@malloydata/malloy 0.0.157 → 0.0.158-dev240805161224

package/dist/lang/ast/expressions/constant-expression.d.ts

@@ -0,0 +1,28 @@
+import { AtomicFieldType, StructDef } from '../../../model/malloy_types';
+import { ExprValue } from '../types/expr-value';
+import { ExpressionDef } from '../types/expression-def';
+import { FieldSpace, QueryFieldSpace } from '../types/field-space';
+import { LookupResult } from '../types/lookup-result';
+import { SpaceEntry } from '../types/space-entry';
+export declare class ConstantFieldSpace implements FieldSpace {
+    readonly type = "fieldSpace";
+    structDef(): StructDef;
+    emptyStructDef(): StructDef;
+    lookup(_name: unknown): LookupResult;
+    entries(): [string, SpaceEntry][];
+    entry(): undefined;
+    dialectObj(): undefined;
+    isQueryFieldSpace(): this is QueryFieldSpace;
+}
+export declare class ConstantExpression extends ExpressionDef {
+    readonly expr: ExpressionDef;
+    elementType: string;
+    private cfs?;
+    constructor(expr: ExpressionDef);
+    getExpression(_fs: FieldSpace): ExprValue;
+    private get constantFs();
+    constantValue(): ExprValue;
+    constantCondition(type: AtomicFieldType): ExprValue;
+    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+    requestExpression(fs: FieldSpace): ExprValue | undefined;
+}

package/dist/lang/ast/expressions/{constant-sub-expression.js → constant-expression.js}

@@ -22,7 +22,7 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConstantSubExpression = void 0;
+exports.ConstantExpression = exports.ConstantFieldSpace = void 0;
 const comparison_1 = require("../types/comparison");
 const expression_def_1 = require("../types/expression-def");
 const expr_compare_1 = require("./expr-compare");
@@ -39,7 +39,7 @@ class ConstantFieldSpace {
     }
     lookup(_name) {
         return {
-            error: 'Only constants allowed in parameter expressions',
+            error: 'Only constants allowed in parameter default values',
             found: undefined,
         };
     }
@@ -56,6 +56,7 @@ class ConstantFieldSpace {
         return false;
     }
 }
+exports.ConstantFieldSpace = ConstantFieldSpace;
 class DollarReference extends expression_def_1.ExpressionDef {
     constructor(refType) {
         super();
@@ -71,7 +72,7 @@ class DollarReference extends expression_def_1.ExpressionDef {
         };
     }
 }
-class ConstantSubExpression extends expression_def_1.ExpressionDef {
+class ConstantExpression extends expression_def_1.ExpressionDef {
     constructor(expr) {
         super({ expr: expr });
         this.expr = expr;
@@ -101,5 +102,5 @@ class ConstantSubExpression extends expression_def_1.ExpressionDef {
         return this.expr.requestExpression(fs);
     }
 }
-exports.ConstantSubExpression = ConstantSubExpression;
-//# sourceMappingURL=constant-sub-expression.js.map
+exports.ConstantExpression = ConstantExpression;
+//# sourceMappingURL=constant-expression.js.map

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

@@ -27,6 +27,7 @@ const malloy_types_1 = require("../../../model/malloy_types");
 const ast_utils_1 = require("../ast-utils");
 const struct_space_field_base_1 = require("../field-space/struct-space-field-base");
 const expression_def_1 = require("../types/expression-def");
+const field_space_1 = require("../types/field-space");
 const utils_1 = require("./utils");
 class ExprFunc extends expression_def_1.ExpressionDef {
     constructor(name, args, isRaw, rawType, source) {
@@ -245,7 +246,9 @@ class ExprFunc extends expression_def_1.ExpressionDef {
             'sql_boolean',
         ].includes(func.name)) {
             if (!this.inExperiment('sql_functions', true)) {
-                return (0, ast_utils_1.errorFor)(`Cannot use sql_function \`${func.name}\`; use \`sql_functions\` experiment to enable this behavior`);
+                const message = `Cannot use sql_function \`${func.name}\`; use \`sql_functions\` experiment to enable this behavior`;
+                this.log(message);
+                return (0, ast_utils_1.errorFor)('sql_function used without enabling');
             }
             const str = argExprs[0].value;
             if (str.length !== 1 ||
@@ -269,16 +272,31 @@ class ExprFunc extends expression_def_1.ExpressionDef {
                     this.log(unsupportedInterpolationMsg);
                     return (0, ast_utils_1.errorFor)(`${unsupportedInterpolationMsg}. See LookML \${...} documentation at https://cloud.google.com/looker/docs/reference/param-field-sql#sql_for_dimensions`);
                 }
-                funcCall = [
-                    {
-                        type: 'sql-string',
-                        e: parts.map(part => part.type === 'string'
-                            ? part.value
-                            : part.name === 'TABLE'
-                                ? { type: 'source-reference' }
-                                : { type: 'field', path: [part.name] }),
-                    },
-                ];
+                const expr = [];
+                for (const part of parts) {
+                    if (part.type === 'string') {
+                        expr.push(part.value);
+                    }
+                    else if (part.name === 'TABLE') {
+                        expr.push({ type: 'source-reference' });
+                    }
+                    else {
+                        const name = new field_space_1.FieldName(part.name);
+                        this.has({ name });
+                        const result = fs.lookup([name]);
+                        if (result.found === undefined) {
+                            this.log(`Invalid interpolation: ${result.error}`);
+                            return (0, ast_utils_1.errorFor)('invalid interpolated field');
+                        }
+                        if (result.found.refType === 'parameter') {
+                            expr.push({ type: 'parameter', path: [part.name] });
+                        }
+                        else {
+                            expr.push({ type: 'field', path: [part.name] });
+                        }
+                    }
+                }
+                funcCall = [{ type: 'sql-string', e: expr }];
             }
         }
         if (type.dataType === 'any') {

package/dist/lang/ast/expressions/expr-id-reference.d.ts

@@ -8,5 +8,4 @@ export declare class ExprIdReference extends ExpressionDef {
     constructor(fieldReference: FieldReference);
     get refString(): string;
     getExpression(fs: FieldSpace): ExprValue;
-    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
 }

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

@@ -25,7 +25,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprIdReference = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
 const ast_utils_1 = require("../ast-utils");
-const space_param_1 = require("../types/space-param");
 const expression_def_1 = require("../types/expression-def");
 class ExprIdReference extends expression_def_1.ExpressionDef {
     constructor(fieldReference) {
@@ -58,29 +57,6 @@ class ExprIdReference extends expression_def_1.ExpressionDef {
         this.log(def.error);
         return (0, ast_utils_1.errorFor)(def.error);
     }
-    apply(fs, op, expr) {
-        const entry = this.fieldReference.getField(fs).found;
-        if (entry instanceof space_param_1.SpaceParam) {
-            const cParam = entry.parameter();
-            if ((0, malloy_types_1.isConditionParameter)(cParam)) {
-                const lval = expr.getExpression(fs);
-                return {
-                    dataType: 'boolean',
-                    expressionType: lval.expressionType,
-                    // TODO not sure about the input-ness of parameters
-                    evalSpace: (0, malloy_types_1.mergeEvalSpaces)(lval.evalSpace, 'input'),
-                    value: [
-                        {
-                            type: 'apply',
-                            value: lval.value,
-                            to: [{ type: 'parameter', path: this.fieldReference.path }],
-                        },
-                    ],
-                };
-            }
-        }
-        return super.apply(fs, op, expr);
-    }
 }
 exports.ExprIdReference = ExprIdReference;
 //# sourceMappingURL=expr-id-reference.js.map

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

@@ -4,16 +4,19 @@ import { HasParameter } from '../parameters/has-parameter';
 import { MalloyElement } from '../types/malloy-element';
 import { SourceSpec, SpaceSeed } from '../space-seed';
 import { StaticSpace } from './static-space';
+import { ParameterSpace } from './parameter-space';
 export declare abstract class DynamicSpace extends StaticSpace {
     protected final: model.StructDef | undefined;
     protected source: SpaceSeed;
     completions: (() => void)[];
     private complete;
+    private parameters;
     protected newTimezone?: string;
     constructor(extending: SourceSpec);
     isComplete(): void;
     protected setEntry(name: string, value: SpaceEntry): void;
-    addParameters(params: HasParameter[]): DynamicSpace;
+    addParameters(parameters: HasParameter[]): DynamicSpace;
+    parameterSpace(): ParameterSpace;
     newEntry(name: string, logTo: MalloyElement, entry: SpaceEntry): void;
     renameEntry(oldName: string, newName: string, entry: SpaceEntry): void;
     addFieldDef(fd: model.FieldDef): void;

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

@@ -32,12 +32,14 @@ const space_param_1 = require("../types/space-param");
 const space_seed_1 = require("../space-seed");
 const static_space_1 = require("./static-space");
 const struct_space_field_base_1 = require("./struct-space-field-base");
+const parameter_space_1 = require("./parameter-space");
 class DynamicSpace extends static_space_1.StaticSpace {
     constructor(extending) {
         const source = new space_seed_1.SpaceSeed(extending);
         super(structuredClone(source.structDef));
         this.completions = [];
         this.complete = false;
+        this.parameters = [];
         this.final = undefined;
         this.source = source;
     }
@@ -50,12 +52,18 @@ class DynamicSpace extends static_space_1.StaticSpace {
         }
         super.setEntry(name, value);
     }
-    addParameters(params) {
-        for (const oneP of params) {
-            this.setEntry(oneP.name, new space_param_1.AbstractParameter(oneP));
+    addParameters(parameters) {
+        for (const parameter of parameters) {
+            if (this.entry(parameter.name) === undefined) {
+                this.parameters.push(parameter);
+                this.setEntry(parameter.name, new space_param_1.AbstractParameter(parameter));
+            }
         }
         return this;
     }
+    parameterSpace() {
+        return new parameter_space_1.ParameterSpace(this.parameters);
+    }
     newEntry(name, logTo, entry) {
         if (this.entry(name)) {
             logTo.log(`Cannot redefine '${name}'`);
@@ -74,11 +82,19 @@ class DynamicSpace extends static_space_1.StaticSpace {
         this.newTimezone = tz;
     }
     structDef() {
-        const parameters = this.fromStruct.parameters || {};
         if (this.final === 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 = {};
+            for (const [name, entry] of this.entries()) {
+                if (entry instanceof space_param_1.SpaceParam) {
+                    parameters[name] = entry.parameter();
+                }
+            }
             this.final = {
                 ...this.fromStruct,
                 fields: [],
+                parameters,
             };
             // Need to process the entities in specific order
             const fields = [];
@@ -95,14 +111,12 @@ class DynamicSpace extends static_space_1.StaticSpace {
                 else if (spaceEntry instanceof space_field_1.SpaceField) {
                     fields.push([name, spaceEntry]);
                 }
-                else if (spaceEntry instanceof space_param_1.SpaceParam) {
-                    parameters[name] = spaceEntry.parameter();
-                }
             }
             const reorderFields = [...fields, ...joins, ...turtles];
+            const parameterSpace = this.parameterSpace();
             for (const [, field] of reorderFields) {
                 if (field instanceof join_space_field_1.JoinSpaceField) {
-                    const joinStruct = field.join.structDef();
+                    const joinStruct = field.join.structDef(parameterSpace);
                     if (!error_factory_1.ErrorFactory.isErrorStructDef(joinStruct)) {
                         this.final.fields.push(joinStruct);
                         fixupJoins.push([field.join, joinStruct]);
@@ -120,9 +134,6 @@ class DynamicSpace extends static_space_1.StaticSpace {
                     // }
                 }
             }
-            if (Object.entries(parameters).length > 0) {
-                this.final.parameters = parameters;
-            }
             // If we have join expressions, we need to now go back and fill them in
             for (const [join, missingOn] of fixupJoins) {
                 join.fixupJoinOn(this, missingOn);

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

@@ -107,6 +107,9 @@ class IndexFieldSpace extends query_spaces_1.QueryOperationSpace {
             if (wild.except.has(name)) {
                 continue;
             }
+            if (entry.refType === 'parameter') {
+                continue;
+            }
             const indexName = field_references_1.IndexFieldReference.indexOutputName([
                 ...joinPath,
                 name,

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

@@ -1,6 +1,8 @@
 import { Join } from '../source-properties/joins';
+import { ParameterSpace } from './parameter-space';
 import { StructSpaceField } from './static-space';
 export declare class JoinSpaceField extends StructSpaceField {
+    readonly parameterSpace: ParameterSpace;
     readonly join: Join;
-    constructor(join: Join);
+    constructor(parameterSpace: ParameterSpace, join: Join);
 }

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

@@ -25,8 +25,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.JoinSpaceField = void 0;
 const static_space_1 = require("./static-space");
 class JoinSpaceField extends static_space_1.StructSpaceField {
-    constructor(join) {
-        super(join.structDef());
+    constructor(parameterSpace, join) {
+        super(join.structDef(parameterSpace));
+        this.parameterSpace = parameterSpace;
         this.join = join;
     }
 }

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

@@ -0,0 +1,18 @@
+import { Dialect } from '../../../dialect';
+import { StructDef } from '../../../model';
+import { HasParameter } from '../parameters/has-parameter';
+import { FieldName, FieldSpace, QueryFieldSpace } from '../types/field-space';
+import { LookupResult } from '../types/lookup-result';
+import { SpaceEntry } from '../types/space-entry';
+export declare class ParameterSpace implements FieldSpace {
+    readonly type = "fieldSpace";
+    private readonly _map;
+    constructor(parameters: HasParameter[]);
+    structDef(): StructDef;
+    emptyStructDef(): StructDef;
+    entry(name: string): SpaceEntry | undefined;
+    lookup(symbol: FieldName[]): LookupResult;
+    entries(): [string, SpaceEntry][];
+    dialectObj(): Dialect | undefined;
+    isQueryFieldSpace(): this is QueryFieldSpace;
+}

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

@@ -0,0 +1,67 @@
+"use strict";
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParameterSpace = void 0;
+const space_param_1 = require("../types/space-param");
+class ParameterSpace {
+    constructor(parameters) {
+        this.type = 'fieldSpace';
+        this._map = {};
+        for (const parameter of parameters) {
+            this._map[parameter.name] = new space_param_1.AbstractParameter(parameter);
+        }
+    }
+    structDef() {
+        throw new Error('Parameter space does not have a structDef');
+    }
+    emptyStructDef() {
+        throw new Error('Parameter space does not have an emptyStructDef');
+    }
+    entry(name) {
+        return this._map[name];
+    }
+    lookup(symbol) {
+        const name = symbol[0];
+        if (name === undefined) {
+            return {
+                error: 'Invalid reference',
+                found: undefined,
+            };
+        }
+        const entry = this.entry(name.refString);
+        if (entry === undefined) {
+            return {
+                error: `\`${name}\` is not defined`,
+                found: undefined,
+            };
+        }
+        if (symbol.length > 1) {
+            return {
+                error: `\`${name}\` cannot contain a \`${symbol.slice(1).join('.')}\``,
+                found: undefined,
+            };
+        }
+        return {
+            found: entry,
+            error: undefined,
+            relationship: [],
+            isOutputField: false,
+        };
+    }
+    entries() {
+        return Object.entries(this._map);
+    }
+    dialectObj() {
+        return undefined;
+    }
+    isQueryFieldSpace() {
+        return false;
+    }
+}
+exports.ParameterSpace = ParameterSpace;
+//# sourceMappingURL=parameter-space.js.map

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

@@ -114,6 +114,9 @@ class QueryOperationSpace extends refined_space_1.RefinedSpace {
             if (wild.except.has(name)) {
                 continue;
             }
+            if (entry.refType === 'parameter') {
+                continue;
+            }
             if (this.entry(name)) {
                 const conflict = (_a = this.expandedWild[name]) === null || _a === void 0 ? void 0 : _a.join('.');
                 wild.log(`Cannot expand '${name}' in '${wild.refString}' because a field with that name already exists${conflict ? ` (conflicts with ${conflict})` : ''}`);

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

@@ -39,15 +39,24 @@ class ReferenceField extends space_field_1.SpaceField {
         return this.memoReference;
     }
     getQueryFieldDef(fs) {
+        var _a;
         if (!this.queryFieldDef) {
             const check = this.fieldRef.getField(fs);
             if (check.error) {
                 this.fieldRef.log(check.error);
             }
-            this.queryFieldDef = {
-                type: 'fieldref',
-                path: this.fieldRef.list.map(f => f.name),
-            };
+            // TODO investigate removing 'fieldref' as a type, as it obscures the
+            //      actual type of the field and is redundant with the slightly
+            //      more verbose `{ e: [{ type: 'field', path }] }`
+            const path = this.fieldRef.list.map(f => f.name);
+            const queryFieldDef = ((_a = check.found) === null || _a === void 0 ? void 0 : _a.refType) === 'parameter'
+                ? {
+                    type: check.found.typeDesc().dataType,
+                    name: path[0],
+                    e: [{ type: 'parameter', path }],
+                }
+                : { type: 'fieldref', path };
+            this.queryFieldDef = queryFieldDef;
             const refTo = this.referenceTo;
             if (refTo instanceof space_field_1.SpaceField && refTo.haveFieldDef) {
                 const origFd = refTo.haveFieldDef;

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

@@ -2,12 +2,13 @@ import { StructDef } from '../../../model/malloy_types';
 import { FieldListEdit } from '../source-properties/field-list-edit';
 import { DynamicSpace } from './dynamic-space';
 import { MalloyElement } from '../types/malloy-element';
+import { ParameterSpace } from './parameter-space';
 export declare class RefinedSpace extends DynamicSpace {
     /**
      * Factory for FieldSpace when there are accept/except edits
      * @param from A structdef which seeds this space
      * @param choose A accept/except edit of the "from" fields
      */
-    static filteredFrom(from: StructDef, choose?: FieldListEdit): RefinedSpace;
+    static filteredFrom(from: StructDef, choose: FieldListEdit | undefined, parameters: ParameterSpace | undefined): RefinedSpace;
     pushFields(...defs: MalloyElement[]): void;
 }

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

@@ -31,11 +31,22 @@ class RefinedSpace extends dynamic_space_1.DynamicSpace {
      * @param from A structdef which seeds this space
      * @param choose A accept/except edit of the "from" fields
      */
-    static filteredFrom(from, choose) {
+    static filteredFrom(from, choose, parameters) {
         const edited = new RefinedSpace(from);
         if (choose) {
             const names = choose.refs.list;
             const oldMap = edited.entries();
+            for (const name of names) {
+                const existing = oldMap.find(([symb]) => symb === name.refString);
+                if (existing === undefined) {
+                    if (parameters === null || parameters === void 0 ? void 0 : parameters.entry(name.refString)) {
+                        name.log(`Illegal \`${choose.edit}:\` of parameter`);
+                    }
+                    else {
+                        name.log(`\`${name.refString}\` is not defined`);
+                    }
+                }
+            }
             edited.dropEntries();
             for (const [symbol, value] of oldMap) {
                 const included = !!names.find(f => f.refString === symbol);

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

@@ -61,11 +61,9 @@ class StaticSpace {
             }
             if (this.fromStruct.parameters) {
                 for (const [paramName, paramDef] of Object.entries(this.fromStruct.parameters)) {
-                    if (this.memoMap[paramName]) {
-                        throw new Error(`In struct '${this.fromStruct.as || this.fromStruct.name}': ` +
-                            ` : Field and parameter name conflict '${paramName}`);
+                    if (!(paramName in this.memoMap)) {
+                        this.memoMap[paramName] = new space_param_1.DefinedParameter(paramDef);
                     }
-                    this.memoMap[paramName] = new space_param_1.DefinedParameter(paramDef);
                 }
             }
         }
@@ -91,7 +89,7 @@ class StaticSpace {
         return this.fromStruct;
     }
     emptyStructDef() {
-        return { ...this.fromStruct, fields: [] };
+        return { ...this.fromStruct, fields: [], parameters: {} };
     }
     lookup(path) {
         const head = path[0];

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

@@ -59,6 +59,7 @@ export * from './expressions/unary';
 export * from './expressions/utils';
 export * from './statements/import-statement';
 export * from './query-properties/extend';
+export * from './parameters/argument';
 export * from './parameters/has-parameter';
 export * from './query-elements/anonymous-query';
 export * from './query-elements/query-refine';

package/dist/lang/ast/index.js

@@ -97,6 +97,7 @@ __exportStar(require("./expressions/unary"), exports);
 __exportStar(require("./expressions/utils"), exports);
 __exportStar(require("./statements/import-statement"), exports);
 __exportStar(require("./query-properties/extend"), exports);
+__exportStar(require("./parameters/argument"), exports);
 __exportStar(require("./parameters/has-parameter"), exports);
 __exportStar(require("./query-elements/anonymous-query"), exports);
 __exportStar(require("./query-elements/query-refine"), exports);

package/dist/lang/ast/parameters/argument.d.ts

@@ -0,0 +1,14 @@
+import { ParameterFieldReference } from '../query-items/field-references';
+import { ExpressionDef } from '../types/expression-def';
+import { MalloyElement } from '../types/malloy-element';
+interface ArgInit {
+    id?: ParameterFieldReference | undefined;
+    value: ExpressionDef;
+}
+export declare class Argument extends MalloyElement {
+    elementType: string;
+    readonly id: ParameterFieldReference | undefined;
+    readonly value: ExpressionDef;
+    constructor(init: ArgInit);
+}
+export {};

package/dist/lang/ast/parameters/argument.js

@@ -0,0 +1,20 @@
+"use strict";
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Argument = void 0;
+const malloy_element_1 = require("../types/malloy-element");
+class Argument extends malloy_element_1.MalloyElement {
+    constructor(init) {
+        super({ ...init });
+        this.elementType = 'Argument';
+        this.id = init.id;
+        this.value = init.value;
+    }
+}
+exports.Argument = Argument;
+//# sourceMappingURL=argument.js.map

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

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

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

@@ -30,7 +30,6 @@ class HasParameter extends malloy_element_1.MalloyElement {
         super();
         this.elementType = 'hasParameter';
         this.name = init.name;
-        this.isCondition = init.isCondition;
         if (init.type && (0, malloy_types_1.isCastType)(init.type)) {
             this.type = init.type;
         }
@@ -40,23 +39,35 @@ class HasParameter extends malloy_element_1.MalloyElement {
         }
     }
     parameter() {
-        var _a, _b;
-        const name = this.name;
-        const type = this.type || 'string';
-        if (this.isCondition) {
-            const cCond = ((_a = this.default) === null || _a === void 0 ? void 0 : _a.constantCondition(type).value) || null;
+        var _a;
+        if (this.default !== undefined) {
+            const constant = this.default.constantValue();
+            if (this.type &&
+                this.type !== constant.dataType &&
+                constant.dataType !== 'error') {
+                this.default.log(`Default value for parameter does not match declared type \`${this.type}\``);
+            }
+            if (!(0, malloy_types_1.isCastType)(constant.dataType) && constant.dataType !== 'error') {
+                this.default.log(`Default value cannot have type \`${constant.dataType}\``);
+                return {
+                    value: constant.value,
+                    name: this.name,
+                    type: 'error',
+                };
+            }
             return {
-                type,
-                name,
-                condition: cCond,
+                value: constant.value,
+                name: this.name,
+                type: constant.dataType,
             };
         }
-        const cVal = ((_b = this.default) === null || _b === void 0 ? void 0 : _b.constantValue().value) || null;
+        if (this.type === undefined) {
+            this.log('Parameter must have default value or declared type');
+        }
         return {
-            value: cVal,
-            type,
+            value: null,
             name: this.name,
-            constant: false,
+            type: (_a = this.type) !== null && _a !== void 0 ? _a : 'error',
         };
     }
 }