Heap2Local: Handle unreachable code inside ref.is_null (#8038)

We must not force the type to be i32, but leave it unreachable (parallel
to ref.eq, below it).

Fixes #8035

Author: kripken

src/passes/Heap2Local.cpp

@@ -795,6 +795,12 @@ struct Struct2Local : PostWalker<Struct2Local> {
       return;
     }
 
+    if (curr->type == Type::unreachable) {
+      // The result does not matter. Leave things as they are (and let DCE
+      // handle it).
+      return;
+    }
+
     // The result must be 0, since the allocation is not null. Drop the RefIs
     // and append that.
     replaceCurrent(builder.makeSequence(

test/lit/passes/heap2local-desc.wast

@@ -1218,3 +1218,64 @@
   )
 )
 
+(module
+  (rec
+   ;; CHECK:      (rec
+   ;; CHECK-NEXT:  (type $struct (sub (descriptor $desc (struct))))
+   (type $struct (sub (descriptor $desc (struct))))
+   ;; CHECK:       (type $desc (describes $struct (struct)))
+   (type $desc (sub final (describes $struct (struct))))
+  )
+
+  ;; CHECK:      (type $2 (func (result i32)))
+
+  ;; CHECK:      (func $test (type $2) (result i32)
+  ;; CHECK-NEXT:  (local $desc (ref $desc))
+  ;; CHECK-NEXT:  (local $1 (ref (exact $desc)))
+  ;; CHECK-NEXT:  (local $2 (ref (exact $desc)))
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (block (result nullref)
+  ;; CHECK-NEXT:    (ref.null none)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (ref.is_null
+  ;; CHECK-NEXT:   (block
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (block (result nullref)
+  ;; CHECK-NEXT:      (local.set $2
+  ;; CHECK-NEXT:       (struct.new_default $desc)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:      (local.set $1
+  ;; CHECK-NEXT:       (local.get $2)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:      (ref.null none)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (ref.null none)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (unreachable)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test (result i32)
+    (local $desc (ref $desc))
+    (local.set $desc
+      (struct.new_default $desc)
+    )
+    ;; After we optimize the struct.new above, the local.get below will get
+    ;; removed, and we will see that the ref.cast_desc traps (the input
+    ;; descriptor differs from the one we test, the allocation we just
+    ;; removed). When optimizing that, we should not emit invalid IR for the
+    ;; ref.is_null: It has an i32 result normally, but in unreachable code it
+    ;; must remain unreachable.
+    (ref.is_null
+      (ref.cast_desc (ref $struct)
+        (struct.new_default $struct
+          (struct.new_default $desc)
+        )
+        (local.get $desc)
+      )
+    )
+  )
+)