[CESQL] Constant folding (#392)

* Added visitor for the expressions

Signed-off-by: Francesco Guardiani <[email protected]>

* First constant folding draft

Signed-off-by: Francesco Guardiani <[email protected]>

* Constant folding for unary expressions

Signed-off-by: Francesco Guardiani <[email protected]>

* More testing
Constant folding for exists expression

Signed-off-by: Francesco Guardiani <[email protected]>

* Little mistake

Signed-off-by: Francesco Guardiani <[email protected]>

* Added a ParserBuilder

Signed-off-by: Francesco Guardiani <[email protected]>

Author: slinkydeveloper

sql/src/main/java/io/cloudevents/sql/ParseException.java

@@ -10,8 +10,9 @@
 public class ParseException extends RuntimeException {
 
     public enum ErrorKind {
-        RECOGNITION_ERROR,
-        PARSE_VALUE
+        RECOGNITION,
+        PARSE_VALUE,
+        CONSTANT_EXPRESSION_EVALUATION,
     }
 
     private final ErrorKind errorKind;
@@ -49,12 +50,22 @@ public static ParseException cannotParseValue(ParseTree node, Type target, Throw
 
     public static ParseException recognitionError(RecognitionException e, String msg) {
         return new ParseException(
-            ErrorKind.RECOGNITION_ERROR,
+            ErrorKind.RECOGNITION,
             new Interval(e.getOffendingToken().getStartIndex(), e.getOffendingToken().getStopIndex()),
             e.getOffendingToken().getText(),
             "Cannot parse: " + msg,
             e
         );
     }
 
+    public static ParseException cannotEvaluateConstantExpression(EvaluationException exception) {
+        return new ParseException(
+            ErrorKind.CONSTANT_EXPRESSION_EVALUATION,
+            exception.getExpressionInterval(),
+            exception.getExpressionText(),
+            "Cannot evaluate the constant expression: " + exception.getExpressionText(),
+            exception
+        );
+    }
+
 }

sql/src/main/java/io/cloudevents/sql/Parser.java

@@ -1,5 +1,6 @@
 package io.cloudevents.sql;
 
+import io.cloudevents.sql.impl.ParserBuilder;
 import io.cloudevents.sql.impl.ParserImpl;
 
 public interface Parser {
@@ -24,4 +25,18 @@ static Expression parseDefault(String inputExpression) throws ParseException {
         return ParserImpl.getInstance().parse(inputExpression);
     }
 
+    /**
+     * @return the default instance of the parser
+     */
+    static Parser getDefault() {
+        return ParserImpl.getInstance();
+    }
+
+    /**
+     * @return a new {@link ParserBuilder}, to create a customized parser instance
+     */
+    static ParserBuilder builder() {
+        return new ParserBuilder();
+    }
+
 }

sql/src/main/java/io/cloudevents/sql/impl/ConstantFoldingExpressionVisitor.java

@@ -0,0 +1,62 @@
+package io.cloudevents.sql.impl;
+
+import io.cloudevents.SpecVersion;
+import io.cloudevents.sql.EvaluationRuntime;
+import io.cloudevents.sql.impl.expressions.*;
+
+public class ConstantFoldingExpressionVisitor implements ExpressionInternalVisitor<ExpressionInternal> {
+
+    @Override
+    public ExpressionInternal visitExpressionInternal(ExpressionInternal expressionInternal) {
+        return expressionInternal;
+    }
+
+    @Override
+    public ExpressionInternal visitBaseBinaryExpression(BaseBinaryExpression baseBinaryExpression) {
+        ExpressionInternal left = baseBinaryExpression.getLeftOperand().visit(this);
+        ExpressionInternal right = baseBinaryExpression.getRightOperand().visit(this);
+
+        if (left instanceof ValueExpression && right instanceof ValueExpression) {
+            // I can do constant folding!
+            return new ValueExpression(
+                baseBinaryExpression.expressionInterval(),
+                baseBinaryExpression.expressionText(),
+                baseBinaryExpression.evaluate(
+                    EvaluationRuntime.getDefault(),
+                    ((ValueExpression) left).getValue(),
+                    ((ValueExpression) right).getValue(),
+                    FailFastExceptionThrower.getInstance()
+                )
+            );
+        }
+
+        baseBinaryExpression.setLeftOperand(left);
+        baseBinaryExpression.setRightOperand(right);
+        return baseBinaryExpression;
+    }
+
+    @Override
+    public ExpressionInternal visitExistsExpression(ExistsExpression existsExpression) {
+        if (SpecVersion.V1.getMandatoryAttributes().contains(existsExpression.getKey())) {
+            // If the attribute is a mandatory attribute of the spec, there's no need to check it
+            return new ValueExpression(existsExpression.expressionInterval(), existsExpression.expressionText(), true);
+        }
+        return existsExpression;
+    }
+
+    @Override
+    public ExpressionInternal visitBaseUnaryExpression(BaseUnaryExpression baseUnaryExpression) {
+        ExpressionInternal inner = baseUnaryExpression.getOperand().visit(this);
+
+        if (inner instanceof ValueExpression) {
+            return new ValueExpression(
+                baseUnaryExpression.expressionInterval(),
+                baseUnaryExpression.expressionText(),
+                baseUnaryExpression.evaluate(EvaluationRuntime.getDefault(), ((ValueExpression) inner).getValue(), FailFastExceptionThrower.getInstance())
+            );
+        }
+
+        baseUnaryExpression.setOperand(inner);
+        return baseUnaryExpression;
+    }
+}

sql/src/main/java/io/cloudevents/sql/impl/ExceptionsStore.java renamed to sql/src/main/java/io/cloudevents/sql/impl/ExceptionStore.java

@@ -5,11 +5,11 @@
 import java.util.ArrayList;
 import java.util.List;
 
-class ExceptionsStore implements ExceptionThrower {
+class ExceptionStore implements ExceptionThrower {
 
     private List<EvaluationException> exceptions;
 
-    ExceptionsStore() {
+    ExceptionStore() {
     }
 
     @Override

sql/src/main/java/io/cloudevents/sql/impl/ExpressionImpl.java

@@ -5,6 +5,7 @@
 import io.cloudevents.sql.EvaluationRuntime;
 import io.cloudevents.sql.Expression;
 import io.cloudevents.sql.Result;
+import io.cloudevents.sql.impl.expressions.ExpressionInternal;
 
 public class ExpressionImpl implements Expression {
 
@@ -16,7 +17,7 @@ public ExpressionImpl(ExpressionInternal expressionInternal) {
 
     @Override
     public Result evaluate(EvaluationRuntime evaluationRuntime, CloudEvent event) {
-        ExceptionsStore exceptions = new ExceptionsStore();
+        ExceptionStore exceptions = new ExceptionStore();
         Object value = this.expressionInternal.evaluate(evaluationRuntime, event, exceptions);
         return new EvaluationResult(value, exceptions.getExceptions());
     }
@@ -25,4 +26,8 @@ public Result evaluate(EvaluationRuntime evaluationRuntime, CloudEvent event) {
     public Object tryEvaluate(EvaluationRuntime evaluationRuntime, CloudEvent event) throws EvaluationException {
         return this.expressionInternal.evaluate(evaluationRuntime, event, FailFastExceptionThrower.getInstance());
     }
+
+    protected ExpressionInternal getExpressionInternal() {
+        return expressionInternal;
+    }
 }

sql/src/main/java/io/cloudevents/sql/impl/ParserBuilder.java

@@ -0,0 +1,30 @@
+package io.cloudevents.sql.impl;
+
+import io.cloudevents.sql.Parser;
+
+public class ParserBuilder {
+
+    private boolean constantFolding;
+
+    public ParserBuilder() {
+        this.constantFolding = true;
+    }
+
+    /**
+     * Disable constant folding when parsing.
+     *
+     * @return this
+     */
+    public ParserBuilder disableConstantFolding() {
+        this.constantFolding = false;
+        return this;
+    }
+
+    /**
+     * @return the new {@link Parser}
+     */
+    public Parser build() {
+        return new ParserImpl(this.constantFolding);
+    }
+
+}

sql/src/main/java/io/cloudevents/sql/impl/ParserImpl.java

@@ -1,10 +1,12 @@
 package io.cloudevents.sql.impl;
 
+import io.cloudevents.sql.EvaluationException;
 import io.cloudevents.sql.Expression;
 import io.cloudevents.sql.ParseException;
 import io.cloudevents.sql.Parser;
 import io.cloudevents.sql.generated.CESQLParserLexer;
 import io.cloudevents.sql.generated.CESQLParserParser;
+import io.cloudevents.sql.impl.expressions.ExpressionInternal;
 import org.antlr.v4.runtime.*;
 import org.antlr.v4.runtime.atn.ATNConfigSet;
 import org.antlr.v4.runtime.dfa.DFA;
@@ -17,17 +19,20 @@
 public class ParserImpl implements Parser {
 
     private static class SingletonContainer {
-        private final static ParserImpl INSTANCE = new ParserImpl();
+        private final static ParserImpl INSTANCE = new ParserImpl(true);
     }
 
     /**
-     * @return instance of {@link ParserImpl}
+     * @return default instance of {@link ParserImpl}
      */
     public static Parser getInstance() {
         return ParserImpl.SingletonContainer.INSTANCE;
     }
 
-    public ParserImpl() {
+    private final boolean constantFolding;
+
+    ParserImpl(boolean constantFolding) {
+        this.constantFolding = constantFolding;
     }
 
     @Override
@@ -72,6 +77,14 @@ public void reportContextSensitivity(org.antlr.v4.runtime.Parser recognizer, DFA
 
         ExpressionInternal internal = new ExpressionTranslatorVisitor().visit(tree);
 
+        if (this.constantFolding) {
+            try {
+                internal = internal.visit(new ConstantFoldingExpressionVisitor());
+            } catch (EvaluationException e) {
+                throw ParseException.cannotEvaluateConstantExpression(e);
+            }
+        }
+
         return new ExpressionImpl(internal);
     }
 

sql/src/main/java/io/cloudevents/sql/impl/expressions/AccessAttributeExpression.java

@@ -20,4 +20,9 @@ public Object evaluate(EvaluationRuntime runtime, CloudEvent event, ExceptionThr
         return CloudEventUtils.accessContextAttribute(thrower, expressionInterval(), expressionText(), event, key);
     }
 
+    @Override
+    public <T> T visit(ExpressionInternalVisitor<T> visitor) {
+        return visitor.visitAccessAttributeExpression(this);
+    }
+
 }

sql/src/main/java/io/cloudevents/sql/impl/expressions/AndExpression.java

@@ -2,7 +2,6 @@
 
 import io.cloudevents.sql.EvaluationRuntime;
 import io.cloudevents.sql.impl.ExceptionThrower;
-import io.cloudevents.sql.impl.ExpressionInternal;
 import org.antlr.v4.runtime.misc.Interval;
 
 public class AndExpression extends BaseBinaryExpression {
@@ -12,7 +11,7 @@ public AndExpression(Interval expressionInterval, String expressionText, Express
     }
 
     @Override
-    Object evaluate(EvaluationRuntime runtime, Object left, Object right, ExceptionThrower exceptions) {
+    public Object evaluate(EvaluationRuntime runtime, Object left, Object right, ExceptionThrower exceptions) {
         boolean x = castToBoolean(runtime, exceptions, left);
         if (!x) {
             // Short circuit

sql/src/main/java/io/cloudevents/sql/impl/expressions/BaseBinaryExpression.java

@@ -3,26 +3,48 @@
 import io.cloudevents.CloudEvent;
 import io.cloudevents.sql.EvaluationRuntime;
 import io.cloudevents.sql.impl.ExceptionThrower;
-import io.cloudevents.sql.impl.ExpressionInternal;
 import org.antlr.v4.runtime.misc.Interval;
 
 public abstract class BaseBinaryExpression extends BaseExpression {
 
-    protected final ExpressionInternal leftOperand;
-    protected final ExpressionInternal rightOperand;
+    protected ExpressionInternal leftOperand;
+    protected ExpressionInternal rightOperand;
 
     protected BaseBinaryExpression(Interval expressionInterval, String expressionText, ExpressionInternal leftOperand, ExpressionInternal rightOperand) {
         super(expressionInterval, expressionText);
         this.leftOperand = leftOperand;
         this.rightOperand = rightOperand;
     }
 
-    abstract Object evaluate(EvaluationRuntime runtime, Object left, Object right, ExceptionThrower exceptions);
+    public abstract Object evaluate(EvaluationRuntime runtime, Object left, Object right, ExceptionThrower exceptions);
 
     @Override
     public Object evaluate(EvaluationRuntime runtime, CloudEvent event, ExceptionThrower thrower) {
         Object left = leftOperand.evaluate(runtime, event, thrower);
         Object right = rightOperand.evaluate(runtime, event, thrower);
         return evaluate(runtime, left, right, thrower);
     }
+
+    @Override
+    public <T> T visit(ExpressionInternalVisitor<T> visitor) {
+        return visitor.visitBaseBinaryExpression(this);
+    }
+
+    public ExpressionInternal getLeftOperand() {
+        return leftOperand;
+    }
+
+    public ExpressionInternal getRightOperand() {
+        return rightOperand;
+    }
+
+    public BaseBinaryExpression setLeftOperand(ExpressionInternal leftOperand) {
+        this.leftOperand = leftOperand;
+        return this;
+    }
+
+    public BaseBinaryExpression setRightOperand(ExpressionInternal rightOperand) {
+        this.rightOperand = rightOperand;
+        return this;
+    }
 }