Use rolling bytecode version, address PR

Instead of a major.minor version in the bytecode, we can just use a
simpler approach of a rolling bytecode version, and more simply the
version of the implementation has to be >= the version in the loaded
bytecode.

Author: mtdowling

client/client-core/src/main/java/software/amazon/smithy/java/client/core/endpoint/EndpointImpl.java

@@ -8,6 +8,7 @@
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -23,8 +24,8 @@ final class EndpointImpl implements Endpoint {
 
     private EndpointImpl(Builder builder) {
         this.uri = Objects.requireNonNull(builder.uri);
-        this.authSchemes = builder.authSchemes == null ? List.of() : builder.authSchemes;
-        this.properties = builder.properties == null ? Map.of() : builder.properties;
+        this.authSchemes = builder.authSchemes == null ? List.of() : Collections.unmodifiableList(builder.authSchemes);
+        this.properties = builder.properties == null ? Map.of() : Collections.unmodifiableMap(builder.properties);
         // Clear out the builder, making this class immutable and the builder still reusable.
         builder.authSchemes = null;
         builder.properties = null;

client/client-rulesengine/src/main/java/software/amazon/smithy/java/client/rulesengine/Bytecode.java

@@ -30,7 +30,7 @@
  * Offset  Size  Description
  * ------  ----  -----------
  * 0       4     Magic number (0x52554C45 = "RULE")
- * 4       2     Version (major.minor, currently 0x0101 = 1.1)
+ * 4       2     Version (rolling version number, currently 1)
  * 6       2     Condition count (unsigned short)
  * 8       2     Result count (unsigned short)
  * 10      2     Register count (unsigned short)
@@ -152,14 +152,15 @@
 public final class Bytecode {
 
     static final int MAGIC = 0x52554C45; // "RULE"
-    static final short VERSION = 0x0101; // 1.1
+    static final short VERSION = 1;
     static final byte CONST_NULL = 0;
     static final byte CONST_STRING = 1;
     static final byte CONST_INTEGER = 2;
     static final byte CONST_BOOLEAN = 3;
     static final byte CONST_LIST = 4;
     static final byte CONST_MAP = 5;
 
+    private final short version;
     private final byte[] bytecode;
     private final int[] conditionOffsets;
     private final int[] resultOffsets;
@@ -187,6 +188,28 @@ public final class Bytecode {
             RulesFunction[] functions,
             int[] bddNodes,
             int bddRootRef
+    ) {
+        this(bytecode,
+                conditionOffsets,
+                resultOffsets,
+                registerDefinitions,
+                constantPool,
+                functions,
+                bddNodes,
+                bddRootRef,
+                VERSION);
+    }
+
+    Bytecode(
+            byte[] bytecode,
+            int[] conditionOffsets,
+            int[] resultOffsets,
+            RegisterDefinition[] registerDefinitions,
+            Object[] constantPool,
+            RulesFunction[] functions,
+            int[] bddNodes,
+            int bddRootRef,
+            short version
     ) {
         if (bddNodes.length % 3 != 0) {
             throw new IllegalArgumentException("BDD nodes length must be multiple of 3, got: " + bddNodes.length);
@@ -205,6 +228,16 @@ public final class Bytecode {
         this.builtinIndices = findBuiltinIndices(registerDefinitions);
         this.hardRequiredIndices = findRequiredIndicesWithoutDefaultsOrBuiltins(registerDefinitions);
         this.inputRegisterMap = createInputRegisterMap(registerDefinitions);
+        this.version = version;
+    }
+
+    /**
+     * Get the bytecode version.
+     *
+     * @return bytecode version number.
+     */
+    public short getVersion() {
+        return version;
     }
 
     /**

client/client-rulesengine/src/main/java/software/amazon/smithy/java/client/rulesengine/BytecodeDisassembler.java

@@ -139,6 +139,7 @@ String disassemble() {
         StringBuilder s = new StringBuilder();
 
         s.append("=== Bytecode Program ===\n");
+        s.append("Version: ").append(bytecode.getVersion()).append("\n");
         s.append("Conditions: ").append(bytecode.getConditionCount()).append("\n");
         s.append("Results: ").append(bytecode.getResultCount()).append("\n");
         s.append("Registers: ").append(bytecode.getRegisterDefinitions().length).append("\n");

client/client-rulesengine/src/main/java/software/amazon/smithy/java/client/rulesengine/BytecodeReader.java

@@ -40,6 +40,10 @@ short readShort() {
         return (short) value;
     }
 
+    int readUnsignedShort() {
+        return readShort() & 0xFFFF;
+    }
+
     int readInt() {
         checkBounds(4);
         int value = (data[offset] & 0xFF) << 24;

client/client-rulesengine/src/main/java/software/amazon/smithy/java/client/rulesengine/BytecodeWriter.java

@@ -18,7 +18,7 @@
  * Builds up bytecode incrementally.
  */
 final class BytecodeWriter {
-    private static final int MAX_CONSTANTS = 65536;
+    private static final int MAX_CONSTANTS = 0xFFFF + 1;
 
     private final ByteArrayOutputStream bytecodeStream = new ByteArrayOutputStream();
     private final List<Integer> conditionOffsets = new ArrayList<>();
@@ -45,7 +45,7 @@ void writeByte(int value) {
     }
 
     void writeShort(int value) {
-        if (value < 0 || value > 65535) {
+        if (value < 0 || value > 0xFFFF) {
             throw new IllegalArgumentException("Value out of range for unsigned short: " + value);
         }
         bytecodeStream.write((value >> 8) & 0xFF);

client/client-rulesengine/src/main/java/software/amazon/smithy/java/client/rulesengine/RegisterFiller.java

@@ -108,7 +108,7 @@ static RegisterFiller of(Bytecode bytecode, Map<String, Function<Context, Object
         }
     }
 
-    // Fast implementation for <= 64 registers using single long bitmasks.
+    // Fast implementation for < 64 registers using single long bitmasks.
     private static final class FastRegisterFiller extends RegisterFiller {
         private final long builtinMask;
         private final long requiredMask;

client/client-rulesengine/src/main/java/software/amazon/smithy/java/client/rulesengine/RulesEngineBuilder.java

@@ -34,6 +34,12 @@ public final class RulesEngineBuilder {
         }
     }
 
+    private static final int BYTECODE_HEADER_SIZE = Integer.BYTES // magic number
+            + Short.BYTES // version
+            + (5 * Short.BYTES) // counts
+            + (2 * Integer.BYTES) // bddNodeCount, bddRootRef
+            + (5 * Integer.BYTES); // offsets
+
     private final List<RulesExtension> extensions = new ArrayList<>();
     private final Map<String, RulesFunction> functions = new LinkedHashMap<>();
     private final Map<String, Function<Context, Object>> builtinProviders = new HashMap<>();
@@ -138,25 +144,19 @@ public Bytecode load(byte[] data) {
         }
 
         short version = reader.readShort();
-        if (version != Bytecode.VERSION) {
-            int major = (version >> 8) & 0xFF;
-            int minor = version & 0xFF;
-            int expectedMajor = (Bytecode.VERSION >> 8) & 0xFF;
-            int expectedMinor = Bytecode.VERSION & 0xFF;
+        if (version > Bytecode.VERSION) {
             throw new IllegalArgumentException(String.format(
-                    "Unsupported bytecode version: %d.%d (expected %d.%d)",
-                    major,
-                    minor,
-                    expectedMajor,
-                    expectedMinor));
+                    "Unsupported bytecode version: %d (maximum supported: %d)",
+                    version,
+                    Bytecode.VERSION));
         }
 
         // Read counts
-        int conditionCount = reader.readShort() & 0xFFFF;
-        int resultCount = reader.readShort() & 0xFFFF;
-        int registerCount = reader.readShort() & 0xFFFF;
-        int constantCount = reader.readShort() & 0xFFFF;
-        int functionCount = reader.readShort() & 0xFFFF;
+        int conditionCount = reader.readUnsignedShort();
+        int resultCount = reader.readUnsignedShort();
+        int registerCount = reader.readUnsignedShort();
+        int constantCount = reader.readUnsignedShort();
+        int functionCount = reader.readUnsignedShort();
         int bddNodeCount = reader.readInt();
         int bddRootRef = reader.readInt();
 
@@ -172,7 +172,7 @@ public Bytecode load(byte[] data) {
         int bddTableOffset = reader.readInt();
 
         // Validate offsets are within bounds and in expected order
-        if (conditionTableOffset < 44
+        if (conditionTableOffset < BYTECODE_HEADER_SIZE
                 || conditionTableOffset > data.length
                 || resultTableOffset < conditionTableOffset
                 || resultTableOffset > data.length
@@ -253,7 +253,8 @@ public Bytecode load(byte[] data) {
                 constantPool,
                 resolvedFunctions,
                 bddNodes,
-                bddRootRef);
+                bddRootRef,
+                version);
     }
 
     private RulesFunction[] loadFunctions(BytecodeReader reader, int count) {