Declare some fuzzing members as const (#8255)

Followup to
#8253 (comment).
Allow us to declare `loggableTypes` and `atomicMemoryOrders` as const to
prevent them from being mutated by mistake.

Author: stevenfontanella

src/tools/fuzzing.h

@@ -194,7 +194,7 @@ class TranslateToFuzzReader {
   std::unordered_map<Type, std::vector<Name>> immutableGlobalsByType;
   std::unordered_map<Type, std::vector<Name>> importedImmutableGlobalsByType;
 
-  std::vector<Type> loggableTypes;
+  const std::vector<Type> loggableTypes;
 
   // The heap types we can pick from to generate instructions.
   std::vector<HeapType> interestingHeapTypes;
@@ -276,7 +276,7 @@ class TranslateToFuzzReader {
   // overridden using another context in an RAII manner).
   std::unique_ptr<FuzzParamsContext> globalParams;
 
-  std::vector<MemoryOrder> atomicMemoryOrders;
+  const std::vector<MemoryOrder> atomicMemoryOrders;
 
 public:
   int nesting = 0;

src/tools/fuzzing/fuzzing.cpp

@@ -29,35 +29,49 @@
 
 namespace wasm {
 
-TranslateToFuzzReader::TranslateToFuzzReader(Module& wasm,
-                                             std::vector<char>&& input,
-                                             bool closedWorld)
-  : wasm(wasm), closedWorld(closedWorld), builder(wasm),
-    random(std::move(input), wasm.features),
-    publicTypeValidator(wasm.features) {
-
-  atomicMemoryOrders = wasm.features.hasRelaxedAtomics()
-                         ? std::vector{MemoryOrder::AcqRel, MemoryOrder::SeqCst}
-                         : std::vector{MemoryOrder::SeqCst};
+namespace {
 
-  haveInitialFunctions = !wasm.functions.empty();
-
-  loggableTypes = {Type::i32, Type::i64, Type::f32, Type::f64};
-  if (wasm.features.hasSIMD()) {
+std::vector<Type> getLoggableTypes(const FeatureSet& features) {
+  std::vector<Type> loggableTypes = {
+    Type::i32, Type::i64, Type::f32, Type::f64};
+  if (features.hasSIMD()) {
     loggableTypes.push_back(Type::v128);
   }
-  if (wasm.features.hasReferenceTypes()) {
-    if (wasm.features.hasGC()) {
+  if (features.hasReferenceTypes()) {
+    if (features.hasGC()) {
       loggableTypes.push_back(Type(HeapType::any, Nullable));
       loggableTypes.push_back(Type(HeapType::func, Nullable));
       loggableTypes.push_back(Type(HeapType::ext, Nullable));
     }
-    if (wasm.features.hasStackSwitching()) {
+    if (features.hasStackSwitching()) {
       loggableTypes.push_back(Type(HeapType::cont, Nullable));
     }
     // Note: exnref traps on the JS boundary, so we cannot try to log it.
   }
 
+  return loggableTypes;
+}
+
+std::vector<MemoryOrder> getMemoryOrders(const FeatureSet& features) {
+  return features.hasRelaxedAtomics()
+           ? std::vector{MemoryOrder::AcqRel, MemoryOrder::SeqCst}
+           : std::vector{MemoryOrder::SeqCst};
+}
+
+} // namespace
+
+TranslateToFuzzReader::TranslateToFuzzReader(Module& wasm,
+                                             std::vector<char>&& input,
+                                             bool closedWorld)
+  : wasm(wasm), closedWorld(closedWorld), builder(wasm),
+    random(std::move(input), wasm.features),
+    loggableTypes(getLoggableTypes(wasm.features)),
+    atomicMemoryOrders(getMemoryOrders(wasm.features)),
+
+    publicTypeValidator(wasm.features) {
+
+  haveInitialFunctions = !wasm.functions.empty();
+
   // Setup params. Start with the defaults.
   globalParams = std::make_unique<FuzzParamsContext>(*this);