[Java] Ensure Java code generation for precedence checks always produces the same code without re-orderings.

Author: vyazelenko

sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/common/FieldPrecedenceModel.java

@@ -45,12 +45,12 @@ public final class FieldPrecedenceModel
     private final CodecInteraction.CodecInteractionFactory interactionFactory =
         new CodecInteraction.CodecInteractionFactory(groupPathsByField, topLevelBlockFields);
     private final Map<CodecInteraction, List<TransitionGroup>> transitionsByInteraction = new LinkedHashMap<>();
-    private final Map<State, List<TransitionGroup>> transitionsByState = new HashMap<>();
+    private final Map<State, List<TransitionGroup>> transitionsByState = new TreeMap<>();
     private final TreeMap<Integer, State> versionWrappedStates = new TreeMap<>();
     private final State notWrappedState = allocateState("NOT_WRAPPED");
     private final String generatedRepresentationClassName;
     private State encoderWrappedState;
-    private Set<State> terminalEncoderStates;
+    private SortedSet<State> terminalEncoderStates;
 
     private FieldPrecedenceModel(final String generatedRepresentationClassName)
     {
@@ -135,9 +135,7 @@ public void forEachTerminalEncoderState(final Consumer<State> consumer)
      */
     public void forEachStateOrderedByStateNumber(final Consumer<State> consumer)
     {
-        transitionsByState.keySet().stream()
-            .sorted(Comparator.comparingInt((s) -> s.number))
-            .forEach(consumer);
+        transitionsByState.keySet().forEach(consumer);
     }
 
     /**
@@ -273,7 +271,7 @@ private void findTransitions(
 
                 // Last writer (highest version) wins when there are multiple versions
                 encoderWrappedState = versionWrappedState;
-                terminalEncoderStates = transitionCollector.exitStates();
+                terminalEncoderStates = new TreeSet<>(transitionCollector.exitStates());
             });
     }
 
@@ -459,7 +457,7 @@ public void onVarData(final Token token)
     private final class TransitionCollector implements SchemaConsumer
     {
         private final String statePrefix;
-        private final HashSet<State> currentStates;
+        private final Set<State> currentStates;
         private final State blockState;
         private final Predicate<Token> filter;
 
@@ -470,7 +468,7 @@ private TransitionCollector(
             final Predicate<Token> filter)
         {
             this.statePrefix = statePrefix;
-            this.currentStates = new HashSet<>(fromStates);
+            this.currentStates = new TreeSet<>(fromStates);
             this.blockState = blockState;
             this.filter = filter;
 
@@ -585,7 +583,7 @@ private Set<State> exitStates()
     /**
      * A state in which a codec may reside.
      */
-    public static final class State
+    public static final class State implements Comparable<State>
     {
         private final int number;
         private final String name;
@@ -615,6 +613,19 @@ public String name()
             return name;
         }
 
+        /**
+         * {@inheritDoc}.
+         */
+        public int compareTo(final State other)
+        {
+            final int result = Integer.compare(number, other.number);
+            if (0 != result)
+            {
+                return result;
+            }
+            return name.compareTo(other.name);
+        }
+
         /**
          * {@inheritDoc}
          */
@@ -642,7 +653,7 @@ private TransitionGroup(
             final State to)
         {
             this.interaction = interaction;
-            this.from = new HashSet<>(from);
+            this.from = new TreeSet<>(from);
             this.to = to;
         }
 

sbe-tool/src/test/java/uk/co/real_logic/sbe/generation/java/JavaGeneratorDeterminismTest.java

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2013-2025 Real Logic Limited.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package uk.co.real_logic.sbe.generation.java;
+
+import org.agrona.DirectBuffer;
+import org.agrona.MutableDirectBuffer;
+import org.agrona.generation.StringWriterOutputManager;
+import org.junit.jupiter.api.Test;
+import uk.co.real_logic.sbe.Tests;
+import uk.co.real_logic.sbe.generation.common.PrecedenceChecks;
+import uk.co.real_logic.sbe.ir.Ir;
+import uk.co.real_logic.sbe.xml.IrGenerator;
+import uk.co.real_logic.sbe.xml.MessageSchema;
+import uk.co.real_logic.sbe.xml.ParserOptions;
+
+import java.io.InputStream;
+import java.util.Map;
+import java.util.TreeMap;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static uk.co.real_logic.sbe.xml.XmlSchemaParser.parse;
+
+/**
+ * Tests that generated code is deterministic when precedence checks are enabled.
+ */
+class JavaGeneratorDeterminismTest
+{
+    private static final String BUFFER_NAME = MutableDirectBuffer.class.getName();
+    private static final String READ_ONLY_BUFFER_NAME = DirectBuffer.class.getName();
+
+    @Test
+    void shouldGenerateDeterministicOutputWithPrecedenceChecks() throws Exception
+    {
+        final Map<String, CharSequence> firstGeneration = generateWithPrecedenceChecks();
+        final Map<String, CharSequence> secondGeneration = generateWithPrecedenceChecks();
+
+        assertEquals(firstGeneration.keySet(), secondGeneration.keySet());
+
+        for (final String fileName : firstGeneration.keySet())
+        {
+            final CharSequence firstSource = firstGeneration.get(fileName);
+            final CharSequence secondSource = secondGeneration.get(fileName);
+            assertEquals(firstSource, secondSource);
+        }
+    }
+
+    private Map<String, CharSequence> generateWithPrecedenceChecks() throws Exception
+    {
+        try (InputStream in = Tests.getLocalResource("field-order-check-schema.xml"))
+        {
+            final ParserOptions options = ParserOptions.builder().stopOnError(true).build();
+            final MessageSchema schema = parse(in, options);
+            final IrGenerator irg = new IrGenerator();
+            final Ir ir = irg.generate(schema);
+            final StringWriterOutputManager outputManager = new StringWriterOutputManager();
+            outputManager.setPackageName(ir.applicableNamespace());
+            final PrecedenceChecks.Context context = new PrecedenceChecks.Context()
+                .shouldGeneratePrecedenceChecks(true);
+            final PrecedenceChecks precedenceChecks = PrecedenceChecks.newInstance(context);
+            final JavaGenerator generator = new JavaGenerator(
+                ir, BUFFER_NAME, READ_ONLY_BUFFER_NAME, false, false, false, false, precedenceChecks, outputManager);
+            generator.generate();
+            return new TreeMap<>(outputManager.getSources());
+        }
+    }
+}