Ensure custom expression editor doesn't allow aggregations

frontend/src/metabase/lib/expressions/parser.js

@@ -176,19 +176,19 @@ function getTokenSource(TokenClass) {
     return TokenClass.PATTERN.source.replace(/^\\/, "");
 }
 
-export function compile(source, { fields } = {}) {
+export function compile(source, { startRule, fields } = {}) {
     if (!source) {
         return [];
     }
     const parser = new ExpressionsParser(ExpressionsLexer.tokenize(source).tokens, fields);
-    const expression = parser.aggregation();
+    const expression = parser[startRule]();
     if (parser.errors.length > 0) {
         throw parser.errors;
     }
     return expression;
 }
 
-export function suggest(source, { index = source.length, fields } = {}) {
+export function suggest(source, { startRule, index = source.length, fields } = {}) {
     const partialSource = source.slice(0, index);
     const lexResult = ExpressionsLexer.tokenize(partialSource);
     if (lexResult.errors.length > 0) {
@@ -206,7 +206,7 @@ export function suggest(source, { index = source.length, fields } = {}) {
         partialSuggestionMode = true
     }
 
-    const syntacticSuggestions = parserInstance.computeContentAssist("aggregation", assistanceTokenVector)
+    const syntacticSuggestions = parserInstance.computeContentAssist(startRule, assistanceTokenVector)
 
     let finalSuggestions = []
 
@@ -215,7 +215,7 @@ export function suggest(source, { index = source.length, fields } = {}) {
         // no nesting of aggregations or field references outside of aggregations
         // we have a predicate in the grammar to prevent nested aggregations but chevrotain
         // doesn't support predicates in content-assist mode, so we need this extra check
-        const outsideAggregation = ruleStack.slice(0, -1).indexOf("aggregationExpression") < 0;
+        const outsideAggregation = startRule === "aggregation" && ruleStack.slice(0, -1).indexOf("aggregationExpression") < 0;
 
         if (nextTokenType === MultiplicativeOperator || nextTokenType === AdditiveOperator) {
             let tokens = getSubTokenTypes(nextTokenType);

frontend/src/metabase/query_builder/components/AggregationPopover.jsx

@@ -176,6 +176,7 @@ export default class AggregationPopover extends Component {
                     </div>
                     <div className="p1">
                         <ExpressionEditorTextfield
+                            startRule="aggregation"
                             expression={aggregation}
                             tableMetadata={tableMetadata}
                             onChange={(parsedExpression) => this.setState({aggregation: parsedExpression, error: null})}

frontend/src/metabase/query_builder/components/expressions/ExpressionEditorTextfield.jsx

@@ -33,11 +33,13 @@ export default class ExpressionEditorTextfield extends Component {
         expression: PropTypes.array,      // should be an array like [parsedExpressionObj, expressionString]
         tableMetadata: PropTypes.object.isRequired,
         onChange: PropTypes.func.isRequired,
-        onError: PropTypes.func.isRequired
+        onError: PropTypes.func.isRequired,
+        startRule: PropTypes.string.isRequired
     };
 
     static defaultProps = {
         expression: [null, ""],
+        startRule: "expression",
         placeholder: "write some math!"
     }
 
@@ -54,7 +56,10 @@ export default class ExpressionEditorTextfield extends Component {
             let suggestions = [];
             try {
                 if (expressionString) {
-                    compile(expressionString, { fields: newProps.tableMetadata.fields });
+                    compile(expressionString, {
+                        startRule: newProps.startRule,
+                        fields: newProps.tableMetadata.fields
+                    });
                 }
             } catch (e) {
                 expressionErrorMessage = e;
@@ -170,13 +175,17 @@ export default class ExpressionEditorTextfield extends Component {
         let parsedExpression;
 
         try {
-            parsedExpression = compile(expressionString, { fields: this.props.tableMetadata.fields })
+            parsedExpression = compile(expressionString, {
+                startRule: this.props.startRule,
+                fields: this.props.tableMetadata.fields
+            })
         } catch (e) {
             expressionErrorMessage = e;
             console.error("expression error:", expressionErrorMessage);
         }
         try {
             suggestions = suggest(expressionString, {
+                startRule: this.props.startRule,
                 index: inputElement.selectionStart,
                 fields: this.props.tableMetadata.fields
             })