;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited.

;; RUN: wasm-opt %s -all --optimize-instructions -S -o - | filecheck %s
;; RUN: wasm-opt %s -all --optimize-instructions -tnh -S -o - | filecheck %s --check-prefix=NTRAP

(module
  (rec
    ;; CHECK:      (rec
    ;; CHECK-NEXT:  (type $struct (sub (descriptor $desc) (struct)))
    ;; NTRAP:      (rec
    ;; NTRAP-NEXT:  (type $struct (sub (descriptor $desc) (struct)))
    (type $struct (sub (descriptor $desc) (struct)))
    ;; CHECK:       (type $desc (sub (describes $struct) (struct)))
    ;; NTRAP:       (type $desc (sub (describes $struct) (struct)))
    (type $desc (sub (describes $struct) (struct)))
  )

  (rec
    ;; CHECK:      (rec
    ;; CHECK-NEXT:  (type $sub (sub $struct (descriptor $sub.desc) (struct)))
    ;; NTRAP:      (rec
    ;; NTRAP-NEXT:  (type $sub (sub $struct (descriptor $sub.desc) (struct)))
    (type $sub (sub $struct (descriptor $sub.desc) (struct)))
    ;; CHECK:       (type $sub.desc (sub $desc (describes $sub) (struct)))
    ;; NTRAP:       (type $sub.desc (sub $desc (describes $sub) (struct)))
    (type $sub.desc (sub $desc (describes $sub) (struct)))
  )

  (rec
    ;; CHECK:      (rec
    ;; CHECK-NEXT:  (type $struct-i32 (descriptor $struct-i32.desc) (struct (field i32)))
    ;; NTRAP:      (rec
    ;; NTRAP-NEXT:  (type $struct-i32 (descriptor $struct-i32.desc) (struct (field i32)))
    (type $struct-i32 (descriptor $struct-i32.desc) (struct (field i32)))
    ;; CHECK:       (type $struct-i32.desc (describes $struct-i32) (struct))
    ;; NTRAP:       (type $struct-i32.desc (describes $struct-i32) (struct))
    (type $struct-i32.desc (describes $struct-i32) (struct))
  )

  ;; CHECK:      (import "" "" (func $effect (type $4)))
  ;; NTRAP:      (import "" "" (func $effect (type $4)))
  (import "" "" (func $effect))

  ;; CHECK:      (func $trap-null-desc (type $10) (result (ref (exact $struct)))
  ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $trap-null-desc (type $10) (result (ref (exact $struct)))
  ;; NTRAP-NEXT:  (unreachable)
  ;; NTRAP-NEXT: )
  (func $trap-null-desc (result (ref (exact $struct)))
    (struct.new_desc $struct
      (ref.null none)
    )
  )

  ;; CHECK:      (func $trap-null-desc-fallthrough (type $10) (result (ref (exact $struct)))
  ;; CHECK-NEXT:  (local $desc (ref null (exact $desc)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (local.tee $desc
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $trap-null-desc-fallthrough (type $10) (result (ref (exact $struct)))
  ;; NTRAP-NEXT:  (local $desc (ref null (exact $desc)))
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (local.tee $desc
  ;; NTRAP-NEXT:    (ref.null none)
  ;; NTRAP-NEXT:   )
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT:  (unreachable)
  ;; NTRAP-NEXT: )
  (func $trap-null-desc-fallthrough (result (ref (exact $struct)))
    (local $desc (ref null (exact $desc)))
    (struct.new_desc $struct
      (local.tee $desc
        (ref.null none)
      )
    )
  )

  ;; CHECK:      (func $nonnull-cast-desc-eq (type $19) (param $desc (ref null (exact $desc))) (result (ref (exact $struct)))
  ;; CHECK-NEXT:  (struct.new_default_desc $struct
  ;; CHECK-NEXT:   (local.get $desc)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $nonnull-cast-desc-eq (type $19) (param $desc (ref null (exact $desc))) (result (ref (exact $struct)))
  ;; NTRAP-NEXT:  (struct.new_default_desc $struct
  ;; NTRAP-NEXT:   (local.get $desc)
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $nonnull-cast-desc-eq (param $desc (ref null (exact $desc))) (result (ref (exact $struct)))
    (struct.new_desc $struct
      (ref.as_non_null
        (local.get $desc)
      )
    )
  )

  ;; Test that when we optimize a struct.new to a struct.new_default, we drop
  ;; the field operands but keep the descriptor.
  ;; CHECK:      (func $new-default-keep-desc (type $11) (result anyref)
  ;; CHECK-NEXT:  (struct.new_default_desc $struct-i32
  ;; CHECK-NEXT:   (block (result (ref (exact $struct-i32.desc)))
  ;; CHECK-NEXT:    (call $effect)
  ;; CHECK-NEXT:    (struct.new_default $struct-i32.desc)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $new-default-keep-desc (type $11) (result anyref)
  ;; NTRAP-NEXT:  (struct.new_default_desc $struct-i32
  ;; NTRAP-NEXT:   (block (result (ref (exact $struct-i32.desc)))
  ;; NTRAP-NEXT:    (call $effect)
  ;; NTRAP-NEXT:    (struct.new_default $struct-i32.desc)
  ;; NTRAP-NEXT:   )
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $new-default-keep-desc (result anyref)
    (struct.new_desc $struct-i32
      (i32.const 0)
      (block (result (ref (exact $struct-i32.desc)))
        ;; This would cause the descriptor to be dropped if it were dropped with
        ;; the other children.
        (call $effect)
        (struct.new_default $struct-i32.desc)
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-null-desc (type $4)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $cast-desc-eq-null-desc (type $4)
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (unreachable)
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $cast-desc-eq-null-desc
    (drop
      (ref.cast_desc_eq (ref (exact $struct))
        (struct.new_desc $struct
          (struct.new $desc)
        )
        (ref.null none)
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-no-glb (type $9) (param $nn-sub (ref $sub)) (param $desc (ref $desc))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $struct)
  ;; CHECK-NEXT:    (local.get $nn-sub)
  ;; CHECK-NEXT:    (local.get $desc)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $cast-desc-eq-no-glb (type $9) (param $nn-sub (ref $sub)) (param $desc (ref $desc))
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (block (result (ref $sub))
  ;; NTRAP-NEXT:    (local.get $nn-sub)
  ;; NTRAP-NEXT:   )
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $cast-desc-eq-no-glb (param $nn-sub (ref $sub)) (param $desc (ref $desc))
    (drop
      ;; We cannot improve the cast target heap type, but we can improve the
      ;; nullability. With traps-never-happen we can optimize fully.
      (ref.cast_desc_eq (ref null $struct)
        (local.get $nn-sub)
        (local.get $desc)
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-improve-nullability (type $20) (param $nn-any (ref any)) (param $desc (ref $desc))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $struct)
  ;; CHECK-NEXT:    (local.get $nn-any)
  ;; CHECK-NEXT:    (local.get $desc)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $cast-desc-eq-improve-nullability (type $20) (param $nn-any (ref any)) (param $desc (ref $desc))
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (ref.cast_desc_eq (ref $struct)
  ;; NTRAP-NEXT:    (local.get $nn-any)
  ;; NTRAP-NEXT:    (local.get $desc)
  ;; NTRAP-NEXT:   )
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $cast-desc-eq-improve-nullability (param $nn-any (ref any)) (param $desc (ref $desc))
    (drop
      ;; Like above, but the ref isn't a subtype of the cast type. We can still
      ;; improve the nullability.
      (ref.cast_desc_eq (ref null $struct)
        (local.get $nn-any)
        (local.get $desc)
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-only-improve-nullability (type $8) (param $any anyref) (param $desc (ref $desc))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $struct)
  ;; CHECK-NEXT:    (local.get $any)
  ;; CHECK-NEXT:    (local.get $desc)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $cast-desc-eq-only-improve-nullability (type $8) (param $any anyref) (param $desc (ref $desc))
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (ref.cast_desc_eq (ref $struct)
  ;; NTRAP-NEXT:    (local.get $any)
  ;; NTRAP-NEXT:    (local.get $desc)
  ;; NTRAP-NEXT:   )
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $cast-desc-eq-only-improve-nullability (param $any anyref) (param $desc (ref $desc))
    (drop
      ;; Now the cast target is already non-nullable. We shouldn't make it
      ;; nullable.
      (ref.cast_desc_eq (ref $struct)
        (local.get $any)
        (local.get $desc)
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-unrelated-type (type $12) (param $struct (ref $struct)) (param $desc-i32 (ref (exact $struct-i32.desc)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $cast-desc-eq-unrelated-type (type $12) (param $struct (ref $struct)) (param $desc-i32 (ref (exact $struct-i32.desc)))
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (unreachable)
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $cast-desc-eq-unrelated-type (param $struct (ref $struct)) (param $desc-i32 (ref (exact $struct-i32.desc)))
    (drop
      ;; We know this cast will fail so we can optimize.
      (ref.cast_desc_eq (ref (exact $struct-i32))
        (local.get $struct)
        (local.get $desc-i32)
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-unrelated-type-effects (type $12) (param $struct (ref $struct)) (param $desc-i32 (ref (exact $struct-i32.desc)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block (result (ref $struct))
  ;; CHECK-NEXT:      (call $effect)
  ;; CHECK-NEXT:      (local.get $struct)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block (result (ref (exact $struct-i32.desc)))
  ;; CHECK-NEXT:      (call $effect)
  ;; CHECK-NEXT:      (local.get $desc-i32)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $cast-desc-eq-unrelated-type-effects (type $12) (param $struct (ref $struct)) (param $desc-i32 (ref (exact $struct-i32.desc)))
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (block
  ;; NTRAP-NEXT:    (drop
  ;; NTRAP-NEXT:     (block (result (ref $struct))
  ;; NTRAP-NEXT:      (call $effect)
  ;; NTRAP-NEXT:      (local.get $struct)
  ;; NTRAP-NEXT:     )
  ;; NTRAP-NEXT:    )
  ;; NTRAP-NEXT:    (drop
  ;; NTRAP-NEXT:     (block (result (ref (exact $struct-i32.desc)))
  ;; NTRAP-NEXT:      (call $effect)
  ;; NTRAP-NEXT:      (local.get $desc-i32)
  ;; NTRAP-NEXT:     )
  ;; NTRAP-NEXT:    )
  ;; NTRAP-NEXT:    (unreachable)
  ;; NTRAP-NEXT:   )
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $cast-desc-eq-unrelated-type-effects (param $struct (ref $struct)) (param $desc-i32 (ref (exact $struct-i32.desc)))
    (drop
      ;; As above, but now with effects we need to keep.
      (ref.cast_desc_eq (ref (exact $struct-i32))
        (block (result (ref $struct))
          (call $effect)
          (local.get $struct)
        )
        (block (result (ref (exact $struct-i32.desc)))
          (call $effect)
          (local.get $desc-i32)
        )
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-unrelated-type-nullable (type $13) (param $struct-i32 (ref null $struct-i32)) (param $desc (ref $desc))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast_desc_eq (ref null $struct)
  ;; CHECK-NEXT:    (local.get $struct-i32)
  ;; CHECK-NEXT:    (local.get $desc)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $cast-desc-eq-unrelated-type-nullable (type $13) (param $struct-i32 (ref null $struct-i32)) (param $desc (ref $desc))
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (ref.null none)
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $cast-desc-eq-unrelated-type-nullable (param $struct-i32 (ref null $struct-i32)) (param $desc (ref $desc))
    (drop
      ;; Same as above, but now we allow nulls. We can optimize with traps-never-happen.
      (ref.cast_desc_eq (ref null $struct)
        (local.get $struct-i32)
        (local.get $desc)
      )
    )
  )

    ;; CHECK:      (func $cast-desc-eq-unrelated-type-nullable-effects (type $13) (param $struct-i32 (ref null $struct-i32)) (param $desc (ref $desc))
    ;; CHECK-NEXT:  (drop
    ;; CHECK-NEXT:   (ref.cast_desc_eq (ref null $struct)
    ;; CHECK-NEXT:    (block (result (ref null $struct-i32))
    ;; CHECK-NEXT:     (call $effect)
    ;; CHECK-NEXT:     (local.get $struct-i32)
    ;; CHECK-NEXT:    )
    ;; CHECK-NEXT:    (block (result (ref $desc))
    ;; CHECK-NEXT:     (call $effect)
    ;; CHECK-NEXT:     (local.get $desc)
    ;; CHECK-NEXT:    )
    ;; CHECK-NEXT:   )
    ;; CHECK-NEXT:  )
    ;; CHECK-NEXT: )
    ;; NTRAP:      (func $cast-desc-eq-unrelated-type-nullable-effects (type $13) (param $struct-i32 (ref null $struct-i32)) (param $desc (ref $desc))
    ;; NTRAP-NEXT:  (drop
    ;; NTRAP-NEXT:   (block (result nullref)
    ;; NTRAP-NEXT:    (drop
    ;; NTRAP-NEXT:     (block (result (ref null $struct-i32))
    ;; NTRAP-NEXT:      (call $effect)
    ;; NTRAP-NEXT:      (local.get $struct-i32)
    ;; NTRAP-NEXT:     )
    ;; NTRAP-NEXT:    )
    ;; NTRAP-NEXT:    (drop
    ;; NTRAP-NEXT:     (block (result (ref $desc))
    ;; NTRAP-NEXT:      (call $effect)
    ;; NTRAP-NEXT:      (local.get $desc)
    ;; NTRAP-NEXT:     )
    ;; NTRAP-NEXT:    )
    ;; NTRAP-NEXT:    (ref.null none)
    ;; NTRAP-NEXT:   )
    ;; NTRAP-NEXT:  )
    ;; NTRAP-NEXT: )
    (func $cast-desc-eq-unrelated-type-nullable-effects (param $struct-i32 (ref null $struct-i32)) (param $desc (ref $desc))
    (drop
      ;; Same as above, but now with effects we cannot drop.
      (ref.cast_desc_eq (ref null $struct)
        (block (result (ref null $struct-i32))
          (call $effect)
          (local.get $struct-i32)
        )
        (block (result (ref $desc))
          (call $effect)
          (local.get $desc)
        )
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-wrong-desc (type $4)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast_desc_eq (ref (exact $struct))
  ;; CHECK-NEXT:    (struct.new_default_desc $struct
  ;; CHECK-NEXT:     (struct.new_default $desc)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (struct.new_default $desc)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $cast-desc-eq-wrong-desc (type $4)
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (block (result (ref (exact $struct)))
  ;; NTRAP-NEXT:    (struct.new_default_desc $struct
  ;; NTRAP-NEXT:     (struct.new_default $desc)
  ;; NTRAP-NEXT:    )
  ;; NTRAP-NEXT:   )
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $cast-desc-eq-wrong-desc
    (drop
      ;; With traps-never-happen we assume the cast will succeed and optimize it
      ;; out, even even though it would actually fail.
      ;; TODO: We could see that the descriptor used in the allocation and the
      ;; descriptor used in the cast are different and optimize without TNH.
      (ref.cast_desc_eq (ref (exact $struct))
        (struct.new_desc $struct
          (struct.new $desc)
        )
        (struct.new $desc)
      )
    )
  )

    ;; CHECK:      (func $cast-desc-eq-wrong-desc-effects (type $4)
    ;; CHECK-NEXT:  (drop
    ;; CHECK-NEXT:   (ref.cast_desc_eq (ref (exact $struct))
    ;; CHECK-NEXT:    (block (result (ref (exact $struct)))
    ;; CHECK-NEXT:     (call $effect)
    ;; CHECK-NEXT:     (struct.new_default_desc $struct
    ;; CHECK-NEXT:      (struct.new_default $desc)
    ;; CHECK-NEXT:     )
    ;; CHECK-NEXT:    )
    ;; CHECK-NEXT:    (block (result (ref (exact $desc)))
    ;; CHECK-NEXT:     (call $effect)
    ;; CHECK-NEXT:     (struct.new_default $desc)
    ;; CHECK-NEXT:    )
    ;; CHECK-NEXT:   )
    ;; CHECK-NEXT:  )
    ;; CHECK-NEXT: )
    ;; NTRAP:      (func $cast-desc-eq-wrong-desc-effects (type $4)
    ;; NTRAP-NEXT:  (local $0 (ref (exact $struct)))
    ;; NTRAP-NEXT:  (local $1 (ref (exact $desc)))
    ;; NTRAP-NEXT:  (drop
    ;; NTRAP-NEXT:   (block (result (ref (exact $struct)))
    ;; NTRAP-NEXT:    (local.set $0
    ;; NTRAP-NEXT:     (block (result (ref (exact $struct)))
    ;; NTRAP-NEXT:      (call $effect)
    ;; NTRAP-NEXT:      (struct.new_default_desc $struct
    ;; NTRAP-NEXT:       (struct.new_default $desc)
    ;; NTRAP-NEXT:      )
    ;; NTRAP-NEXT:     )
    ;; NTRAP-NEXT:    )
    ;; NTRAP-NEXT:    (local.set $1
    ;; NTRAP-NEXT:     (block (result (ref (exact $desc)))
    ;; NTRAP-NEXT:      (call $effect)
    ;; NTRAP-NEXT:      (struct.new_default $desc)
    ;; NTRAP-NEXT:     )
    ;; NTRAP-NEXT:    )
    ;; NTRAP-NEXT:    (local.get $0)
    ;; NTRAP-NEXT:   )
    ;; NTRAP-NEXT:  )
    ;; NTRAP-NEXT: )
    (func $cast-desc-eq-wrong-desc-effects
    (drop
      ;; Same, but with effects.
      (ref.cast_desc_eq (ref (exact $struct))
        (block (result (ref (exact $struct)))
          (call $effect)
          (struct.new_desc $struct
            (struct.new $desc)
          )
        )
        (block (result (ref (exact $desc)))
          (call $effect)
          (struct.new $desc)
        )
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-weaker-nondesc-child (type $14) (param $ref anyref) (param $desc (ref $sub.desc))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $sub)
  ;; CHECK-NEXT:    (local.get $ref)
  ;; CHECK-NEXT:    (local.get $desc)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $cast-desc-eq-weaker-nondesc-child (type $14) (param $ref anyref) (param $desc (ref $sub.desc))
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (ref.cast_desc_eq (ref $sub)
  ;; NTRAP-NEXT:    (local.get $ref)
  ;; NTRAP-NEXT:    (local.get $desc)
  ;; NTRAP-NEXT:   )
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $cast-desc-eq-weaker-nondesc-child (param $ref anyref) (param $desc (ref $sub.desc))
    (drop
      ;; Optimize out the weaker child cast.
      (ref.cast_desc_eq (ref $sub)
        (ref.cast (ref any)
          (local.get $ref)
        )
        (local.get $desc)
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-weaker-nondesc-child-effects (type $14) (param $ref anyref) (param $desc (ref $sub.desc))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $sub)
  ;; CHECK-NEXT:    (ref.as_non_null
  ;; CHECK-NEXT:     (block (result anyref)
  ;; CHECK-NEXT:      (call $effect)
  ;; CHECK-NEXT:      (local.get $ref)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (block (result (ref $sub.desc))
  ;; CHECK-NEXT:     (call $effect)
  ;; CHECK-NEXT:     (local.get $desc)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $cast-desc-eq-weaker-nondesc-child-effects (type $14) (param $ref anyref) (param $desc (ref $sub.desc))
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (ref.cast_desc_eq (ref $sub)
  ;; NTRAP-NEXT:    (ref.as_non_null
  ;; NTRAP-NEXT:     (block (result anyref)
  ;; NTRAP-NEXT:      (call $effect)
  ;; NTRAP-NEXT:      (local.get $ref)
  ;; NTRAP-NEXT:     )
  ;; NTRAP-NEXT:    )
  ;; NTRAP-NEXT:    (block (result (ref $sub.desc))
  ;; NTRAP-NEXT:     (call $effect)
  ;; NTRAP-NEXT:     (local.get $desc)
  ;; NTRAP-NEXT:    )
  ;; NTRAP-NEXT:   )
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $cast-desc-eq-weaker-nondesc-child-effects (param $ref anyref) (param $desc (ref $sub.desc))
    (drop
      ;; Same, but with effects. Due to ordering, we cannot remove the inner
      ;; cast (which turns into ref.as_non_null).
      (ref.cast_desc_eq (ref $sub)
        (ref.cast (ref any)
          (block (result anyref)
            (call $effect)
            (local.get $ref)
          )
        )
        (block (result (ref $sub.desc))
          (call $effect)
          (local.get $desc)
        )
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-stronger-nondesc-child (type $8) (param $ref anyref) (param $desc (ref $desc))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $struct)
  ;; CHECK-NEXT:    (ref.cast (ref $sub)
  ;; CHECK-NEXT:     (local.get $ref)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $desc)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $cast-desc-eq-stronger-nondesc-child (type $8) (param $ref anyref) (param $desc (ref $desc))
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (block (result (ref $sub))
  ;; NTRAP-NEXT:    (ref.cast (ref $sub)
  ;; NTRAP-NEXT:     (local.get $ref)
  ;; NTRAP-NEXT:    )
  ;; NTRAP-NEXT:   )
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $cast-desc-eq-stronger-nondesc-child (param $ref anyref) (param $desc (ref $desc))
    (drop
      ;; With traps-never-happen we assume the outer cast will succeed and
      ;; optimize it out.
      (ref.cast_desc_eq (ref $struct)
        (ref.cast (ref $sub)
          (local.get $ref)
        )
        (local.get $desc)
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-stronger-nondesc-child-effects (type $8) (param $ref anyref) (param $desc (ref $desc))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $struct)
  ;; CHECK-NEXT:    (ref.cast (ref $sub)
  ;; CHECK-NEXT:     (block (result anyref)
  ;; CHECK-NEXT:      (call $effect)
  ;; CHECK-NEXT:      (local.get $ref)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (block (result (ref $desc))
  ;; CHECK-NEXT:     (call $effect)
  ;; CHECK-NEXT:     (local.get $desc)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $cast-desc-eq-stronger-nondesc-child-effects (type $8) (param $ref anyref) (param $desc (ref $desc))
  ;; NTRAP-NEXT:  (local $2 (ref $sub))
  ;; NTRAP-NEXT:  (local $3 (ref $desc))
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (block (result (ref $sub))
  ;; NTRAP-NEXT:    (local.set $2
  ;; NTRAP-NEXT:     (ref.cast (ref $sub)
  ;; NTRAP-NEXT:      (block (result anyref)
  ;; NTRAP-NEXT:       (call $effect)
  ;; NTRAP-NEXT:       (local.get $ref)
  ;; NTRAP-NEXT:      )
  ;; NTRAP-NEXT:     )
  ;; NTRAP-NEXT:    )
  ;; NTRAP-NEXT:    (local.set $3
  ;; NTRAP-NEXT:     (block (result (ref $desc))
  ;; NTRAP-NEXT:      (call $effect)
  ;; NTRAP-NEXT:      (local.get $desc)
  ;; NTRAP-NEXT:     )
  ;; NTRAP-NEXT:    )
  ;; NTRAP-NEXT:    (local.get $2)
  ;; NTRAP-NEXT:   )
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $cast-desc-eq-stronger-nondesc-child-effects (param $ref anyref) (param $desc (ref $desc))
    (drop
      ;; Same, but with effects.
      (ref.cast_desc_eq (ref $struct)
        (ref.cast (ref $sub)
          (block (result anyref)
            (call $effect)
            (local.get $ref)
          )
        )
        (block (result (ref $desc))
          (call $effect)
          (local.get $desc)
        )
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-weaker-desc-child (type $15) (param $ref anyref) (param $desc (ref $desc)) (param $sub.desc (ref $sub.desc))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $sub)
  ;; CHECK-NEXT:    (ref.cast_desc_eq (ref $struct)
  ;; CHECK-NEXT:     (local.get $ref)
  ;; CHECK-NEXT:     (local.get $desc)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $sub.desc)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $cast-desc-eq-weaker-desc-child (type $15) (param $ref anyref) (param $desc (ref $desc)) (param $sub.desc (ref $sub.desc))
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (ref.cast_desc_eq (ref $sub)
  ;; NTRAP-NEXT:    (block (result anyref)
  ;; NTRAP-NEXT:     (local.get $ref)
  ;; NTRAP-NEXT:    )
  ;; NTRAP-NEXT:    (local.get $sub.desc)
  ;; NTRAP-NEXT:   )
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $cast-desc-eq-weaker-desc-child (param $ref anyref) (param $desc (ref $desc)) (param $sub.desc (ref $sub.desc))
    (drop
      ;; We can only optimize the weaker child cast with traps-never-happen
      ;; because it might fail due to an incorrect descriptor even when the
      ;; parent cast would succeed.
      (ref.cast_desc_eq (ref $sub)
        (ref.cast_desc_eq (ref $struct)
          (local.get $ref)
          (local.get $desc)
        )
        (local.get $sub.desc)
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-stronger-desc-child (type $15) (param $ref anyref) (param $desc (ref $desc)) (param $sub.desc (ref $sub.desc))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $struct)
  ;; CHECK-NEXT:    (ref.cast_desc_eq (ref $sub)
  ;; CHECK-NEXT:     (local.get $ref)
  ;; CHECK-NEXT:     (local.get $sub.desc)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $desc)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $cast-desc-eq-stronger-desc-child (type $15) (param $ref anyref) (param $desc (ref $desc)) (param $sub.desc (ref $sub.desc))
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (block (result (ref $sub))
  ;; NTRAP-NEXT:    (ref.cast_desc_eq (ref $sub)
  ;; NTRAP-NEXT:     (local.get $ref)
  ;; NTRAP-NEXT:     (local.get $sub.desc)
  ;; NTRAP-NEXT:    )
  ;; NTRAP-NEXT:   )
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $cast-desc-eq-stronger-desc-child (param $ref anyref) (param $desc (ref $desc)) (param $sub.desc (ref $sub.desc))
    (drop
      ;; Like above, but now when we optimize with traps-never-happen we replace
      ;; the parent with the child.
      (ref.cast_desc_eq (ref $struct)
        (ref.cast_desc_eq (ref $sub)
          (local.get $ref)
          (local.get $sub.desc)
        )
        (local.get $desc)
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-stronger-fallthrough (type $9) (param $sub (ref $sub)) (param $desc (ref $desc))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $struct)
  ;; CHECK-NEXT:    (block (result anyref)
  ;; CHECK-NEXT:     (local.get $sub)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $desc)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $cast-desc-eq-stronger-fallthrough (type $9) (param $sub (ref $sub)) (param $desc (ref $desc))
  ;; NTRAP-NEXT:  (local $2 (ref $sub))
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (block (result (ref $sub))
  ;; NTRAP-NEXT:    (drop
  ;; NTRAP-NEXT:     (block (result (ref $sub))
  ;; NTRAP-NEXT:      (local.tee $2
  ;; NTRAP-NEXT:       (local.get $sub)
  ;; NTRAP-NEXT:      )
  ;; NTRAP-NEXT:     )
  ;; NTRAP-NEXT:    )
  ;; NTRAP-NEXT:    (local.get $2)
  ;; NTRAP-NEXT:   )
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $cast-desc-eq-stronger-fallthrough (param $sub (ref $sub)) (param $desc (ref $desc))
    (drop
      ;; Like above, but now the stronger child is deeper. We use a tee to
      ;; extract it.
      (ref.cast_desc_eq (ref $struct)
        (block (result anyref)
          (local.get $sub)
        )
        (local.get $desc)
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-stronger-fallthrough-effects (type $9) (param $sub (ref $sub)) (param $desc (ref $desc))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $struct)
  ;; CHECK-NEXT:    (block (result anyref)
  ;; CHECK-NEXT:     (call $effect)
  ;; CHECK-NEXT:     (local.get $sub)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (block (result (ref $desc))
  ;; CHECK-NEXT:     (call $effect)
  ;; CHECK-NEXT:     (local.get $desc)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $cast-desc-eq-stronger-fallthrough-effects (type $9) (param $sub (ref $sub)) (param $desc (ref $desc))
  ;; NTRAP-NEXT:  (local $2 (ref $sub))
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (block (result (ref $sub))
  ;; NTRAP-NEXT:    (drop
  ;; NTRAP-NEXT:     (block (result (ref $sub))
  ;; NTRAP-NEXT:      (call $effect)
  ;; NTRAP-NEXT:      (local.tee $2
  ;; NTRAP-NEXT:       (local.get $sub)
  ;; NTRAP-NEXT:      )
  ;; NTRAP-NEXT:     )
  ;; NTRAP-NEXT:    )
  ;; NTRAP-NEXT:    (drop
  ;; NTRAP-NEXT:     (block (result (ref $desc))
  ;; NTRAP-NEXT:      (call $effect)
  ;; NTRAP-NEXT:      (local.get $desc)
  ;; NTRAP-NEXT:     )
  ;; NTRAP-NEXT:    )
  ;; NTRAP-NEXT:    (local.get $2)
  ;; NTRAP-NEXT:   )
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $cast-desc-eq-stronger-fallthrough-effects (param $sub (ref $sub)) (param $desc (ref $desc))
    (drop
      ;; Like above, but now with effects we cannot drop.
      (ref.cast_desc_eq (ref $struct)
        (block (result anyref)
          (call $effect)
          (local.get $sub)
        )
        (block (result (ref $desc))
          (call $effect)
          (local.get $desc)
        )
      )
    )
  )

   ;; CHECK:      (func $cast-desc-eq-stronger-fallthrough-nullck (type $16) (param $sub (ref null $sub)) (param $desc (ref $desc))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $struct)
   ;; CHECK-NEXT:    (block (result anyref)
   ;; CHECK-NEXT:     (local.get $sub)
   ;; CHECK-NEXT:    )
   ;; CHECK-NEXT:    (local.get $desc)
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
   ;; NTRAP:      (func $cast-desc-eq-stronger-fallthrough-nullck (type $16) (param $sub (ref null $sub)) (param $desc (ref $desc))
   ;; NTRAP-NEXT:  (local $2 (ref null $sub))
   ;; NTRAP-NEXT:  (drop
   ;; NTRAP-NEXT:   (block (result (ref $sub))
   ;; NTRAP-NEXT:    (drop
   ;; NTRAP-NEXT:     (block (result (ref null $sub))
   ;; NTRAP-NEXT:      (local.tee $2
   ;; NTRAP-NEXT:       (local.get $sub)
   ;; NTRAP-NEXT:      )
   ;; NTRAP-NEXT:     )
   ;; NTRAP-NEXT:    )
   ;; NTRAP-NEXT:    (ref.as_non_null
   ;; NTRAP-NEXT:     (local.get $2)
   ;; NTRAP-NEXT:    )
   ;; NTRAP-NEXT:   )
   ;; NTRAP-NEXT:  )
   ;; NTRAP-NEXT: )
   (func $cast-desc-eq-stronger-fallthrough-nullck (param $sub (ref null $sub)) (param $desc (ref $desc))
    (drop
      ;; Like above, but now we also need a null check.
      (ref.cast_desc_eq (ref $struct)
        (block (result anyref)
          (local.get $sub)
        )
        (local.get $desc)
      )
    )
  )

    ;; CHECK:      (func $cast-desc-eq-stronger-fallthrough-nullck-effects (type $16) (param $sub (ref null $sub)) (param $desc (ref $desc))
    ;; CHECK-NEXT:  (drop
    ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $struct)
    ;; CHECK-NEXT:    (block (result anyref)
    ;; CHECK-NEXT:     (call $effect)
    ;; CHECK-NEXT:     (local.get $sub)
    ;; CHECK-NEXT:    )
    ;; CHECK-NEXT:    (block (result (ref $desc))
    ;; CHECK-NEXT:     (call $effect)
    ;; CHECK-NEXT:     (local.get $desc)
    ;; CHECK-NEXT:    )
    ;; CHECK-NEXT:   )
    ;; CHECK-NEXT:  )
    ;; CHECK-NEXT: )
    ;; NTRAP:      (func $cast-desc-eq-stronger-fallthrough-nullck-effects (type $16) (param $sub (ref null $sub)) (param $desc (ref $desc))
    ;; NTRAP-NEXT:  (local $2 (ref null $sub))
    ;; NTRAP-NEXT:  (drop
    ;; NTRAP-NEXT:   (block (result (ref $sub))
    ;; NTRAP-NEXT:    (drop
    ;; NTRAP-NEXT:     (block (result (ref null $sub))
    ;; NTRAP-NEXT:      (call $effect)
    ;; NTRAP-NEXT:      (local.tee $2
    ;; NTRAP-NEXT:       (local.get $sub)
    ;; NTRAP-NEXT:      )
    ;; NTRAP-NEXT:     )
    ;; NTRAP-NEXT:    )
    ;; NTRAP-NEXT:    (drop
    ;; NTRAP-NEXT:     (block (result (ref $desc))
    ;; NTRAP-NEXT:      (call $effect)
    ;; NTRAP-NEXT:      (local.get $desc)
    ;; NTRAP-NEXT:     )
    ;; NTRAP-NEXT:    )
    ;; NTRAP-NEXT:    (ref.as_non_null
    ;; NTRAP-NEXT:     (local.get $2)
    ;; NTRAP-NEXT:    )
    ;; NTRAP-NEXT:   )
    ;; NTRAP-NEXT:  )
    ;; NTRAP-NEXT: )
    (func $cast-desc-eq-stronger-fallthrough-nullck-effects (param $sub (ref null $sub)) (param $desc (ref $desc))
    (drop
      ;; Like above, but now with effects.
      (ref.cast_desc_eq (ref $struct)
        (block (result anyref)
          (call $effect)
          (local.get $sub)
        )
        (block (result (ref $desc))
          (call $effect)
          (local.get $desc)
        )
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-stronger-fallthrough-null (type $17) (param $null nullref) (param $desc (ref $desc))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.null none)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $cast-desc-eq-stronger-fallthrough-null (type $17) (param $null nullref) (param $desc (ref $desc))
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (ref.null none)
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $cast-desc-eq-stronger-fallthrough-null (param $null nullref) (param $desc (ref $desc))
    (drop
      ;; Like above, but now the value itself is null and we allow it.
      (ref.cast_desc_eq (ref null $struct)
        (block (result anyref)
          (local.get $null)
        )
        (local.get $desc)
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-stronger-fallthrough-null-effects (type $17) (param $null nullref) (param $desc (ref $desc))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block (result nullref)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block (result nullref)
  ;; CHECK-NEXT:      (call $effect)
  ;; CHECK-NEXT:      (local.get $null)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block (result (ref $desc))
  ;; CHECK-NEXT:      (call $effect)
  ;; CHECK-NEXT:      (local.get $desc)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $cast-desc-eq-stronger-fallthrough-null-effects (type $17) (param $null nullref) (param $desc (ref $desc))
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (block (result nullref)
  ;; NTRAP-NEXT:    (drop
  ;; NTRAP-NEXT:     (block (result nullref)
  ;; NTRAP-NEXT:      (call $effect)
  ;; NTRAP-NEXT:      (local.get $null)
  ;; NTRAP-NEXT:     )
  ;; NTRAP-NEXT:    )
  ;; NTRAP-NEXT:    (drop
  ;; NTRAP-NEXT:     (block (result (ref $desc))
  ;; NTRAP-NEXT:      (call $effect)
  ;; NTRAP-NEXT:      (local.get $desc)
  ;; NTRAP-NEXT:     )
  ;; NTRAP-NEXT:    )
  ;; NTRAP-NEXT:    (ref.null none)
  ;; NTRAP-NEXT:   )
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $cast-desc-eq-stronger-fallthrough-null-effects (param $null nullref) (param $desc (ref $desc))
    (drop
      ;; Like above, but now with effects.
      (ref.cast_desc_eq (ref null $struct)
        (block (result anyref)
          (call $effect)
          (local.get $null)
        )
        (block (result (ref $desc))
          (call $effect)
          (local.get $desc)
        )
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-stronger-fallthrough-null-null-desc (type $18) (param $null nullref) (param $desc (ref null $desc))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block (result nullref)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (ref.as_non_null
  ;; CHECK-NEXT:      (local.get $desc)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $cast-desc-eq-stronger-fallthrough-null-null-desc (type $18) (param $null nullref) (param $desc (ref null $desc))
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (ref.null none)
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $cast-desc-eq-stronger-fallthrough-null-null-desc (param $null nullref) (param $desc (ref null $desc))
    (drop
      ;; Like above, but now the descriptor is nullable so we have to add a null
      ;; check to it.
      (ref.cast_desc_eq (ref null $struct)
        (block (result anyref)
          (local.get $null)
        )
        (local.get $desc)
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-stronger-fallthrough-null-null-desc-effects (type $18) (param $null nullref) (param $desc (ref null $desc))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block (result nullref)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block (result nullref)
  ;; CHECK-NEXT:      (call $effect)
  ;; CHECK-NEXT:      (local.get $null)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (ref.as_non_null
  ;; CHECK-NEXT:      (block (result (ref null $desc))
  ;; CHECK-NEXT:       (call $effect)
  ;; CHECK-NEXT:       (local.get $desc)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $cast-desc-eq-stronger-fallthrough-null-null-desc-effects (type $18) (param $null nullref) (param $desc (ref null $desc))
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (block (result nullref)
  ;; NTRAP-NEXT:    (drop
  ;; NTRAP-NEXT:     (block (result nullref)
  ;; NTRAP-NEXT:      (call $effect)
  ;; NTRAP-NEXT:      (local.get $null)
  ;; NTRAP-NEXT:     )
  ;; NTRAP-NEXT:    )
  ;; NTRAP-NEXT:    (drop
  ;; NTRAP-NEXT:     (block (result (ref null $desc))
  ;; NTRAP-NEXT:      (call $effect)
  ;; NTRAP-NEXT:      (local.get $desc)
  ;; NTRAP-NEXT:     )
  ;; NTRAP-NEXT:    )
  ;; NTRAP-NEXT:    (ref.null none)
  ;; NTRAP-NEXT:   )
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $cast-desc-eq-stronger-fallthrough-null-null-desc-effects (param $null nullref) (param $desc (ref null $desc))
    (drop
      ;; Like above, but now with effects.
      (ref.cast_desc_eq (ref null $struct)
        (block (result anyref)
          (call $effect)
          (local.get $null)
        )
        (block (result (ref null $desc))
          (call $effect)
          (local.get $desc)
        )
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-ref-as-non-null (type $8) (param $any anyref) (param $desc (ref $desc))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $struct)
  ;; CHECK-NEXT:    (local.get $any)
  ;; CHECK-NEXT:    (local.get $desc)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $cast-desc-eq-ref-as-non-null (type $8) (param $any anyref) (param $desc (ref $desc))
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (ref.cast_desc_eq (ref $struct)
  ;; NTRAP-NEXT:    (local.get $any)
  ;; NTRAP-NEXT:    (local.get $desc)
  ;; NTRAP-NEXT:   )
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $cast-desc-eq-ref-as-non-null (param $any anyref) (param $desc (ref $desc))
    (drop
      ;; We can roll the ref.as_non_null into the cast.
      (ref.cast_desc_eq (ref null $struct)
        (ref.as_non_null
          (local.get $any)
        )
        (local.get $desc)
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-unreachable-desc (type $4)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block ;; (replaces unreachable RefCast we can't emit)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (ref.null none)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (unreachable)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $cast-desc-eq-unreachable-desc (type $4)
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (block ;; (replaces unreachable RefCast we can't emit)
  ;; NTRAP-NEXT:    (drop
  ;; NTRAP-NEXT:     (ref.null none)
  ;; NTRAP-NEXT:    )
  ;; NTRAP-NEXT:    (drop
  ;; NTRAP-NEXT:     (unreachable)
  ;; NTRAP-NEXT:    )
  ;; NTRAP-NEXT:    (unreachable)
  ;; NTRAP-NEXT:   )
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $cast-desc-eq-unreachable-desc
    (drop
      ;; Don't crash on an unreachable descriptor.
      (ref.cast_desc_eq (ref $struct)
        (ref.null none)
        (unreachable)
      )
    )
  )

  ;; CHECK:      (func $ref.get_desc-skip-non-null (type $21) (param $ref (ref null $struct)) (result anyref)
  ;; CHECK-NEXT:  (ref.get_desc $struct
  ;; CHECK-NEXT:   (local.get $ref)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $ref.get_desc-skip-non-null (type $21) (param $ref (ref null $struct)) (result anyref)
  ;; NTRAP-NEXT:  (ref.get_desc $struct
  ;; NTRAP-NEXT:   (local.get $ref)
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $ref.get_desc-skip-non-null (param $ref (ref null $struct)) (result anyref)
    (ref.get_desc $struct
      ;; This is not needed, as the parent traps on null anyhow.
      (ref.as_non_null
        (local.get $ref)
      )
    )
  )

  ;; CHECK:      (func $ref.get_desc-trap-on-null (type $11) (result anyref)
  ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $ref.get_desc-trap-on-null (type $11) (result anyref)
  ;; NTRAP-NEXT:  (unreachable)
  ;; NTRAP-NEXT: )
  (func $ref.get_desc-trap-on-null (result anyref)
    ;; This traps.
    (ref.get_desc $struct
      (block (result (ref null $struct))
        (ref.null $struct)
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-skip-non-null (type $7) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast_desc_eq (ref (exact $struct))
  ;; CHECK-NEXT:    (local.get $ref)
  ;; CHECK-NEXT:    (local.get $desc)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $cast-desc-eq-skip-non-null (type $7) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (ref.cast_desc_eq (ref (exact $struct))
  ;; NTRAP-NEXT:    (local.get $ref)
  ;; NTRAP-NEXT:    (local.get $desc)
  ;; NTRAP-NEXT:   )
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $cast-desc-eq-skip-non-null (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
    (drop
      (ref.cast_desc_eq (ref (exact $struct))
        (local.get $ref)
        ;; This is not needed, as the parent traps on null anyhow.
        (ref.as_non_null
          (local.get $desc)
        )
      )
    )
  )

  ;; CHECK:      (func $br_on_cast_desc_eq-skip-non-null (type $7) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block $l (result (ref null $struct))
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (br_on_cast_desc_eq $l (ref null $struct) (ref null (exact $struct))
  ;; CHECK-NEXT:      (local.get $ref)
  ;; CHECK-NEXT:      (local.get $desc)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (return)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $br_on_cast_desc_eq-skip-non-null (type $7) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (block $l (result (ref null $struct))
  ;; NTRAP-NEXT:    (drop
  ;; NTRAP-NEXT:     (br_on_cast_desc_eq $l (ref null $struct) (ref null (exact $struct))
  ;; NTRAP-NEXT:      (local.get $ref)
  ;; NTRAP-NEXT:      (local.get $desc)
  ;; NTRAP-NEXT:     )
  ;; NTRAP-NEXT:    )
  ;; NTRAP-NEXT:    (return)
  ;; NTRAP-NEXT:   )
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $br_on_cast_desc_eq-skip-non-null (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
    (drop
      (block $l (result (ref null $struct))
        (br_on_cast_desc_eq $l anyref (ref null $struct)
          (local.get $ref)
          ;; This is not needed, as the parent traps on null anyhow.
          (ref.as_non_null
            (local.get $desc)
          )
        )
        (return)
      )
    )
  )

  ;; CHECK:      (func $br_on_cast_desc_eq_fail-skip-non-null (type $7) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block $l (result (ref null $struct))
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (br_on_cast_desc_eq_fail $l (ref null $struct) (ref null (exact $struct))
  ;; CHECK-NEXT:      (local.get $ref)
  ;; CHECK-NEXT:      (local.get $desc)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (return)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $br_on_cast_desc_eq_fail-skip-non-null (type $7) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (block $l (result (ref null $struct))
  ;; NTRAP-NEXT:    (drop
  ;; NTRAP-NEXT:     (br_on_cast_desc_eq_fail $l (ref null $struct) (ref null (exact $struct))
  ;; NTRAP-NEXT:      (local.get $ref)
  ;; NTRAP-NEXT:      (local.get $desc)
  ;; NTRAP-NEXT:     )
  ;; NTRAP-NEXT:    )
  ;; NTRAP-NEXT:    (return)
  ;; NTRAP-NEXT:   )
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $br_on_cast_desc_eq_fail-skip-non-null (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
    (drop
      (block $l (result (ref null $struct))
        (br_on_cast_desc_eq_fail $l anyref (ref null $struct)
          (local.get $ref)
          ;; This is not needed, as the parent traps on null anyhow.
          (ref.as_non_null
            (local.get $desc)
          )
        )
        (return)
      )
    )
  )

  ;; CHECK:      (func $br_on_cast_desc_eq-trap-on-null (type $7) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block $l (result (ref none))
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block
  ;; CHECK-NEXT:      (drop
  ;; CHECK-NEXT:       (block ;; (replaces unreachable BrOn we can't emit)
  ;; CHECK-NEXT:        (drop
  ;; CHECK-NEXT:         (local.get $ref)
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:        (drop
  ;; CHECK-NEXT:         (block (result nullref)
  ;; CHECK-NEXT:          (ref.null none)
  ;; CHECK-NEXT:         )
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:        (unreachable)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (unreachable)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (return)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $br_on_cast_desc_eq-trap-on-null (type $7) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (block $l (result (ref none))
  ;; NTRAP-NEXT:    (drop
  ;; NTRAP-NEXT:     (block
  ;; NTRAP-NEXT:      (drop
  ;; NTRAP-NEXT:       (block ;; (replaces unreachable BrOn we can't emit)
  ;; NTRAP-NEXT:        (drop
  ;; NTRAP-NEXT:         (local.get $ref)
  ;; NTRAP-NEXT:        )
  ;; NTRAP-NEXT:        (drop
  ;; NTRAP-NEXT:         (block (result nullref)
  ;; NTRAP-NEXT:          (ref.null none)
  ;; NTRAP-NEXT:         )
  ;; NTRAP-NEXT:        )
  ;; NTRAP-NEXT:        (unreachable)
  ;; NTRAP-NEXT:       )
  ;; NTRAP-NEXT:      )
  ;; NTRAP-NEXT:      (unreachable)
  ;; NTRAP-NEXT:     )
  ;; NTRAP-NEXT:    )
  ;; NTRAP-NEXT:    (return)
  ;; NTRAP-NEXT:   )
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $br_on_cast_desc_eq-trap-on-null (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
    (drop
      (block $l (result (ref null $struct))
        (br_on_cast_desc_eq $l anyref (ref null $struct)
          (local.get $ref)
          (block (result (ref null $desc))
            (ref.null $desc)
          )
        )
        (return)
      )
    )
  )

  ;; CHECK:      (func $br_on_cast_desc_eq_fail-trap-on-null (type $7) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block $l (result (ref null $struct))
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block
  ;; CHECK-NEXT:      (drop
  ;; CHECK-NEXT:       (block ;; (replaces unreachable BrOn we can't emit)
  ;; CHECK-NEXT:        (drop
  ;; CHECK-NEXT:         (local.get $ref)
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:        (drop
  ;; CHECK-NEXT:         (block (result nullref)
  ;; CHECK-NEXT:          (ref.null none)
  ;; CHECK-NEXT:         )
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:        (unreachable)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (unreachable)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (return)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $br_on_cast_desc_eq_fail-trap-on-null (type $7) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (block $l (result (ref null $struct))
  ;; NTRAP-NEXT:    (drop
  ;; NTRAP-NEXT:     (block
  ;; NTRAP-NEXT:      (drop
  ;; NTRAP-NEXT:       (block ;; (replaces unreachable BrOn we can't emit)
  ;; NTRAP-NEXT:        (drop
  ;; NTRAP-NEXT:         (local.get $ref)
  ;; NTRAP-NEXT:        )
  ;; NTRAP-NEXT:        (drop
  ;; NTRAP-NEXT:         (block (result nullref)
  ;; NTRAP-NEXT:          (ref.null none)
  ;; NTRAP-NEXT:         )
  ;; NTRAP-NEXT:        )
  ;; NTRAP-NEXT:        (unreachable)
  ;; NTRAP-NEXT:       )
  ;; NTRAP-NEXT:      )
  ;; NTRAP-NEXT:      (unreachable)
  ;; NTRAP-NEXT:     )
  ;; NTRAP-NEXT:    )
  ;; NTRAP-NEXT:    (return)
  ;; NTRAP-NEXT:   )
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $br_on_cast_desc_eq_fail-trap-on-null (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
    (drop
      (block $l (result (ref null $struct))
        (br_on_cast_desc_eq_fail $l anyref (ref null $struct)
          (local.get $ref)
          (block (result (ref null $desc))
            (ref.null $desc)
          )
        )
        (return)
      )
    )
  )

  ;; CHECK:      (func $ref.cast_desc_eq-ref.as_non_null (type $4)
  ;; CHECK-NEXT:  (local $null (ref null $struct))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $struct)
  ;; CHECK-NEXT:    (ref.as_non_null
  ;; CHECK-NEXT:     (local.get $null)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (block (result (ref null $desc))
  ;; CHECK-NEXT:     (return)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast_desc_eq (ref (exact $struct))
  ;; CHECK-NEXT:    (local.get $null)
  ;; CHECK-NEXT:    (struct.new_default $desc)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; NTRAP:      (func $ref.cast_desc_eq-ref.as_non_null (type $4)
  ;; NTRAP-NEXT:  (local $null (ref null $struct))
  ;; NTRAP-NEXT:  (local $1 (ref $struct))
  ;; NTRAP-NEXT:  (local $2 (ref null $desc))
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (block (result (ref $struct))
  ;; NTRAP-NEXT:    (local.set $1
  ;; NTRAP-NEXT:     (ref.as_non_null
  ;; NTRAP-NEXT:      (local.get $null)
  ;; NTRAP-NEXT:     )
  ;; NTRAP-NEXT:    )
  ;; NTRAP-NEXT:    (local.set $2
  ;; NTRAP-NEXT:     (block (result (ref null $desc))
  ;; NTRAP-NEXT:      (return)
  ;; NTRAP-NEXT:     )
  ;; NTRAP-NEXT:    )
  ;; NTRAP-NEXT:    (local.get $1)
  ;; NTRAP-NEXT:   )
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT:  (drop
  ;; NTRAP-NEXT:   (ref.cast_desc_eq (ref (exact $struct))
  ;; NTRAP-NEXT:    (local.get $null)
  ;; NTRAP-NEXT:    (struct.new_default $desc)
  ;; NTRAP-NEXT:   )
  ;; NTRAP-NEXT:  )
  ;; NTRAP-NEXT: )
  (func $ref.cast_desc_eq-ref.as_non_null
    (local $null (ref null $struct))
    ;; We read a null local and cast it to non-null, trapping. The ref.cast_desc_eq
    ;; would trap on null anyhow, so it seems we can remove the ref.as_non_null,
    ;; but doing so would allow us to reach the block, which returns *before* the
    ;; ref.cast_desc_eq would trap.
    (drop
      (ref.cast_desc_eq (ref $struct)
        (ref.as_non_null
          (local.get $null)
        )
        ;; Hide the return in a block, otherwise we'd skip unreachable code.
        (block (result (ref null $desc))
          (return)
        )
      )
    )
    ;; As above, but without dangerous effects: we can remove the
    ;; ref.as_non_null.
    (drop
      (ref.cast_desc_eq (ref $struct)
        (ref.as_non_null
          (local.get $null)
        )
        (struct.new $desc)
      )
    )
  )
)