Simplify by requiring only constants in maps and arrays at grammar level

3 files changed, 19 insertions, 65 deletions

diff --git a/container-search/src/main/antlr4/com/yahoo/search/yql/yqlplus.g4 b/container-search/src/main/antlr4/com/yahoo/search/yql/yqlplus.g4
index d9c0ab81121..5bc0253ee5f 100644
--- a/container-search/src/main/antlr4/com/yahoo/search/yql/yqlplus.g4
+++ b/container-search/src/main/antlr4/com/yahoo/search/yql/yqlplus.g4
@@ -317,10 +317,6 @@ mapExpression
     : LBRACE propertyNameAndValue? (COMMA propertyNameAndValue)* RBRACE
     ;
 
-constantMapExpression
-    : LBRACE constantPropertyNameAndValue? (COMMA constantPropertyNameAndValue)* RBRACE
-    ;
-
 arguments[boolean in_select]
 	:  LPAREN RPAREN                                                    
 	|  LPAREN (argument[$in_select] (COMMA argument[$in_select])*) RPAREN
@@ -354,7 +350,7 @@ annotateExpression
 	;
 
 annotation
-    : LBRACKET constantMapExpression RBRACKET
+    : LBRACKET mapExpression RBRACKET
     ;
 
 logicalORExpression
@@ -441,28 +437,19 @@ primaryExpression
 @init {
     boolean in_select = expression_stack.peek().in_select;
 }
-	: callExpresion[in_select]
-	| parameter
+	: callExpression[in_select]
 	| fieldref
-	| scalar_literal
-	| arrayLiteral
-	| mapExpression
+	| constantExpression
 	| LPAREN expression[in_select] RPAREN
 	;
 	
-callExpresion[boolean in_select]
+callExpression[boolean in_select]
 	: namespaced_name arguments[in_select]
 	;
-	
+
 fieldref
 	: namespaced_name
 	;
-arrayLiteral
-@init {
-	boolean in_select = expression_stack.peek().in_select;
-}
-    : LBRACKET expression[in_select]? (COMMA expression[in_select])* RBRACKET
-	;
 
 // a parameter is an argument from outside the YQL statement
 parameter
@@ -470,10 +457,6 @@ parameter
 	;	
 	       
 propertyNameAndValue
-	: propertyName ':' expression[{expression_stack.peek().in_select}] //{return (PROPERTY propertyName expression);}
-	;
-
-constantPropertyNameAndValue
 	: propertyName ':' constantExpression
 	;
 
@@ -484,12 +467,12 @@ propertyName
 
 constantExpression
     : scalar_literal
-    | constantMapExpression
-    | constantArray
+    | mapExpression
+    | arrayLiteral
     | parameter
     ;
 
-constantArray
+arrayLiteral
     : LBRACKET i+=constantExpression? (COMMA i+=constantExpression)* RBRACKET
     ;
 
diff --git a/container-search/src/main/java/com/yahoo/search/yql/ProgramParser.java b/container-search/src/main/java/com/yahoo/search/yql/ProgramParser.java
index c84ed0a0565..c7c4b2885d2 100644
--- a/container-search/src/main/java/com/yahoo/search/yql/ProgramParser.java
+++ b/container-search/src/main/java/com/yahoo/search/yql/ProgramParser.java
@@ -9,19 +9,15 @@ import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
-import com.yahoo.search.yql.yqlplusParser.AnnotationContext;
 import com.yahoo.search.yql.yqlplusParser.AnnotateExpressionContext;
+import com.yahoo.search.yql.yqlplusParser.AnnotationContext;
 import com.yahoo.search.yql.yqlplusParser.ArgumentContext;
 import com.yahoo.search.yql.yqlplusParser.ArgumentsContext;
 import com.yahoo.search.yql.yqlplusParser.ArrayLiteralContext;
 import com.yahoo.search.yql.yqlplusParser.Call_sourceContext;
-import com.yahoo.search.yql.yqlplusParser.ConstantArrayContext;
 import com.yahoo.search.yql.yqlplusParser.ConstantExpressionContext;
-import com.yahoo.search.yql.yqlplusParser.ConstantMapExpressionContext;
-import com.yahoo.search.yql.yqlplusParser.ConstantPropertyNameAndValueContext;
 import com.yahoo.search.yql.yqlplusParser.DereferencedExpressionContext;
 import com.yahoo.search.yql.yqlplusParser.EqualityExpressionContext;
-import com.yahoo.search.yql.yqlplusParser.ExpressionContext;
 import com.yahoo.search.yql.yqlplusParser.Field_defContext;
 import com.yahoo.search.yql.yqlplusParser.IdentContext;
 import com.yahoo.search.yql.yqlplusParser.InNotInTargetContext;
@@ -38,8 +34,8 @@ import com.yahoo.search.yql.yqlplusParser.OrderbyContext;
 import com.yahoo.search.yql.yqlplusParser.Orderby_fieldContext;
 import com.yahoo.search.yql.yqlplusParser.Output_specContext;
 import com.yahoo.search.yql.yqlplusParser.Pipeline_stepContext;
-import com.yahoo.search.yql.yqlplusParser.Project_specContext;
 import com.yahoo.search.yql.yqlplusParser.ProgramContext;
+import com.yahoo.search.yql.yqlplusParser.Project_specContext;
 import com.yahoo.search.yql.yqlplusParser.PropertyNameAndValueContext;
 import com.yahoo.search.yql.yqlplusParser.Query_statementContext;
 import com.yahoo.search.yql.yqlplusParser.RelationalExpressionContext;
@@ -55,7 +51,6 @@ import com.yahoo.search.yql.yqlplusParser.StatementContext;
 import com.yahoo.search.yql.yqlplusParser.TimeoutContext;
 import com.yahoo.search.yql.yqlplusParser.UnaryExpressionContext;
 import com.yahoo.search.yql.yqlplusParser.WhereContext;
-
 import org.antlr.v4.runtime.ANTLRInputStream;
 import org.antlr.v4.runtime.BaseErrorListener;
 import org.antlr.v4.runtime.CharStream;
@@ -612,8 +607,7 @@ final class ProgramParser {
                 ParseTree firstChild = parseTree.getChild(0);
                 if (getParseTreeIndex(firstChild) == yqlplusParser.RULE_annotation) {
                     ParseTree secondChild = parseTree.getChild(1);
-                    OperatorNode<ExpressionOperator> annotation = convertExpr(((AnnotationContext) firstChild)
-                                                                                      .constantMapExpression(), scope);
+                    OperatorNode<ExpressionOperator> annotation = convertExpr(((AnnotationContext) firstChild).mapExpression(), scope);
                     OperatorNode<ExpressionOperator> expr = OperatorNode.create(toLocation(scope, secondChild),
                                                                                 ExpressionOperator.VESPA_GROUPING, secondChild.getText());
                     List<String> names = annotation.getArgument(0);
@@ -639,18 +633,6 @@ final class ProgramParser {
                     return convertExpr(firstChild, scope);
                 }
             }
-            case yqlplusParser.RULE_constantMapExpression: {
-                List<ConstantPropertyNameAndValueContext> propertyList = ((ConstantMapExpressionContext) parseTree).constantPropertyNameAndValue();
-                List<String> names = Lists.newArrayListWithExpectedSize(propertyList.size());
-                List<OperatorNode<ExpressionOperator>> exprs = Lists.newArrayListWithExpectedSize(propertyList.size());
-                for (ConstantPropertyNameAndValueContext child : propertyList) {
-                    // : propertyName ':' expression[$expression::namespace] ->
-                    // ^(PROPERTY propertyName expression)
-                    names.add(StringUnescaper.unquote(child.getChild(0).getText()));
-                    exprs.add(convertExpr(child.getChild(2), scope));
-                }
-                return OperatorNode.create(toLocation(scope, parseTree),ExpressionOperator.MAP, names, exprs);
-            }
             case yqlplusParser.RULE_mapExpression: {
                 List<PropertyNameAndValueContext> propertyList = ((MapExpressionContext)parseTree).propertyNameAndValue();
                 List<String> names = Lists.newArrayListWithExpectedSize(propertyList.size());
@@ -663,18 +645,10 @@ final class ProgramParser {
                 }
                 return OperatorNode.create(toLocation(scope, parseTree),ExpressionOperator.MAP, names, exprs);
             }
-            case yqlplusParser.RULE_constantArray: {
-                List<ConstantExpressionContext> expressionList = ((ConstantArrayContext)parseTree).constantExpression();
-                List<OperatorNode<ExpressionOperator>> values = Lists.newArrayListWithExpectedSize(expressionList.size());
-                for (ConstantExpressionContext expr : expressionList) {
-                    values.add(convertExpr(expr, scope));
-                }
-                return OperatorNode.create(toLocation(scope, expressionList.isEmpty()? parseTree:expressionList.get(0)), ExpressionOperator.ARRAY, values);
-            }
             case yqlplusParser.RULE_arrayLiteral: {
-                List<ExpressionContext> expressionList = ((ArrayLiteralContext) parseTree).expression();
+                List<ConstantExpressionContext> expressionList = ((ArrayLiteralContext) parseTree).constantExpression();
                 List<OperatorNode<ExpressionOperator>> values = Lists.newArrayListWithExpectedSize(expressionList.size());
-                for (ExpressionContext expr : expressionList) {
+                for (ConstantExpressionContext expr : expressionList) {
                     values.add(convertExpr(expr, scope));
                 }
                 return OperatorNode.create(toLocation(scope, expressionList.isEmpty()? parseTree:expressionList.get(0)), ExpressionOperator.ARRAY, values);
@@ -703,7 +677,7 @@ final class ProgramParser {
                     case yqlplusParser.RULE_fieldref: {
                         return convertExpr(firstChild, scope);
                     }
-                    case yqlplusParser.RULE_callExpresion: {
+                    case yqlplusParser.RULE_callExpression: {
                         List<ArgumentContext> args = ((ArgumentsContext) firstChild.getChild(1)).argument();
                         List<OperatorNode<ExpressionOperator>> arguments = Lists.newArrayListWithExpectedSize(args.size());
                         for (ArgumentContext argContext : args) {
@@ -711,13 +685,9 @@ final class ProgramParser {
                         }
                         return OperatorNode.create(toLocation(scope, parseTree), ExpressionOperator.CALL, scope.resolvePath(readName((Namespaced_nameContext) firstChild.getChild(0))), arguments);
                     }
-                    case yqlplusParser.RULE_parameter:
-                        // external variable reference
-                        return OperatorNode.create(toLocation(scope, firstChild), ExpressionOperator.VARREF, firstChild.getChild(1).getText());
-                    case yqlplusParser.RULE_scalar_literal:
-                    case yqlplusParser.RULE_arrayLiteral:
-                    case yqlplusParser.RULE_mapExpression:
+                    case yqlplusParser.RULE_constantExpression:
                         return convertExpr(firstChild, scope);
+
                     case yqlplusParser.LPAREN:
                         return convertExpr(parseTree.getChild(1), scope);
                 }
@@ -732,7 +702,7 @@ final class ProgramParser {
             case yqlplusParser.RULE_annotateExpression: {
                 //annotation logicalORExpression
                 AnnotationContext annotateExpressionContext = ((AnnotateExpressionContext)parseTree).annotation();
-                OperatorNode<ExpressionOperator> annotation = convertExpr(annotateExpressionContext.constantMapExpression(), scope);
+                OperatorNode<ExpressionOperator> annotation = convertExpr(annotateExpressionContext.mapExpression(), scope);
                 OperatorNode<ExpressionOperator> expr = convertExpr(parseTree.getChild(1), scope);
                 List<String> names = annotation.getArgument(0);
                 List<OperatorNode<ExpressionOperator>> annotates = annotation.getArgument(1);
diff --git a/container-search/src/test/java/com/yahoo/search/yql/YqlParserTestCase.java b/container-search/src/test/java/com/yahoo/search/yql/YqlParserTestCase.java
index ab99118b179..ec33cca9739 100644
--- a/container-search/src/test/java/com/yahoo/search/yql/YqlParserTestCase.java
+++ b/container-search/src/test/java/com/yahoo/search/yql/YqlParserTestCase.java
@@ -551,7 +551,8 @@ public class YqlParserTestCase {
         assertParse("select foo from bar where weightedSet(description, {\"a\":1, \"b\":2});",
                     "WEIGHTEDSET description{[1]:\"a\",[2]:\"b\"}");
         assertParseFail("select foo from bar where weightedSet(description, {\"a\":g, \"b\":2});",
-                        new IllegalArgumentException("Expected operator LITERAL, got READ_FIELD."));
+                        new IllegalInputException("com.yahoo.search.yql.ProgramCompileException: " +
+                                                  "query:L1:56 no viable alternative at input 'weightedSet(description, {\"a\":g'"));
         assertParseFail("select foo from bar where weightedSet(description);",
                         new IllegalArgumentException("Expected 2 arguments, got 1."));
     }