Use snake case consistently

2 files changed, 106 insertions, 106 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 6193cabeaa7..8c59ed0799b 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
@@ -302,8 +302,8 @@ field_def
 	: expression[true] alias_def?
 	;
 
-mapExpression
-    : LBRACE propertyNameAndValue? (COMMA propertyNameAndValue)* RBRACE
+map_expression
+    : LBRACE property_name_and_value? (COMMA property_name_and_value)* RBRACE
     ;
 
 arguments[boolean in_select]
@@ -325,90 +325,90 @@ expression [boolean select]
 @after {
 	expression_stack.pop();	
 }
-	: annotateExpression
-	| logicalORExpression
-	| nullOperator
+	: annotate_expression
+	| logical_OR_expression
+	| null_operator
 	;
 	
-nullOperator
+null_operator
 	: 'null'
 	;
 
-annotateExpression
-	: annotation logicalORExpression
+annotate_expression
+	: annotation logical_OR_expression
 	;
 
 annotation
-    : LBRACKET mapExpression RBRACKET
+    : LBRACKET map_expression RBRACKET
     ;
 
-logicalORExpression
-	: logicalANDExpression (OR logicalANDExpression)+
-	| logicalANDExpression
+logical_OR_expression
+	: logical_AND_expression (OR logical_AND_expression)+
+	| logical_AND_expression
 	;
 		
-logicalANDExpression
-	: equalityExpression (AND equalityExpression)*
+logical_AND_expression
+	: equality_expression (AND equality_expression)*
 	;
 
-equalityExpression
-	: relationalExpression (  ((IN | NOT_IN) inNotInTarget)
+equality_expression
+	: relational_expression (  ((IN | NOT_IN) in_not_in_target)
 	                         | (IS_NULL | IS_NOT_NULL)
-	                         | (equalityOp relationalExpression) )
-	 | relationalExpression
+	                         | (equality_op relational_expression) )
+	 | relational_expression
 	;
 
-inNotInTarget
+in_not_in_target
     : {expression_stack.peek().in_select}? LPAREN select_statement RPAREN
     | literal_list
     ;
 
-equalityOp 
+equality_op
 	:	(EQ | NEQ | LIKE | NOTLIKE | MATCHES | NOTMATCHES | CONTAINS)
 	;
 	
-relationalExpression
-	: additiveExpression (relationalOp additiveExpression)?
+relational_expression
+	: additive_expression (relational_op additive_expression)?
 	;
 
-relationalOp
+relational_op
 	:	(LT | GT | LTEQ | GTEQ)
 	;
 	
-additiveExpression
-	: multiplicativeExpression (additiveOp additiveExpression)?
+additive_expression
+	: multiplicative_expression (additive_op additive_expression)?
 	;
 	
-additiveOp
+additive_op
 	:	'+'
 	|   '-'
 	;	
 	
-multiplicativeExpression
-	: unaryExpression (multOp multiplicativeExpression)?
+multiplicative_expression
+	: unary_expression (mult_op multiplicative_expression)?
 	;
 	
-multOp
+mult_op
 	:	'*'
 	|   '/'
 	|   '%'
 	;
 
-unaryOp
+unary_op
     : '-'
     | '!'
 	;	
 	
-unaryExpression
-    : dereferencedExpression
-    | unaryOp dereferencedExpression
+unary_expression
+    : dereferenced_expression
+    | unary_op dereferenced_expression
 	;
 	
-dereferencedExpression
+dereferenced_expression
 @init{
 	boolean	in_select = expression_stack.peek().in_select;	
 }
-	:	 primaryExpression
+	:	 primary_expression
 	     (
 	        indexref[in_select]
           | propertyref
@@ -422,17 +422,17 @@ propertyref
 	: 	DOT nm=IDENTIFIER
 	;
 
-primaryExpression
+primary_expression
 @init {
     boolean in_select = expression_stack.peek().in_select;
 }
-	: callExpression[in_select]
+	: call_expression[in_select]
 	| fieldref
-	| constantExpression
+	| constant_expression
 	| LPAREN expression[in_select] RPAREN
 	;
 	
-callExpression[boolean in_select]
+call_expression[boolean in_select]
 	: namespaced_name arguments[in_select]
 	;
 
@@ -445,11 +445,11 @@ parameter
 	: AT ident
 	;	
 	       
-propertyNameAndValue
-	: propertyName ':' constantExpression
+property_name_and_value
+	: property_name ':' constant_expression
 	;
 
-propertyName
+property_name
 	: dotted_idents
 	| STRING
 	;
@@ -458,15 +458,15 @@ dotted_idents
     :   ident (DOT ident)*
     ;
 
-constantExpression
+constant_expression
     : scalar_literal
-    | mapExpression
-    | arrayLiteral
+    | map_expression
+    | array_literal
     | parameter
     ;
 
-arrayLiteral
-    : LBRACKET i+=constantExpression? (COMMA i+=constantExpression)* RBRACKET
+array_literal
+    : LBRACKET i+=constant_expression? (COMMA i+=constant_expression)* RBRACKET
     ;
 
 scalar_literal
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 74f2894f04c..fc0cef2fb5e 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,25 +9,25 @@ 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.AnnotateExpressionContext;
+import com.yahoo.search.yql.yqlplusParser.Annotate_expressionContext;
 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.Array_literalContext;
 import com.yahoo.search.yql.yqlplusParser.Call_sourceContext;
-import com.yahoo.search.yql.yqlplusParser.ConstantExpressionContext;
-import com.yahoo.search.yql.yqlplusParser.DereferencedExpressionContext;
-import com.yahoo.search.yql.yqlplusParser.EqualityExpressionContext;
+import com.yahoo.search.yql.yqlplusParser.Constant_expressionContext;
+import com.yahoo.search.yql.yqlplusParser.Dereferenced_expressionContext;
+import com.yahoo.search.yql.yqlplusParser.Equality_expressionContext;
 import com.yahoo.search.yql.yqlplusParser.Field_defContext;
 import com.yahoo.search.yql.yqlplusParser.IdentContext;
-import com.yahoo.search.yql.yqlplusParser.InNotInTargetContext;
+import com.yahoo.search.yql.yqlplusParser.In_not_in_targetContext;
 import com.yahoo.search.yql.yqlplusParser.LimitContext;
 import com.yahoo.search.yql.yqlplusParser.Literal_elementContext;
 import com.yahoo.search.yql.yqlplusParser.Literal_listContext;
-import com.yahoo.search.yql.yqlplusParser.LogicalANDExpressionContext;
-import com.yahoo.search.yql.yqlplusParser.LogicalORExpressionContext;
-import com.yahoo.search.yql.yqlplusParser.MapExpressionContext;
-import com.yahoo.search.yql.yqlplusParser.MultiplicativeExpressionContext;
+import com.yahoo.search.yql.yqlplusParser.Logical_AND_expressionContext;
+import com.yahoo.search.yql.yqlplusParser.Logical_OR_expressionContext;
+import com.yahoo.search.yql.yqlplusParser.Map_expressionContext;
+import com.yahoo.search.yql.yqlplusParser.Multiplicative_expressionContext;
 import com.yahoo.search.yql.yqlplusParser.Namespaced_nameContext;
 import com.yahoo.search.yql.yqlplusParser.OffsetContext;
 import com.yahoo.search.yql.yqlplusParser.OrderbyContext;
@@ -36,10 +36,10 @@ import com.yahoo.search.yql.yqlplusParser.Output_specContext;
 import com.yahoo.search.yql.yqlplusParser.Pipeline_stepContext;
 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.Property_name_and_valueContext;
 import com.yahoo.search.yql.yqlplusParser.Query_statementContext;
-import com.yahoo.search.yql.yqlplusParser.RelationalExpressionContext;
-import com.yahoo.search.yql.yqlplusParser.RelationalOpContext;
+import com.yahoo.search.yql.yqlplusParser.Relational_expressionContext;
+import com.yahoo.search.yql.yqlplusParser.Relational_opContext;
 import com.yahoo.search.yql.yqlplusParser.Scalar_literalContext;
 import com.yahoo.search.yql.yqlplusParser.Select_source_multiContext;
 import com.yahoo.search.yql.yqlplusParser.Select_statementContext;
@@ -49,7 +49,7 @@ import com.yahoo.search.yql.yqlplusParser.Source_specContext;
 import com.yahoo.search.yql.yqlplusParser.Source_statementContext;
 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.Unary_expressionContext;
 import com.yahoo.search.yql.yqlplusParser.WhereContext;
 import org.antlr.v4.runtime.BaseErrorListener;
 import org.antlr.v4.runtime.CharStream;
@@ -604,7 +604,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).mapExpression(), scope);
+                    OperatorNode<ExpressionOperator> annotation = convertExpr(((AnnotationContext) firstChild).map_expression(), scope);
                     OperatorNode<ExpressionOperator> expr = OperatorNode.create(toLocation(scope, secondChild),
                                                                                 ExpressionOperator.VESPA_GROUPING, secondChild.getText());
                     List<String> names = annotation.getArgument(0);
@@ -618,7 +618,7 @@ final class ProgramParser {
                                                firstChild.getText());
                 }
             }
-            case yqlplusParser.RULE_nullOperator:
+            case yqlplusParser.RULE_null_operator:
                 return OperatorNode.create(ExpressionOperator.NULL);
             case yqlplusParser.RULE_argument:
                 return convertExpr(parseTree.getChild(0), scope);
@@ -630,11 +630,11 @@ final class ProgramParser {
                     return convertExpr(firstChild, scope);
                 }
             }
-            case yqlplusParser.RULE_mapExpression: {
-                List<PropertyNameAndValueContext> propertyList = ((MapExpressionContext)parseTree).propertyNameAndValue();
+            case yqlplusParser.RULE_map_expression: {
+                List<Property_name_and_valueContext> propertyList = ((Map_expressionContext)parseTree).property_name_and_value();
                 List<String> names = Lists.newArrayListWithExpectedSize(propertyList.size());
                 List<OperatorNode<ExpressionOperator>> exprs = Lists.newArrayListWithCapacity(propertyList.size());
-                for (PropertyNameAndValueContext child : propertyList) {
+                for (Property_name_and_valueContext child : propertyList) {
                     // : propertyName ':' expression[$expression::namespace] ->
                     // ^(PROPERTY propertyName expression)
                     names.add(StringUnescaper.unquote(child.getChild(0).getText()));
@@ -642,17 +642,17 @@ final class ProgramParser {
                 }
                 return OperatorNode.create(toLocation(scope, parseTree),ExpressionOperator.MAP, names, exprs);
             }
-            case yqlplusParser.RULE_arrayLiteral: {
-                List<ConstantExpressionContext> expressionList = ((ArrayLiteralContext) parseTree).constantExpression();
+            case yqlplusParser.RULE_array_literal: {
+                List<Constant_expressionContext> expressionList = ((Array_literalContext) parseTree).constant_expression();
                 List<OperatorNode<ExpressionOperator>> values = Lists.newArrayListWithExpectedSize(expressionList.size());
-                for (ConstantExpressionContext expr : expressionList) {
+                for (Constant_expressionContext expr : expressionList) {
                     values.add(convertExpr(expr, scope));
                 }
                 return OperatorNode.create(toLocation(scope, expressionList.isEmpty()? parseTree:expressionList.get(0)), ExpressionOperator.ARRAY, values);
             }
             // dereferencedExpression: primaryExpression(indexref[in_select]| propertyref)*
-            case yqlplusParser.RULE_dereferencedExpression: {
-                DereferencedExpressionContext dereferencedExpression = (DereferencedExpressionContext) parseTree;
+            case yqlplusParser.RULE_dereferenced_expression: {
+                Dereferenced_expressionContext dereferencedExpression = (Dereferenced_expressionContext) parseTree;
                 Iterator<ParseTree> it = dereferencedExpression.children.iterator();
                 OperatorNode<ExpressionOperator> result = convertExpr(it.next(), scope);
                 while (it.hasNext()) {
@@ -667,14 +667,14 @@ final class ProgramParser {
                 }
                 return result;
             }
-            case yqlplusParser.RULE_primaryExpression: {
+            case yqlplusParser.RULE_primary_expression: {
                 // ^(CALL namespaced_name arguments)
                 ParseTree firstChild = parseTree.getChild(0);
                 switch (getParseTreeIndex(firstChild)) {
                     case yqlplusParser.RULE_fieldref: {
                         return convertExpr(firstChild, scope);
                     }
-                    case yqlplusParser.RULE_callExpression: {
+                    case yqlplusParser.RULE_call_expression: {
                         List<ArgumentContext> args = ((ArgumentsContext) firstChild.getChild(1)).argument();
                         List<OperatorNode<ExpressionOperator>> arguments = Lists.newArrayListWithExpectedSize(args.size());
                         for (ArgumentContext argContext : args) {
@@ -682,7 +682,7 @@ final class ProgramParser {
                         }
                         return OperatorNode.create(toLocation(scope, parseTree), ExpressionOperator.CALL, scope.resolvePath(readName((Namespaced_nameContext) firstChild.getChild(0))), arguments);
                     }
-                    case yqlplusParser.RULE_constantExpression:
+                    case yqlplusParser.RULE_constant_expression:
                         return convertExpr(firstChild, scope);
 
                     case yqlplusParser.LPAREN:
@@ -696,10 +696,10 @@ final class ProgramParser {
                 IdentContext identContext = parameterContext.getRuleContext(IdentContext.class, 0);
                 return OperatorNode.create(toLocation(scope, identContext), ExpressionOperator.VARREF, identContext.getText());
             }
-            case yqlplusParser.RULE_annotateExpression: {
+            case yqlplusParser.RULE_annotate_expression: {
                 //annotation logicalORExpression
-                AnnotationContext annotateExpressionContext = ((AnnotateExpressionContext)parseTree).annotation();
-                OperatorNode<ExpressionOperator> annotation = convertExpr(annotateExpressionContext.mapExpression(), scope);
+                AnnotationContext annotateExpressionContext = ((Annotate_expressionContext)parseTree).annotation();
+                OperatorNode<ExpressionOperator> annotation = convertExpr(annotateExpressionContext.map_expression(), scope);
                 OperatorNode<ExpressionOperator> expr = convertExpr(parseTree.getChild(1), scope);
                 List<String> names = annotation.getArgument(0);
                 List<OperatorNode<ExpressionOperator>> annotates = annotation.getArgument(1);
@@ -711,16 +711,16 @@ final class ProgramParser {
             case yqlplusParser.RULE_expression: {
                 return convertExpr(parseTree.getChild(0), scope);
             }
-            case yqlplusParser.RULE_logicalANDExpression:
-                LogicalANDExpressionContext andExpressionContext = (LogicalANDExpressionContext) parseTree;
-                return readConjOp(ExpressionOperator.AND, andExpressionContext.equalityExpression(), scope);
-            case yqlplusParser.RULE_logicalORExpression: {
+            case yqlplusParser.RULE_logical_AND_expression:
+                Logical_AND_expressionContext andExpressionContext = (Logical_AND_expressionContext) parseTree;
+                return readConjOp(ExpressionOperator.AND, andExpressionContext.equality_expression(), scope);
+            case yqlplusParser.RULE_logical_OR_expression: {
                 int childCount = parseTree.getChildCount();
-                LogicalORExpressionContext logicalORExpressionContext = (LogicalORExpressionContext) parseTree;
+                Logical_OR_expressionContext logicalORExpressionContext = (Logical_OR_expressionContext) parseTree;
                 if (childCount > 1) {
                     return readConjOrOp(ExpressionOperator.OR, logicalORExpressionContext, scope);
                 } else {
-                    List<EqualityExpressionContext> equalityExpressionList = ((LogicalANDExpressionContext) parseTree.getChild(0)).equalityExpression();
+                    List<Equality_expressionContext> equalityExpressionList = ((Logical_AND_expressionContext) parseTree.getChild(0)).equality_expression();
                     if (equalityExpressionList.size() > 1) {
                         return readConjOp(ExpressionOperator.AND, equalityExpressionList, scope);
                     } else {
@@ -728,11 +728,11 @@ final class ProgramParser {
                     }
                 }
             }
-            case yqlplusParser.RULE_equalityExpression: {
-                EqualityExpressionContext equalityExpression = (EqualityExpressionContext) parseTree;
-                RelationalExpressionContext relationalExpressionContext = equalityExpression.relationalExpression(0);
+            case yqlplusParser.RULE_equality_expression: {
+                Equality_expressionContext equalityExpression = (Equality_expressionContext) parseTree;
+                Relational_expressionContext relationalExpressionContext = equalityExpression.relational_expression(0);
                 OperatorNode<ExpressionOperator> expr = convertExpr(relationalExpressionContext, scope);
-                InNotInTargetContext inNotInTarget = equalityExpression.inNotInTarget();
+                In_not_in_targetContext inNotInTarget = equalityExpression.in_not_in_target();
                 int childCount = equalityExpression.getChildCount();
                 if (childCount == 1) {
                     return expr;
@@ -786,11 +786,11 @@ final class ProgramParser {
                 }
                 break;
             }
-            case yqlplusParser.RULE_relationalExpression: {
-                RelationalExpressionContext relationalExpressionContext = (RelationalExpressionContext) parseTree;
-                RelationalOpContext opContext = relationalExpressionContext.relationalOp();
+            case yqlplusParser.RULE_relational_expression: {
+                Relational_expressionContext relationalExpressionContext = (Relational_expressionContext) parseTree;
+                Relational_opContext opContext = relationalExpressionContext.relational_op();
                 if (opContext != null) {
-                    switch (getParseTreeIndex(relationalExpressionContext.relationalOp().getChild(0))) {
+                    switch (getParseTreeIndex(relationalExpressionContext.relational_op().getChild(0))) {
                         case yqlplusParser.LT:
                             return readBinOp(ExpressionOperator.LT, parseTree, scope);
                         case yqlplusParser.LTEQ:
@@ -801,12 +801,12 @@ final class ProgramParser {
                             return readBinOp(ExpressionOperator.GTEQ, parseTree, scope);
                     }
                 } else {
-                    return convertExpr(relationalExpressionContext.additiveExpression(0), scope);
+                    return convertExpr(relationalExpressionContext.additive_expression(0), scope);
                 }
             }
             break;
-            case yqlplusParser.RULE_additiveExpression:
-            case yqlplusParser.RULE_multiplicativeExpression: {
+            case yqlplusParser.RULE_additive_expression:
+            case yqlplusParser.RULE_multiplicative_expression: {
                 if (parseTree.getChildCount() > 1) {
                     String opStr = parseTree.getChild(1).getText();
                     switch (opStr) {
@@ -821,23 +821,23 @@ final class ProgramParser {
                         case "%":
                             return readBinOp(ExpressionOperator.MOD, parseTree, scope);
                         default:
-                            if (parseTree.getChild(0) instanceof UnaryExpressionContext) {
+                            if (parseTree.getChild(0) instanceof Unary_expressionContext) {
                                 return convertExpr(parseTree.getChild(0), scope);
                             } else {
                                 throw new ProgramCompileException(toLocation(scope, parseTree), "Unknown expression type: " + parseTree.toStringTree());
                             }
                     }
                 } else {
-                    if (parseTree.getChild(0) instanceof UnaryExpressionContext) {
+                    if (parseTree.getChild(0) instanceof Unary_expressionContext) {
                         return convertExpr(parseTree.getChild(0), scope);
-                    } else if (parseTree.getChild(0) instanceof MultiplicativeExpressionContext) {
+                    } else if (parseTree.getChild(0) instanceof Multiplicative_expressionContext) {
                         return convertExpr(parseTree.getChild(0), scope);
                     } else {
                         throw new ProgramCompileException(toLocation(scope, parseTree), "Unknown expression type: " + parseTree.getText());
                     }
                 }
             }
-            case yqlplusParser.RULE_unaryExpression: {
+            case yqlplusParser.RULE_unary_expression: {
                 if (1 == parseTree.getChildCount()) {
                     return convertExpr(parseTree.getChild(0), scope);
                 } else if (2 == parseTree.getChildCount()) {
@@ -886,7 +886,7 @@ final class ProgramParser {
             }
             case yqlplusParser.RULE_scalar_literal:
                 return OperatorNode.create(toLocation(scope, parseTree), ExpressionOperator.LITERAL, convertLiteral((Scalar_literalContext) parseTree));
-            case yqlplusParser.RULE_constantExpression:
+            case yqlplusParser.RULE_constant_expression:
                 return convertExpr(parseTree.getChild(0), scope);
             case yqlplusParser.RULE_literal_list:
                 if (getParseTreeIndex(parseTree.getChild(1)) == yqlplusParser.RULE_array_parameter) {
@@ -968,7 +968,7 @@ final class ProgramParser {
         return OperatorNode.create(op, convertExpr(operand1, scope), convertExpr(operand2, scope));
     }
 
-    private OperatorNode<ExpressionOperator> readConjOp(ExpressionOperator op, List<EqualityExpressionContext> nodes, Scope scope) {
+    private OperatorNode<ExpressionOperator> readConjOp(ExpressionOperator op, List<Equality_expressionContext> nodes, Scope scope) {
         List<OperatorNode<ExpressionOperator>> arguments = Lists.newArrayListWithExpectedSize(nodes.size());
         for (ParseTree child : nodes) {
             arguments.add(convertExpr(child, scope));
@@ -976,16 +976,16 @@ final class ProgramParser {
         return OperatorNode.create(op, arguments);
     }
 
-    private OperatorNode<ExpressionOperator> readConjOrOp(ExpressionOperator op, LogicalORExpressionContext node, Scope scope) {
-        List<LogicalANDExpressionContext> andExpressionList = node.logicalANDExpression();
+    private OperatorNode<ExpressionOperator> readConjOrOp(ExpressionOperator op, Logical_OR_expressionContext node, Scope scope) {
+        List<Logical_AND_expressionContext> andExpressionList = node.logical_AND_expression();
         List<OperatorNode<ExpressionOperator>> arguments = Lists.newArrayListWithExpectedSize(andExpressionList.size());
-        for (LogicalANDExpressionContext child : andExpressionList) {
-         	List<EqualityExpressionContext> equalities = child.equalityExpression();
+        for (Logical_AND_expressionContext child : andExpressionList) {
+         	List<Equality_expressionContext> equalities = child.equality_expression();
          	if (equalities.size() == 1) {
          		arguments.add(convertExpr(equalities.get(0), scope));
          	} else {
          		List<OperatorNode<ExpressionOperator>> andArguments = Lists.newArrayListWithExpectedSize(equalities.size());
-         		for (EqualityExpressionContext subTreeChild:equalities) {
+         		for (Equality_expressionContext subTreeChild:equalities) {
          				andArguments.add(convertExpr(subTreeChild, scope));
          		}
          		arguments.add(OperatorNode.create(ExpressionOperator.AND, andArguments));
@@ -998,7 +998,7 @@ final class ProgramParser {
     // (IS_NULL | IS_NOT_NULL)
     // unaryExpression
     private OperatorNode<ExpressionOperator> readUnOp(ExpressionOperator op, ParseTree node, Scope scope) {
-        assert (node instanceof TerminalNode) || (node.getChildCount() == 1) || (node instanceof UnaryExpressionContext);
+        assert (node instanceof TerminalNode) || (node.getChildCount() == 1) || (node instanceof Unary_expressionContext);
         if (node instanceof TerminalNode) {
             return OperatorNode.create(op, convertExpr(node, scope));
         } else if (node.getChildCount() == 1) {