[NFC] Share the "simple combinable bool" logic among StructValues users (#7875)

This mostly just avoids code duplication, but the CFP version was
actually also inefficient (combine returned true more than it
should, possibly leading to wasted work).

Author: kripken

src/ir/struct-utils.h

@@ -29,6 +29,25 @@ using StructField = std::pair<HeapType, Index>;
 
 namespace StructUtils {
 
+// A value that has a single bool, and implements combine() so it can be used in
+// StructValues.
+struct CombinableBool {
+  bool value = false;
+
+  CombinableBool() {}
+  CombinableBool(bool value) : value(value) {}
+
+  operator bool() const { return value; }
+
+  bool combine(const CombinableBool& other) {
+    if (!value && other.value) {
+      value = true;
+      return true;
+    }
+    return false;
+  }
+};
+
 // A vector of a template type's values. One such vector will be used per struct
 // type, where each element in the vector represents a field. We always assume
 // that the vectors are pre-initialized to the right length before accessing any

src/passes/ConstantFieldPropagation.cpp

@@ -71,21 +71,10 @@ using PCVStructValuesMap = StructUtils::StructValuesMap<PossibleConstantValues>;
 using PCVFunctionStructValuesMap =
   StructUtils::FunctionStructValuesMap<PossibleConstantValues>;
 
-// A wrapper for a boolean value that provides a combine() method as is used in
-// the StructUtils propagation logic.
-struct Bool {
-  bool value = false;
-
-  Bool() {}
-  Bool(bool value) : value(value) {}
-
-  operator bool() const { return value; }
-
-  bool combine(bool other) { return value = value || other; }
-};
-
-using BoolStructValuesMap = StructUtils::StructValuesMap<Bool>;
-using BoolFunctionStructValuesMap = StructUtils::FunctionStructValuesMap<Bool>;
+using BoolStructValuesMap =
+  StructUtils::StructValuesMap<StructUtils::CombinableBool>;
+using BoolFunctionStructValuesMap =
+  StructUtils::FunctionStructValuesMap<StructUtils::CombinableBool>;
 
 // Optimize struct gets based on what we've learned about writes.
 //
@@ -560,7 +549,8 @@ struct ConstantFieldPropagation : public Pass {
     // of subtypes must be taken into account (that is, A or a subtype is being
     // copied, so we want to do the same thing for B and C as well as A, since
     // a copy of A means it could be a copy of B or C).
-    StructUtils::TypeHierarchyPropagator<Bool> boolPropagator(subTypes);
+    StructUtils::TypeHierarchyPropagator<StructUtils::CombinableBool>
+      boolPropagator(subTypes);
     boolPropagator.propagateToSubTypes(combinedCopyInfos);
     for (auto& [type, copied] : combinedCopyInfos) {
       for (Index i = 0; i < copied.size(); i++) {

src/passes/GlobalTypeOptimization.cpp

@@ -427,31 +427,18 @@ struct GlobalTypeOptimization : public Pass {
     // remove A's descriptor without also removing $B's, so we need to propagate
     // that "must remain a descriptor" property among descriptors.
     if (!haveUnneededDescriptors.empty()) {
-
-      struct DescriptorInfo {
-        // Whether this descriptor is needed - it must keep describing.
-        bool needed = false;
-
-        bool combine(const DescriptorInfo& other) {
-          if (!needed && other.needed) {
-            needed = true;
-            return true;
-          }
-          return false;
-        }
-      };
-
-      StructUtils::TypeHierarchyPropagator<DescriptorInfo> descPropagator(
-        subTypes);
+      StructUtils::TypeHierarchyPropagator<StructUtils::CombinableBool>
+        descPropagator(subTypes);
 
       // Populate the initial data: Any descriptor we did not see was unneeded,
       // is needed.
-      StructUtils::TypeHierarchyPropagator<DescriptorInfo>::StructMap map;
+      StructUtils::TypeHierarchyPropagator<
+        StructUtils::CombinableBool>::StructMap map;
       for (auto type : subTypes.types) {
         if (auto desc = type.getDescriptorType()) {
           if (!haveUnneededDescriptors.count(type)) {
             // This descriptor type is needed.
-            map[*desc].needed = true;
+            map[*desc].value = true;
           }
         }
       }
@@ -471,7 +458,7 @@ struct GlobalTypeOptimization : public Pass {
       // keep subtyping working for the descriptors, and later passes could
       // remove the unused A2.
       for (auto& [type, info] : map) {
-        if (info.needed) {
+        if (info.value) {
           auto described = type.getDescribedType();
           assert(described);
           haveUnneededDescriptors.erase(*described);