Simplify condition handling in CFG and BDD

This also revealed a bug in the BDD compilation process that was
causing negated nodes to get added twice.

Author: mtdowling

smithy-rules-engine/src/main/java/software/amazon/smithy/rulesengine/language/syntax/expressions/Expression.java

@@ -36,6 +36,8 @@
 @SmithyUnstableApi
 public abstract class Expression extends SyntaxElement implements FromSourceLocation, ToNode, TypeCheck {
     private final SourceLocation sourceLocation;
+    private Integer cachedComplexity;
+    private Set<String> cachedReferences;
     private Type cachedType;
 
     public Expression(SourceLocation sourceLocation) {
@@ -147,10 +149,43 @@ public static Literal getLiteral(StringNode node) {
      *
      * @return variable references by name.
      */
-    public Set<String> getReferences() {
+    public final Set<String> getReferences() {
+        if (cachedReferences == null) {
+            cachedReferences = Collections.unmodifiableSet(calculateReferences());
+        }
+        return cachedReferences;
+    }
+
+    /**
+     * Computes the references of an expression.
+     *
+     * @return the computed references.
+     */
+    protected Set<String> calculateReferences() {
         return Collections.emptySet();
     }
 
+    /**
+     * Get the complexity heuristic of the expression, based on functions, references, etc.
+     *
+     * @return the complexity heuristic.
+     */
+    public final int getComplexity() {
+        if (cachedComplexity == null) {
+            cachedComplexity = calculateComplexity();
+        }
+        return cachedComplexity;
+    }
+
+    /**
+     * Calculates the complexity of the expression, to be overridden by implementations.
+     *
+     * @return complexity estimate.
+     */
+    protected int calculateComplexity() {
+        return 1;
+    }
+
     /**
      * Invoke the {@link ExpressionVisitor} functions for this expression.
      *

smithy-rules-engine/src/main/java/software/amazon/smithy/rulesengine/language/syntax/expressions/Reference.java

@@ -50,7 +50,7 @@ public String template() {
     }
 
     @Override
-    public Set<String> getReferences() {
+    protected Set<String> calculateReferences() {
         return Collections.singleton(getName().toString());
     }
 

smithy-rules-engine/src/main/java/software/amazon/smithy/rulesengine/language/syntax/expressions/functions/LibraryFunction.java

@@ -48,7 +48,7 @@ public String getName() {
     }
 
     @Override
-    public Set<String> getReferences() {
+    protected Set<String> calculateReferences() {
         Set<String> references = new LinkedHashSet<>();
         for (Expression arg : getArguments()) {
             references.addAll(arg.getReferences());
@@ -245,4 +245,13 @@ private static boolean isReference(Expression arg) {
         }
         return false;
     }
+
+    @Override
+    protected int calculateComplexity() {
+        int complexity = getFunctionDefinition().getCostHeuristic();
+        for (Expression arg : getArguments()) {
+            complexity += arg.getComplexity();
+        }
+        return complexity;
+    }
 }

smithy-rules-engine/src/main/java/software/amazon/smithy/rulesengine/language/syntax/expressions/literal/RecordLiteral.java

@@ -76,11 +76,20 @@ public Node toNode() {
     }
 
     @Override
-    public Set<String> getReferences() {
+    protected Set<String> calculateReferences() {
         Set<String> references = new LinkedHashSet<>();
         for (Literal value : members().values()) {
             references.addAll(value.getReferences());
         }
         return references;
     }
+
+    @Override
+    protected int calculateComplexity() {
+        int complexity = 1;
+        for (Literal value : members().values()) {
+            complexity += value.getComplexity();
+        }
+        return complexity;
+    }
 }

smithy-rules-engine/src/main/java/software/amazon/smithy/rulesengine/language/syntax/expressions/literal/StringLiteral.java

@@ -71,7 +71,7 @@ public Node toNode() {
     }
 
     @Override
-    public Set<String> getReferences() {
+    protected Set<String> calculateReferences() {
         Template template = value();
         if (template.isStatic()) {
             return Collections.emptySet();
@@ -86,4 +86,27 @@ public Set<String> getReferences() {
 
         return references;
     }
+
+    @Override
+    protected int calculateComplexity() {
+        Template template = value();
+        if (template.isStatic()) {
+            return 1;
+        }
+
+        int complexity = 1;
+        if (template.getParts().size() > 1) {
+            // Multiple parts are expensive
+            complexity += 8;
+        }
+
+        for (Template.Part part : template.getParts()) {
+            if (part instanceof Template.Dynamic) {
+                Template.Dynamic dynamic = (Template.Dynamic) part;
+                complexity += dynamic.toExpression().getComplexity();
+            }
+        }
+
+        return complexity;
+    }
 }

smithy-rules-engine/src/main/java/software/amazon/smithy/rulesengine/language/syntax/expressions/literal/TupleLiteral.java

@@ -82,11 +82,20 @@ public Node toNode() {
     }
 
     @Override
-    public Set<String> getReferences() {
+    protected Set<String> calculateReferences() {
         Set<String> references = new LinkedHashSet<>();
         for (Literal member : members()) {
             references.addAll(member.getReferences());
         }
         return references;
     }
+
+    @Override
+    protected int calculateComplexity() {
+        int complexity = 1;
+        for (Literal member : members()) {
+            complexity += member.getComplexity();
+        }
+        return complexity;
+    }
 }