Fix missing Exact type ReFinalization in TypeMerging (#7619)

If we merge siblings to their parent, they may end up equal:

(select (result A))
 (B1)
 (B2)
)

=>

(select (result (exact A))) ;; result is now exact
 (A) ;; both are
 (A) ;; now A
)

In such cases we must refinalize, as the LUB is now exact.

Author: kripken

src/passes/TypeMerging.cpp

@@ -245,9 +245,22 @@ void TypeMerging::run(Module* module_) {
   //
   // If we merge siblings, we also need to refinalize because the LUB of merged
   // siblings is the merged type rather than their common supertype after the
-  // merge.
-  bool refinalize = false;
-  merge(Supertypes);
+  // merge. This can happen in merge(Siblings), but also in merge(Supertypes),
+  // since we may end up merging B1 to its super A, and also B2 to the same
+  // super A, ending up with B1 and B2 now equal - in that case the siblings are
+  // now both equal (to the parent), allowing an exact LUB:
+  //
+  //  (select (result A))
+  //   (B1)
+  //   (B2)
+  //  )
+  // =>
+  //  (select (result (exact A))) ;; result is now exact
+  //   (A) ;; both are
+  //   (A) ;; now A
+  //  )
+  //
+  bool refinalize = merge(Supertypes);
   for (int i = 0; i < MAX_ITERATIONS; ++i) {
     if (!merge(Siblings)) {
       break;

test/lit/passes/type-merging-exact.wast

@@ -131,3 +131,44 @@
     )
   )
 )
+
+;; Merge two siblings to their parent. We must refinalize here.
+(module
+  (rec
+    ;; CHECK:      (rec
+    ;; CHECK-NEXT:  (type $A (sub (array i8)))
+    (type $A (sub (array i8)))
+    (type $B1 (sub $A (array i8)))
+    (type $B2 (sub $A (array i8)))
+  )
+
+  ;; CHECK:      (func $test (type $1)
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (select (result (ref (exact $A)))
+  ;; CHECK-NEXT:    (array.new_default $A
+  ;; CHECK-NEXT:     (i32.const 0)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (array.new_default $A
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (i32.const 2)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test
+    ;; B1 and B2 will turn into A, after which the select can be refined to an
+    ;; exact type.
+    (drop
+      (select (result (ref $A))
+        (array.new_default $B1
+          (i32.const 0)
+        )
+        (array.new_default $B2
+          (i32.const 1)
+        )
+        (i32.const 2)
+      )
+    )
+  )
+)
+

test/lit/passes/type-merging.wast

@@ -890,7 +890,7 @@
  )
 
  ;; CHECK:      (func $test (type $D) (result (ref any) (ref $B))
- ;; CHECK-NEXT:  (block $l (type $A) (result (ref any) (ref $B))
+ ;; CHECK-NEXT:  (block $l
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )