@malloydata/malloy 0.0.157 → 0.0.158-dev240805161224

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

@@ -38,15 +38,15 @@ class Join extends malloy_element_1.MalloyElement {
         this.extendNote = noteable_1.extendNoteMethod;
     }
     makeEntry(fs) {
-        fs.newEntry(this.name.refString, this, new join_space_field_1.JoinSpaceField(this));
+        fs.newEntry(this.name.refString, this, new join_space_field_1.JoinSpaceField(fs.parameterSpace(), this));
     }
-    getStructDefFromExpr() {
+    getStructDefFromExpr(parameterSpace) {
         const source = this.sourceExpr.getSource();
         if (!source) {
             this.sourceExpr.sqLog('Cannot great a source to join from');
             return error_factory_1.ErrorFactory.structDef;
         }
-        return source.structDef();
+        return source.structDef(parameterSpace);
     }
 }
 exports.Join = Join;
@@ -58,9 +58,9 @@ class KeyJoin extends Join {
         this.keyExpr = keyExpr;
         this.elementType = 'joinOnKey';
     }
-    structDef() {
+    structDef(parameterSpace) {
         var _a;
-        const sourceDef = this.getStructDefFromExpr();
+        const sourceDef = this.getStructDefFromExpr(parameterSpace);
         const joinStruct = {
             ...sourceDef,
             structRelationship: {
@@ -147,14 +147,14 @@ class ExpressionJoin extends Join {
             joinRel.onExpression = (0, utils_1.compressExpr)(exprX.value);
         }
     }
-    structDef() {
+    structDef(parameterSpace) {
         var _a;
         const source = this.sourceExpr.getSource();
         if (!source) {
             this.sourceExpr.sqLog('Cannot create a source to join from');
             return error_factory_1.ErrorFactory.structDef;
         }
-        const sourceDef = source.structDef();
+        const sourceDef = source.structDef(parameterSpace);
         let matrixOperation = 'left';
         if (this.inExperiment('join_types', true)) {
             matrixOperation = this.matrixOperation;

package/dist/lang/ast/source-query-elements/sq-reference.d.ts

@@ -2,6 +2,7 @@ import { ModelEntryReference } from '../types/malloy-element';
 import { Source } from '../source-elements/source';
 import { SourceQueryElement } from './source-query-element';
 import { QueryElement } from '../types/query-element';
+import { Argument } from '../parameters/argument';
 /**
  * A reference to either a source or a query.
  *
@@ -9,9 +10,10 @@ import { QueryElement } from '../types/query-element';
  */
 export declare class SQReference extends SourceQueryElement {
     readonly ref: ModelEntryReference;
+    readonly args?: Argument[] | undefined;
     elementType: string;
     asSource?: Source;
-    constructor(ref: ModelEntryReference);
+    constructor(ref: ModelEntryReference, args?: Argument[] | undefined);
     getQuery(): QueryElement | undefined;
     isSource(): boolean;
     getSource(): Source | undefined;

package/dist/lang/ast/source-query-elements/sq-reference.js

@@ -33,10 +33,14 @@ const query_reference_1 = require("../query-elements/query-reference");
  * e.g. `flights`
  */
 class SQReference extends source_query_element_1.SourceQueryElement {
-    constructor(ref) {
+    constructor(ref, args) {
         super({ ref });
         this.ref = ref;
+        this.args = args;
         this.elementType = 'sq-reference';
+        if (args !== undefined) {
+            this.has({ args });
+        }
     }
     getQuery() {
         const entry = this.ref.getNamed();
@@ -71,11 +75,14 @@ class SQReference extends source_query_element_1.SourceQueryElement {
             return;
         }
         if (entry.type === 'query') {
+            if (this.args !== undefined) {
+                this.ref.log('Arguments cannot be passed to queries');
+            }
             const existingQuery = new query_reference_1.QueryReference(this.ref);
             this.asSource = new query_source_1.QuerySource(existingQuery);
         }
         else if (entry.type === 'struct') {
-            this.asSource = new named_source_1.NamedSource(this.ref);
+            this.asSource = new named_source_1.NamedSource(this.ref, undefined, this.args);
         }
         else {
             this.sqLog(`Expected '${this.ref.refString}' to be of type query or source, not '${entry.type}'`);

package/dist/lang/ast/statements/define-source.d.ts

@@ -7,13 +7,15 @@ export declare class DefineSource extends MalloyElement implements DocStatement,
     readonly name: string;
     readonly sourceExpr: SourceQueryElement | undefined;
     readonly exported: boolean;
+    readonly parameters?: HasParameter[] | undefined;
     elementType: string;
-    readonly parameters?: HasParameter[];
-    constructor(name: string, sourceExpr: SourceQueryElement | undefined, exported: boolean, params?: MalloyElement[]);
+    constructor(name: string, sourceExpr: SourceQueryElement | undefined, exported: boolean, parameters?: HasParameter[] | undefined);
     readonly isNoteableObj = true;
     extendNote: typeof extendNoteMethod;
     note?: Annotation;
     execute(doc: Document): void;
+    private deduplicatedParameters;
+    private validateParameterShadowing;
 }
 export declare class DefineSourceList extends DocStatementList {
     elementType: string;

package/dist/lang/ast/statements/define-source.js

@@ -24,32 +24,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefineSourceList = exports.DefineSource = void 0;
 const error_factory_1 = require("../error-factory");
-const has_parameter_1 = require("../parameters/has-parameter");
 const malloy_element_1 = require("../types/malloy-element");
 const noteable_1 = require("../types/noteable");
 class DefineSource extends malloy_element_1.MalloyElement {
-    constructor(name, sourceExpr, exported, params) {
+    constructor(name, sourceExpr, exported, parameters) {
         super();
         this.name = name;
         this.sourceExpr = sourceExpr;
         this.exported = exported;
+        this.parameters = parameters;
         this.elementType = 'defineSource';
         this.isNoteableObj = true;
         this.extendNote = noteable_1.extendNoteMethod;
         if (sourceExpr) {
             this.has({ sourceExpr });
         }
-        if (params) {
-            this.parameters = [];
-            for (const el of params) {
-                if (el instanceof has_parameter_1.HasParameter) {
-                    this.parameters.push(el);
-                }
-                else {
-                    this.log(`Unexpected element type in define statement: ${el.elementType}`);
-                }
-            }
-            this.has({ parameters: this.parameters });
+        if (parameters) {
+            this.has({ parameters });
         }
     }
     execute(doc) {
@@ -62,7 +53,9 @@ class DefineSource extends malloy_element_1.MalloyElement {
             if (theSource === undefined) {
                 return;
             }
-            const structDef = theSource.withParameters(this.parameters);
+            const parameters = this.deduplicatedParameters();
+            const structDef = theSource.withParameters(undefined, this.parameters);
+            this.validateParameterShadowing(parameters, structDef);
             if (error_factory_1.ErrorFactory.isErrorStructDef(structDef)) {
                 return;
             }
@@ -79,6 +72,27 @@ class DefineSource extends malloy_element_1.MalloyElement {
             doc.setEntry(this.name, { entry, exported: this.exported });
         }
     }
+    deduplicatedParameters() {
+        if (this.parameters === undefined)
+            return [];
+        const exists = {};
+        const out = [];
+        for (const parameter of this.parameters) {
+            if (parameter.name in exists) {
+                parameter.log(`Cannot redefine parameter \`${parameter.name}\``);
+            }
+            exists[parameter.name] = true;
+            out.push(parameter);
+        }
+        return out;
+    }
+    validateParameterShadowing(parameters, structDef) {
+        for (const parameter of parameters) {
+            if (structDef.fields.find(field => { var _a; return ((_a = field.as) !== null && _a !== void 0 ? _a : field.name) === parameter.name; })) {
+                parameter.log(`Illegal shadowing of field \`${parameter.name}\` by parameter with the same name`);
+            }
+        }
+    }
 }
 exports.DefineSource = DefineSource;
 class DefineSourceList extends malloy_element_1.DocStatementList {

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

@@ -28,13 +28,14 @@ const malloy_query_1 = require("../../model/malloy_query");
 const malloy_types_1 = require("../../model/malloy_types");
 const error_factory_1 = require("./error-factory");
 function opOutputStruct(logTo, inputStruct, opDesc) {
-    const badModel = error_factory_1.ErrorFactory.isErrorStructDef(inputStruct);
+    const badModel = error_factory_1.ErrorFactory.isErrorStructDef(inputStruct) || (0, malloy_types_1.structHasErrors)(inputStruct);
     // We don't want to expose partial segments to the compiler
     if ((0, malloy_types_1.isPartialSegment)(opDesc)) {
         opDesc = { ...opDesc, type: 'reduce' };
     }
+    const badOpDesc = (0, malloy_types_1.segmentHasErrors)(opDesc);
     // Don't call into the model code with a broken model
-    if (!badModel) {
+    if (!badModel && !badOpDesc) {
         try {
             return malloy_query_1.Segment.nextStructDef(inputStruct, opDesc);
         }

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

@@ -348,6 +348,8 @@ function numeric(fs, left, op, right) {
             evalSpace: (0, malloy_types_1.mergeEvalSpaces)(lhs.evalSpace, rhs.evalSpace),
         };
     }
+    // TODO make the error location be the operand that is not a number, rather than
+    // always the first operand
     left.log(`Non numeric('${lhs.dataType},${rhs.dataType}') value with '${op}'`);
     return (0, ast_utils_1.errorFor)('numbers required');
 }

package/dist/lang/lib/Malloy/MalloyParser.d.ts

@@ -192,104 +192,109 @@ export declare class MalloyParser extends Parser {
     static readonly RULE_sourcePropertyList = 27;
     static readonly RULE_sourceDefinition = 28;
     static readonly RULE_sqExplore = 29;
-    static readonly RULE_sourceNameDef = 30;
-    static readonly RULE_sourceID = 31;
-    static readonly RULE_exploreProperties = 32;
-    static readonly RULE_exploreStatement = 33;
-    static readonly RULE_defMeasures = 34;
-    static readonly RULE_defDimensions = 35;
-    static readonly RULE_renameList = 36;
-    static readonly RULE_exploreRenameDef = 37;
-    static readonly RULE_defList = 38;
-    static readonly RULE_fieldDef = 39;
-    static readonly RULE_fieldNameDef = 40;
-    static readonly RULE_joinNameDef = 41;
-    static readonly RULE_declareStatement = 42;
-    static readonly RULE_joinStatement = 43;
-    static readonly RULE_queryExtend = 44;
-    static readonly RULE_modEither = 45;
-    static readonly RULE_sqExpr = 46;
-    static readonly RULE_segExpr = 47;
-    static readonly RULE_vExpr = 48;
-    static readonly RULE_queryExtendStatement = 49;
-    static readonly RULE_queryExtendStatementList = 50;
-    static readonly RULE_joinList = 51;
-    static readonly RULE_isExplore = 52;
-    static readonly RULE_matrixOperation = 53;
-    static readonly RULE_joinDef = 54;
-    static readonly RULE_joinExpression = 55;
-    static readonly RULE_filterStatement = 56;
-    static readonly RULE_fieldProperties = 57;
-    static readonly RULE_aggregateOrdering = 58;
-    static readonly RULE_aggregateOrderBySpec = 59;
-    static readonly RULE_aggregateOrderByStatement = 60;
-    static readonly RULE_fieldPropertyLimitStatement = 61;
-    static readonly RULE_fieldPropertyStatement = 62;
-    static readonly RULE_filterClauseList = 63;
-    static readonly RULE_whereStatement = 64;
-    static readonly RULE_havingStatement = 65;
-    static readonly RULE_subQueryDefList = 66;
-    static readonly RULE_exploreQueryNameDef = 67;
-    static readonly RULE_exploreQueryDef = 68;
-    static readonly RULE_queryStatement = 69;
-    static readonly RULE_queryJoinStatement = 70;
-    static readonly RULE_groupByStatement = 71;
-    static readonly RULE_queryFieldList = 72;
-    static readonly RULE_queryFieldEntry = 73;
-    static readonly RULE_nestStatement = 74;
-    static readonly RULE_nestedQueryList = 75;
-    static readonly RULE_nestEntry = 76;
-    static readonly RULE_aggregateStatement = 77;
-    static readonly RULE_calculateStatement = 78;
-    static readonly RULE_projectStatement = 79;
-    static readonly RULE_partitionByStatement = 80;
-    static readonly RULE_orderByStatement = 81;
-    static readonly RULE_ordering = 82;
-    static readonly RULE_orderBySpec = 83;
-    static readonly RULE_limitStatement = 84;
-    static readonly RULE_bySpec = 85;
-    static readonly RULE_topStatement = 86;
-    static readonly RULE_indexElement = 87;
-    static readonly RULE_indexFields = 88;
-    static readonly RULE_indexStatement = 89;
-    static readonly RULE_sampleStatement = 90;
-    static readonly RULE_timezoneStatement = 91;
-    static readonly RULE_queryAnnotation = 92;
-    static readonly RULE_sampleSpec = 93;
-    static readonly RULE_aggregate = 94;
-    static readonly RULE_malloyType = 95;
-    static readonly RULE_compareOp = 96;
-    static readonly RULE_string = 97;
-    static readonly RULE_shortString = 98;
-    static readonly RULE_numericLiteral = 99;
-    static readonly RULE_literal = 100;
-    static readonly RULE_dateLiteral = 101;
-    static readonly RULE_tablePath = 102;
-    static readonly RULE_tableURI = 103;
-    static readonly RULE_id = 104;
-    static readonly RULE_timeframe = 105;
-    static readonly RULE_ungroup = 106;
-    static readonly RULE_malloyOrSQLType = 107;
-    static readonly RULE_fieldExpr = 108;
-    static readonly RULE_partialAllowedFieldExpr = 109;
-    static readonly RULE_pickStatement = 110;
-    static readonly RULE_pick = 111;
-    static readonly RULE_argumentList = 112;
-    static readonly RULE_fieldNameList = 113;
-    static readonly RULE_fieldCollection = 114;
-    static readonly RULE_collectionWildCard = 115;
-    static readonly RULE_starQualified = 116;
-    static readonly RULE_taggedRef = 117;
-    static readonly RULE_refExpr = 118;
-    static readonly RULE_collectionMember = 119;
-    static readonly RULE_fieldPath = 120;
-    static readonly RULE_joinName = 121;
-    static readonly RULE_fieldName = 122;
-    static readonly RULE_justExpr = 123;
-    static readonly RULE_sqlExploreNameRef = 124;
-    static readonly RULE_nameSQLBlock = 125;
-    static readonly RULE_connectionName = 126;
-    static readonly RULE_experimentalStatementForTesting = 127;
+    static readonly RULE_sourceParameters = 30;
+    static readonly RULE_sourceParameter = 31;
+    static readonly RULE_parameterNameDef = 32;
+    static readonly RULE_sourceNameDef = 33;
+    static readonly RULE_exploreProperties = 34;
+    static readonly RULE_exploreStatement = 35;
+    static readonly RULE_defMeasures = 36;
+    static readonly RULE_defDimensions = 37;
+    static readonly RULE_renameList = 38;
+    static readonly RULE_exploreRenameDef = 39;
+    static readonly RULE_defList = 40;
+    static readonly RULE_fieldDef = 41;
+    static readonly RULE_fieldNameDef = 42;
+    static readonly RULE_joinNameDef = 43;
+    static readonly RULE_declareStatement = 44;
+    static readonly RULE_joinStatement = 45;
+    static readonly RULE_queryExtend = 46;
+    static readonly RULE_modEither = 47;
+    static readonly RULE_sourceArguments = 48;
+    static readonly RULE_argumentId = 49;
+    static readonly RULE_sourceArgument = 50;
+    static readonly RULE_sqExpr = 51;
+    static readonly RULE_segExpr = 52;
+    static readonly RULE_vExpr = 53;
+    static readonly RULE_queryExtendStatement = 54;
+    static readonly RULE_queryExtendStatementList = 55;
+    static readonly RULE_joinList = 56;
+    static readonly RULE_isExplore = 57;
+    static readonly RULE_matrixOperation = 58;
+    static readonly RULE_joinDef = 59;
+    static readonly RULE_joinExpression = 60;
+    static readonly RULE_filterStatement = 61;
+    static readonly RULE_fieldProperties = 62;
+    static readonly RULE_aggregateOrdering = 63;
+    static readonly RULE_aggregateOrderBySpec = 64;
+    static readonly RULE_aggregateOrderByStatement = 65;
+    static readonly RULE_fieldPropertyLimitStatement = 66;
+    static readonly RULE_fieldPropertyStatement = 67;
+    static readonly RULE_filterClauseList = 68;
+    static readonly RULE_whereStatement = 69;
+    static readonly RULE_havingStatement = 70;
+    static readonly RULE_subQueryDefList = 71;
+    static readonly RULE_exploreQueryNameDef = 72;
+    static readonly RULE_exploreQueryDef = 73;
+    static readonly RULE_queryStatement = 74;
+    static readonly RULE_queryJoinStatement = 75;
+    static readonly RULE_groupByStatement = 76;
+    static readonly RULE_queryFieldList = 77;
+    static readonly RULE_queryFieldEntry = 78;
+    static readonly RULE_nestStatement = 79;
+    static readonly RULE_nestedQueryList = 80;
+    static readonly RULE_nestEntry = 81;
+    static readonly RULE_aggregateStatement = 82;
+    static readonly RULE_calculateStatement = 83;
+    static readonly RULE_projectStatement = 84;
+    static readonly RULE_partitionByStatement = 85;
+    static readonly RULE_orderByStatement = 86;
+    static readonly RULE_ordering = 87;
+    static readonly RULE_orderBySpec = 88;
+    static readonly RULE_limitStatement = 89;
+    static readonly RULE_bySpec = 90;
+    static readonly RULE_topStatement = 91;
+    static readonly RULE_indexElement = 92;
+    static readonly RULE_indexFields = 93;
+    static readonly RULE_indexStatement = 94;
+    static readonly RULE_sampleStatement = 95;
+    static readonly RULE_timezoneStatement = 96;
+    static readonly RULE_queryAnnotation = 97;
+    static readonly RULE_sampleSpec = 98;
+    static readonly RULE_aggregate = 99;
+    static readonly RULE_malloyType = 100;
+    static readonly RULE_compareOp = 101;
+    static readonly RULE_string = 102;
+    static readonly RULE_shortString = 103;
+    static readonly RULE_numericLiteral = 104;
+    static readonly RULE_literal = 105;
+    static readonly RULE_dateLiteral = 106;
+    static readonly RULE_tablePath = 107;
+    static readonly RULE_tableURI = 108;
+    static readonly RULE_id = 109;
+    static readonly RULE_timeframe = 110;
+    static readonly RULE_ungroup = 111;
+    static readonly RULE_malloyOrSQLType = 112;
+    static readonly RULE_fieldExpr = 113;
+    static readonly RULE_partialAllowedFieldExpr = 114;
+    static readonly RULE_pickStatement = 115;
+    static readonly RULE_pick = 116;
+    static readonly RULE_argumentList = 117;
+    static readonly RULE_fieldNameList = 118;
+    static readonly RULE_fieldCollection = 119;
+    static readonly RULE_collectionWildCard = 120;
+    static readonly RULE_starQualified = 121;
+    static readonly RULE_taggedRef = 122;
+    static readonly RULE_refExpr = 123;
+    static readonly RULE_collectionMember = 124;
+    static readonly RULE_fieldPath = 125;
+    static readonly RULE_joinName = 126;
+    static readonly RULE_fieldName = 127;
+    static readonly RULE_justExpr = 128;
+    static readonly RULE_sqlExploreNameRef = 129;
+    static readonly RULE_nameSQLBlock = 130;
+    static readonly RULE_connectionName = 131;
+    static readonly RULE_experimentalStatementForTesting = 132;
     static readonly ruleNames: string[];
     private static readonly _LITERAL_NAMES;
     private static readonly _SYMBOLIC_NAMES;
@@ -330,8 +335,10 @@ export declare class MalloyParser extends Parser {
     sourcePropertyList(): SourcePropertyListContext;
     sourceDefinition(): SourceDefinitionContext;
     sqExplore(): SqExploreContext;
+    sourceParameters(): SourceParametersContext;
+    sourceParameter(): SourceParameterContext;
+    parameterNameDef(): ParameterNameDefContext;
     sourceNameDef(): SourceNameDefContext;
-    sourceID(): SourceIDContext;
     exploreProperties(): ExplorePropertiesContext;
     exploreStatement(): ExploreStatementContext;
     defMeasures(): DefMeasuresContext;
@@ -346,6 +353,9 @@ export declare class MalloyParser extends Parser {
     joinStatement(): JoinStatementContext;
     queryExtend(): QueryExtendContext;
     modEither(): ModEitherContext;
+    sourceArguments(): SourceArgumentsContext;
+    argumentId(): ArgumentIdContext;
+    sourceArgument(): SourceArgumentContext;
     sqExpr(): SqExprContext;
     sqExpr(_p: number): SqExprContext;
     segExpr(): SegExprContext;
@@ -769,6 +779,7 @@ export declare class SourceDefinitionContext extends ParserRuleContext {
     sourceNameDef(): SourceNameDefContext;
     isDefine(): IsDefineContext;
     sqExplore(): SqExploreContext;
+    sourceParameters(): SourceParametersContext | undefined;
     constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: MalloyParserListener): void;
@@ -783,7 +794,32 @@ export declare class SqExploreContext extends ParserRuleContext {
     exitRule(listener: MalloyParserListener): void;
     accept<Result>(visitor: MalloyParserVisitor<Result>): Result;
 }
-export declare class SourceNameDefContext extends ParserRuleContext {
+export declare class SourceParametersContext extends ParserRuleContext {
+    OPAREN(): TerminalNode;
+    CPAREN(): TerminalNode;
+    sourceParameter(): SourceParameterContext[];
+    sourceParameter(i: number): SourceParameterContext;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyParserListener): void;
+    exitRule(listener: MalloyParserListener): void;
+    accept<Result>(visitor: MalloyParserVisitor<Result>): Result;
+}
+export declare class SourceParameterContext extends ParserRuleContext {
+    parameterNameDef(): ParameterNameDefContext;
+    DOUBLECOLON(): TerminalNode | undefined;
+    malloyType(): MalloyTypeContext | undefined;
+    IS(): TerminalNode | undefined;
+    fieldExpr(): FieldExprContext | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyParserListener): void;
+    exitRule(listener: MalloyParserListener): void;
+    accept<Result>(visitor: MalloyParserVisitor<Result>): Result;
+}
+export declare class ParameterNameDefContext extends ParserRuleContext {
     id(): IdContext;
     constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
@@ -791,7 +827,7 @@ export declare class SourceNameDefContext extends ParserRuleContext {
     exitRule(listener: MalloyParserListener): void;
     accept<Result>(visitor: MalloyParserVisitor<Result>): Result;
 }
-export declare class SourceIDContext extends ParserRuleContext {
+export declare class SourceNameDefContext extends ParserRuleContext {
     id(): IdContext;
     constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
@@ -1049,6 +1085,37 @@ export declare class ModEitherContext extends ParserRuleContext {
     exitRule(listener: MalloyParserListener): void;
     accept<Result>(visitor: MalloyParserVisitor<Result>): Result;
 }
+export declare class SourceArgumentsContext extends ParserRuleContext {
+    OPAREN(): TerminalNode;
+    CPAREN(): TerminalNode;
+    sourceArgument(): SourceArgumentContext[];
+    sourceArgument(i: number): SourceArgumentContext;
+    COMMA(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyParserListener): void;
+    exitRule(listener: MalloyParserListener): void;
+    accept<Result>(visitor: MalloyParserVisitor<Result>): Result;
+}
+export declare class ArgumentIdContext extends ParserRuleContext {
+    id(): IdContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyParserListener): void;
+    exitRule(listener: MalloyParserListener): void;
+    accept<Result>(visitor: MalloyParserVisitor<Result>): Result;
+}
+export declare class SourceArgumentContext extends ParserRuleContext {
+    fieldExpr(): FieldExprContext;
+    argumentId(): ArgumentIdContext | undefined;
+    IS(): TerminalNode | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyParserListener): void;
+    exitRule(listener: MalloyParserListener): void;
+    accept<Result>(visitor: MalloyParserVisitor<Result>): Result;
+}
 export declare class SqExprContext extends ParserRuleContext {
     constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
@@ -1056,6 +1123,7 @@ export declare class SqExprContext extends ParserRuleContext {
 }
 export declare class SQIDContext extends SqExprContext {
     id(): IdContext;
+    sourceArguments(): SourceArgumentsContext | undefined;
     constructor(ctx: SqExprContext);
     enterRule(listener: MalloyParserListener): void;
     exitRule(listener: MalloyParserListener): void;