Add a --preserve-type-order option (#6916)

Unlike other module elements, types are not stored on the `Module`.
Instead, they are collected by traversing the IR before printing and
binary writing. The code that collects the types tries to optimize the
order of rec groups based on the number of times each type is used. As a
result, the output order of types generally has no relation to the input
order of types. In addition, most type optimizations rewrite the types
into a single large rec group, and the order of types in that group is
essentially arbitrary. Changes to the code for counting type uses,
sorting types, or sorting rec groups can yield very large changes in the
output order of types, producing test diffs that are hard to review and
potentially harming the readability of tests by moving output types away
from the corresponding input types.

To help make test output more stable and readable, introduce a tool
option that causes the order of output types to match the order of input
types as closely as possible. It is implemented by having the parsers
record the indices of the input types on the `Module` just like they
already record the type names. The `GlobalTypeRewriter` infrastructure
used by type optimizations associates the new types with the old indices
just like it already does for names and also respects the input order
when rewriting types into a large recursion group.

By default, wasm-opt and other tools clear the recorded type indices
after parsing the module, so their default behavior is not modified by
this change.

Follow-on PRs will use the new flag in more tests, which will generate
large diffs but leave the tests in stable, more readable states that
will no longer change due to other changes to the optimizing type
sorting logic.

1 files changed, 9 insertions, 0 deletions

diff --git a/src/passes/RoundTrip.cpp b/src/passes/RoundTrip.cpp
index 129b89ac8..123752f79 100644
--- a/src/passes/RoundTrip.cpp
+++ b/src/passes/RoundTrip.cpp
@@ -40,6 +40,11 @@ struct RoundTrip : public Pass {
     // the target features section has been stripped. We also need them in order
     // to tell the builder which features to build with.
     auto features = module->features;
+
+    // We need to know whether we should preserve the type order when we read
+    // the module back in.
+    bool preserveTypeOrder = !module->typeIndices.empty();
+
     // Write, clear, and read the module
     WasmBinaryWriter(module, buffer, getPassOptions()).write();
     ModuleUtils::clearModule(*module);
@@ -53,6 +58,10 @@ struct RoundTrip : public Pass {
       std::cerr << '\n';
       Fatal() << "error in parsing wasm binary";
     }
+
+    if (!preserveTypeOrder) {
+      module->typeIndices.clear();
+    }
   }
 };