Improve initial ordering and add coalesce

Our previous initial ordering could result in pathalogical orderings
if it decided to moving something very early from the CFG to very late.
This is in fact what happened when I added a coalesce method: it moved
an early discriminating condition to very late, which blew up the
BDD from ~40K nodes to 5.1M. This taught me that we really shouldn't
throw away the ordering found in the CFG, and instead should leverage
it when determining the initial ordering since it inherently gates
logic and keeps related conditions together.

So now the initial ordering is based on the CFG ordering and also on
cone analysis (basically how many downstream nodes a node affects).
We now get an initial ordering ~3K nodes, and with the coalesce method,
we can now sift S3 down to ~800 nodes instead of ~1000.

The coalesce function is added here so that we can fold bind-then-test
conditions into a single condition. The current endpoints type system
has strict nullability requirements. So you can't do a substring test
and pass that directly into something that expects a non-null value.
You have to first do the nullable function, then assign that to a value,
then the next condition is inherently guarded and only called if the
assigned value is non-null (the assignment acts as an implicit guard).
The coalsce function allows us to identify these patterns and inline
the test into a single condition by defaulting null to the zero value
of the return type (integer=0, string="", array=[]). We only coalesce
when the comparison is not to literally the zero value. When coalesce
was added, it uncovered the original brittle ordering, leading to the
much improved ordering in this PR.

Author: mtdowling

smithy-aws-endpoints/src/main/java/software/amazon/smithy/rulesengine/aws/language/functions/AwsPartition.java

@@ -184,11 +184,6 @@ public Value evaluate(List<Value> arguments) {
         public AwsPartition createFunction(FunctionNode functionNode) {
             return new AwsPartition(functionNode);
         }
-
-        @Override
-        public int getCostHeuristic() {
-            return 6;
-        }
     }
 
     /**

smithy-aws-endpoints/src/main/java/software/amazon/smithy/rulesengine/aws/language/functions/IsVirtualHostableS3Bucket.java

@@ -97,11 +97,6 @@ public Value evaluate(List<Value> arguments) {
         public IsVirtualHostableS3Bucket createFunction(FunctionNode functionNode) {
             return new IsVirtualHostableS3Bucket(functionNode);
         }
-
-        @Override
-        public int getCostHeuristic() {
-            return 8;
-        }
     }
 
     /**

smithy-aws-endpoints/src/main/java/software/amazon/smithy/rulesengine/aws/language/functions/ParseArn.java

@@ -125,10 +125,5 @@ public Value evaluate(List<Value> arguments) {
         public ParseArn createFunction(FunctionNode functionNode) {
             return new ParseArn(functionNode);
         }
-
-        @Override
-        public int getCostHeuristic() {
-            return 9;
-        }
     }
 }

smithy-rules-engine/src/main/java/software/amazon/smithy/rulesengine/language/evaluation/type/ArrayType.java

@@ -4,12 +4,17 @@
  */
 package software.amazon.smithy.rulesengine.language.evaluation.type;
 
+import java.util.Collections;
 import java.util.Objects;
+import java.util.Optional;
+import software.amazon.smithy.rulesengine.language.syntax.expressions.literal.Literal;
 
 /**
  * The "array" type, which contains entries of a member type.
  */
 public final class ArrayType extends AbstractType {
+
+    private static final Optional<Literal> ZERO = Optional.of(Literal.tupleLiteral(Collections.emptyList()));
     private final Type member;
 
     ArrayType(Type member) {
@@ -51,4 +56,9 @@ public int hashCode() {
     public String toString() {
         return String.format("ArrayType[%s]", member);
     }
+
+    @Override
+    public Optional<Literal> getZeroValue() {
+        return ZERO;
+    }
 }

smithy-rules-engine/src/main/java/software/amazon/smithy/rulesengine/language/evaluation/type/BooleanType.java

@@ -4,11 +4,15 @@
  */
 package software.amazon.smithy.rulesengine.language.evaluation.type;
 
+import java.util.Optional;
+import software.amazon.smithy.rulesengine.language.syntax.expressions.literal.Literal;
+
 /**
  * The "boolean" type.
  */
 public final class BooleanType extends AbstractType {
 
+    private static final Optional<Literal> ZERO = Optional.of(Literal.of(false));
     static final BooleanType INSTANCE = new BooleanType();
 
     BooleanType() {}
@@ -17,4 +21,9 @@ public final class BooleanType extends AbstractType {
     public BooleanType expectBooleanType() {
         return this;
     }
+
+    @Override
+    public Optional<Literal> getZeroValue() {
+        return ZERO;
+    }
 }

smithy-rules-engine/src/main/java/software/amazon/smithy/rulesengine/language/evaluation/type/IntegerType.java

@@ -4,11 +4,15 @@
  */
 package software.amazon.smithy.rulesengine.language.evaluation.type;
 
+import java.util.Optional;
+import software.amazon.smithy.rulesengine.language.syntax.expressions.literal.Literal;
+
 /**
  * The "integer" type.
  */
 public final class IntegerType extends AbstractType {
 
+    private static final Optional<Literal> ZERO = Optional.of(Literal.of(0));
     static final IntegerType INSTANCE = new IntegerType();
 
     IntegerType() {}
@@ -17,4 +21,9 @@ public final class IntegerType extends AbstractType {
     public IntegerType expectIntegerType() {
         return this;
     }
+
+    @Override
+    public Optional<Literal> getZeroValue() {
+        return ZERO;
+    }
 }

smithy-rules-engine/src/main/java/software/amazon/smithy/rulesengine/language/evaluation/type/OptionalType.java

@@ -5,7 +5,9 @@
 package software.amazon.smithy.rulesengine.language.evaluation.type;
 
 import java.util.Objects;
+import java.util.Optional;
 import software.amazon.smithy.rulesengine.language.error.InnerParseError;
+import software.amazon.smithy.rulesengine.language.syntax.expressions.literal.Literal;
 
 /**
  * The "optional" type, a container for a type that may or may not be present.
@@ -78,4 +80,9 @@ public int hashCode() {
     public String toString() {
         return String.format("OptionalType[%s]", inner);
     }
+
+    @Override
+    public Optional<Literal> getZeroValue() {
+        return inner.getZeroValue();
+    }
 }

smithy-rules-engine/src/main/java/software/amazon/smithy/rulesengine/language/evaluation/type/StringType.java

@@ -4,11 +4,15 @@
  */
 package software.amazon.smithy.rulesengine.language.evaluation.type;
 
+import java.util.Optional;
+import software.amazon.smithy.rulesengine.language.syntax.expressions.literal.Literal;
+
 /**
  * The "string" type.
  */
 public final class StringType extends AbstractType {
 
+    private static final Optional<Literal> ZERO = Optional.of(Literal.of(""));
     static final StringType INSTANCE = new StringType();
 
     StringType() {}
@@ -17,4 +21,9 @@ public final class StringType extends AbstractType {
     public StringType expectStringType() {
         return this;
     }
+
+    @Override
+    public Optional<Literal> getZeroValue() {
+        return ZERO;
+    }
 }

smithy-rules-engine/src/main/java/software/amazon/smithy/rulesengine/language/evaluation/type/Type.java

@@ -6,8 +6,10 @@
 
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import software.amazon.smithy.rulesengine.language.error.InnerParseError;
 import software.amazon.smithy.rulesengine.language.syntax.Identifier;
+import software.amazon.smithy.rulesengine.language.syntax.expressions.literal.Literal;
 import software.amazon.smithy.rulesengine.language.syntax.parameters.ParameterType;
 import software.amazon.smithy.utils.SmithyUnstableApi;
 
@@ -129,4 +131,17 @@ default StringType expectStringType() throws InnerParseError {
     default TupleType expectTupleType() throws InnerParseError {
         throw new InnerParseError("Expected tuple but found " + this);
     }
+
+    /**
+     * Gets the default zero-value of the type as a Literal.
+     *
+     * <p>Strings, booleans, integers, and arrays have zero values. Other types do not. E.g., a map might have
+     * required properties, and the behavior of a tuple _seems_ to imply that each member is required. Optionals
+     * return the zero value of its inner type.
+     *
+     * @return the default zero value.
+     */
+    default Optional<Literal> getZeroValue() {
+        return Optional.empty();
+    }
 }

smithy-rules-engine/src/main/java/software/amazon/smithy/rulesengine/language/evaluation/value/BooleanValue.java

@@ -14,9 +14,17 @@
  * A boolean value of true or false.
  */
 public final class BooleanValue extends Value {
+
+    static final BooleanValue TRUE = new BooleanValue(true);
+    static final BooleanValue FALSE = new BooleanValue(false);
+
     private final boolean value;
 
-    BooleanValue(boolean value) {
+    static BooleanValue create(boolean v) {
+        return v ? TRUE : FALSE;
+    }
+
+    private BooleanValue(boolean value) {
         super(SourceLocation.none());
         this.value = value;
     }