;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited.
;; RUN: wasm-opt %s --optimize-instructions --traps-never-happen -all -S -o - | filecheck %s --check-prefix TNH
;; RUN: wasm-opt %s --optimize-instructions                      -all -S -o - | filecheck %s --check-prefix NO_TNH

(module
  ;; TNH:      (type $struct (sub (struct (field (mut i32)))))
  ;; NO_TNH:      (type $struct (sub (struct (field (mut i32)))))
  (type $struct (sub (struct (field (mut i32)))))

  ;; TNH:      (type $void (func))
  ;; NO_TNH:      (type $void (func))
  (type $void (func))

  ;; TNH:      (import "a" "b" (func $import (type $2) (result i32)))
  ;; NO_TNH:      (import "a" "b" (func $import (type $2) (result i32)))
  (import "a" "b" (func $import (result i32)))

  ;; TNH:      (func $ref.eq (type $7) (param $a eqref) (param $b eqref) (result i32)
  ;; TNH-NEXT:  (ref.eq
  ;; TNH-NEXT:   (local.get $a)
  ;; TNH-NEXT:   (local.get $b)
  ;; TNH-NEXT:  )
  ;; TNH-NEXT: )
  ;; NO_TNH:      (func $ref.eq (type $7) (param $a eqref) (param $b eqref) (result i32)
  ;; NO_TNH-NEXT:  (ref.eq
  ;; NO_TNH-NEXT:   (ref.cast (ref $struct)
  ;; NO_TNH-NEXT:    (local.get $a)
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:   (ref.cast (ref struct)
  ;; NO_TNH-NEXT:    (local.get $b)
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT: )
  (func $ref.eq (param $a (ref null eq)) (param $b (ref null eq)) (result i32)
    ;; When traps never happen we can remove all the casts here, since they do
    ;; not affect the comparison of the references.
    (ref.eq
      ;; When traps can happen we can still improve this by removing and
      ;; combining redundant casts.
      (ref.cast (ref struct)
        (ref.as_non_null
          (ref.cast (ref null $struct)
            (local.get $a)
          )
        )
      )
      ;; Note that we can remove the non-null casts here in both modes, as the
      ;; ref.cast struct also checks for null.
      (ref.cast (ref struct)
        (ref.as_non_null
          (ref.as_non_null
            (local.get $b)
          )
        )
      )
    )
  )

  ;; TNH:      (func $ref.eq-no (type $8) (param $a eqref) (param $b eqref) (param $any anyref)
  ;; TNH-NEXT:  (drop
  ;; TNH-NEXT:   (i32.const 1)
  ;; TNH-NEXT:  )
  ;; TNH-NEXT: )
  ;; NO_TNH:      (func $ref.eq-no (type $8) (param $a eqref) (param $b eqref) (param $any anyref)
  ;; NO_TNH-NEXT:  (drop
  ;; NO_TNH-NEXT:   (ref.eq
  ;; NO_TNH-NEXT:    (ref.cast (ref null $struct)
  ;; NO_TNH-NEXT:     (local.get $any)
  ;; NO_TNH-NEXT:    )
  ;; NO_TNH-NEXT:    (ref.cast (ref struct)
  ;; NO_TNH-NEXT:     (local.get $any)
  ;; NO_TNH-NEXT:    )
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT: )
  (func $ref.eq-no (param $a (ref null eq)) (param $b (ref null eq)) (param $any anyref)
    ;; We must leave the inputs to ref.eq of type eqref or a subtype.
    (drop
      (ref.eq
        (ref.cast (ref null $struct)
          (local.get $any) ;; *Not* an eqref!
        )
        (ref.as_non_null
          (ref.cast (ref struct)
            (ref.as_non_null
              (local.get $any) ;; *Not* an eqref!
            )
          )
        )
      )
    )
  )

  ;; TNH:      (func $ref.is (type $3) (param $a eqref) (result i32)
  ;; TNH-NEXT:  (drop
  ;; TNH-NEXT:   (ref.cast (ref $struct)
  ;; TNH-NEXT:    (local.get $a)
  ;; TNH-NEXT:   )
  ;; TNH-NEXT:  )
  ;; TNH-NEXT:  (i32.const 0)
  ;; TNH-NEXT: )
  ;; NO_TNH:      (func $ref.is (type $3) (param $a eqref) (result i32)
  ;; NO_TNH-NEXT:  (drop
  ;; NO_TNH-NEXT:   (ref.cast (ref $struct)
  ;; NO_TNH-NEXT:    (local.get $a)
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT:  (i32.const 0)
  ;; NO_TNH-NEXT: )
  (func $ref.is (param $a (ref null eq)) (result i32)
    ;; In this case non-nullability is enough to tell that the ref.is will
    ;; return 0. TNH does not help here.
    (ref.is_null
      (ref.cast (ref $struct)
        (ref.as_non_null
          (ref.cast (ref struct)
            (local.get $a)
          )
        )
      )
    )
  )

  ;; TNH:      (func $ref.is_b (type $9) (param $a eqref) (param $f funcref) (result i32)
  ;; TNH-NEXT:  (drop
  ;; TNH-NEXT:   (ref.is_null
  ;; TNH-NEXT:    (local.get $a)
  ;; TNH-NEXT:   )
  ;; TNH-NEXT:  )
  ;; TNH-NEXT:  (ref.is_null
  ;; TNH-NEXT:   (local.get $f)
  ;; TNH-NEXT:  )
  ;; TNH-NEXT: )
  ;; NO_TNH:      (func $ref.is_b (type $9) (param $a eqref) (param $f funcref) (result i32)
  ;; NO_TNH-NEXT:  (drop
  ;; NO_TNH-NEXT:   (ref.is_null
  ;; NO_TNH-NEXT:    (ref.cast (ref null $struct)
  ;; NO_TNH-NEXT:     (local.get $a)
  ;; NO_TNH-NEXT:    )
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT:  (ref.is_null
  ;; NO_TNH-NEXT:   (ref.cast (ref null $void)
  ;; NO_TNH-NEXT:    (local.get $f)
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT: )
  (func $ref.is_b (param $a eqref) (param $f funcref) (result i32)
    ;; Here we only have a cast, and no cast operations that force the value
    ;; to be non-nullable. That means we cannot remove the ref.is, but we can
    ;; remove the cast in TNH.
    (drop
      (ref.is_null
        (ref.cast (ref null $struct)
          (local.get $a)
        )
      )
    )
    ;; It works on func references, too.
    (ref.is_null
      (ref.cast (ref null $void)
        (local.get $f)
      )
    )
  )

  ;; TNH:      (func $ref.test (type $3) (param $a eqref) (result i32)
  ;; TNH-NEXT:  (drop
  ;; TNH-NEXT:   (block (result i32)
  ;; TNH-NEXT:    (drop
  ;; TNH-NEXT:     (ref.cast i31ref
  ;; TNH-NEXT:      (local.get $a)
  ;; TNH-NEXT:     )
  ;; TNH-NEXT:    )
  ;; TNH-NEXT:    (i32.const 1)
  ;; TNH-NEXT:   )
  ;; TNH-NEXT:  )
  ;; TNH-NEXT:  (block (result i32)
  ;; TNH-NEXT:   (drop
  ;; TNH-NEXT:    (ref.as_non_null
  ;; TNH-NEXT:     (local.get $a)
  ;; TNH-NEXT:    )
  ;; TNH-NEXT:   )
  ;; TNH-NEXT:   (i32.const 1)
  ;; TNH-NEXT:  )
  ;; TNH-NEXT: )
  ;; NO_TNH:      (func $ref.test (type $3) (param $a eqref) (result i32)
  ;; NO_TNH-NEXT:  (drop
  ;; NO_TNH-NEXT:   (block (result i32)
  ;; NO_TNH-NEXT:    (drop
  ;; NO_TNH-NEXT:     (ref.cast i31ref
  ;; NO_TNH-NEXT:      (local.get $a)
  ;; NO_TNH-NEXT:     )
  ;; NO_TNH-NEXT:    )
  ;; NO_TNH-NEXT:    (i32.const 1)
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT:  (block (result i32)
  ;; NO_TNH-NEXT:   (drop
  ;; NO_TNH-NEXT:    (ref.as_non_null
  ;; NO_TNH-NEXT:     (local.get $a)
  ;; NO_TNH-NEXT:    )
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:   (i32.const 1)
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT: )
  (func $ref.test (param $a eqref) (result i32)
    (drop
      (ref.test i31ref
        (ref.cast i31ref
          (local.get $a)
        )
      )
    )
    (ref.test (ref eq)
      (ref.cast (ref eq)
        (local.get $a)
      )
    )
  )

  ;; TNH:      (func $if.arm.null (type $4) (param $x i32) (param $ref (ref $struct))
  ;; TNH-NEXT:  (struct.set $struct 0
  ;; TNH-NEXT:   (block (result (ref $struct))
  ;; TNH-NEXT:    (drop
  ;; TNH-NEXT:     (local.get $x)
  ;; TNH-NEXT:    )
  ;; TNH-NEXT:    (local.get $ref)
  ;; TNH-NEXT:   )
  ;; TNH-NEXT:   (i32.const 1)
  ;; TNH-NEXT:  )
  ;; TNH-NEXT:  (struct.set $struct 0
  ;; TNH-NEXT:   (block (result (ref $struct))
  ;; TNH-NEXT:    (drop
  ;; TNH-NEXT:     (local.get $x)
  ;; TNH-NEXT:    )
  ;; TNH-NEXT:    (local.get $ref)
  ;; TNH-NEXT:   )
  ;; TNH-NEXT:   (i32.const 2)
  ;; TNH-NEXT:  )
  ;; TNH-NEXT: )
  ;; NO_TNH:      (func $if.arm.null (type $4) (param $x i32) (param $ref (ref $struct))
  ;; NO_TNH-NEXT:  (struct.set $struct 0
  ;; NO_TNH-NEXT:   (if (result (ref null $struct))
  ;; NO_TNH-NEXT:    (local.get $x)
  ;; NO_TNH-NEXT:    (then
  ;; NO_TNH-NEXT:     (local.get $ref)
  ;; NO_TNH-NEXT:    )
  ;; NO_TNH-NEXT:    (else
  ;; NO_TNH-NEXT:     (ref.null none)
  ;; NO_TNH-NEXT:    )
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:   (i32.const 1)
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT:  (struct.set $struct 0
  ;; NO_TNH-NEXT:   (if (result (ref null $struct))
  ;; NO_TNH-NEXT:    (local.get $x)
  ;; NO_TNH-NEXT:    (then
  ;; NO_TNH-NEXT:     (ref.null none)
  ;; NO_TNH-NEXT:    )
  ;; NO_TNH-NEXT:    (else
  ;; NO_TNH-NEXT:     (local.get $ref)
  ;; NO_TNH-NEXT:    )
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:   (i32.const 2)
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT: )
  (func $if.arm.null (param $x i32) (param $ref (ref $struct))
    ;; A set will trap on a null, so in tnh mode we know the null arm is not
    ;; executed, and the other one is.
    (struct.set $struct 0
      (if (result (ref null $struct))
        (local.get $x)
        (then
          (local.get $ref)
        )
        (else
          (ref.null none)
        )
      )
      (i32.const 1)
    )
    (struct.set $struct 0
      (if (result (ref null $struct))
        (local.get $x)
        (then
          (ref.null none)
        )
        (else
          (local.get $ref)
        )
      )
      (i32.const 2)
    )
  )

  ;; TNH:      (func $select.arm.null (type $4) (param $x i32) (param $ref (ref $struct))
  ;; TNH-NEXT:  (struct.set $struct 0
  ;; TNH-NEXT:   (block (result (ref $struct))
  ;; TNH-NEXT:    (block
  ;; TNH-NEXT:     (drop
  ;; TNH-NEXT:      (ref.null none)
  ;; TNH-NEXT:     )
  ;; TNH-NEXT:     (drop
  ;; TNH-NEXT:      (local.get $x)
  ;; TNH-NEXT:     )
  ;; TNH-NEXT:    )
  ;; TNH-NEXT:    (local.get $ref)
  ;; TNH-NEXT:   )
  ;; TNH-NEXT:   (i32.const 1)
  ;; TNH-NEXT:  )
  ;; TNH-NEXT:  (struct.set $struct 0
  ;; TNH-NEXT:   (block (result (ref $struct))
  ;; TNH-NEXT:    (drop
  ;; TNH-NEXT:     (ref.null none)
  ;; TNH-NEXT:    )
  ;; TNH-NEXT:    (block (result (ref $struct))
  ;; TNH-NEXT:     (drop
  ;; TNH-NEXT:      (local.get $x)
  ;; TNH-NEXT:     )
  ;; TNH-NEXT:     (local.get $ref)
  ;; TNH-NEXT:    )
  ;; TNH-NEXT:   )
  ;; TNH-NEXT:   (i32.const 2)
  ;; TNH-NEXT:  )
  ;; TNH-NEXT: )
  ;; NO_TNH:      (func $select.arm.null (type $4) (param $x i32) (param $ref (ref $struct))
  ;; NO_TNH-NEXT:  (struct.set $struct 0
  ;; NO_TNH-NEXT:   (select (result (ref null $struct))
  ;; NO_TNH-NEXT:    (local.get $ref)
  ;; NO_TNH-NEXT:    (ref.null none)
  ;; NO_TNH-NEXT:    (local.get $x)
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:   (i32.const 1)
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT:  (struct.set $struct 0
  ;; NO_TNH-NEXT:   (select (result (ref null $struct))
  ;; NO_TNH-NEXT:    (ref.null none)
  ;; NO_TNH-NEXT:    (local.get $ref)
  ;; NO_TNH-NEXT:    (local.get $x)
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:   (i32.const 2)
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT: )
  (func $select.arm.null (param $x i32) (param $ref (ref $struct))
    ;; As above but with a select.
    (struct.set $struct 0
      (select (result (ref null $struct))
        (local.get $ref)
        (ref.null none)
        (local.get $x)
      )
      (i32.const 1)
    )
    (struct.set $struct 0
      (select (result (ref null $struct))
        (ref.null none)
        (local.get $ref)
        (local.get $x)
      )
      (i32.const 2)
    )
  )

  ;; TNH:      (func $select.arm.null.effects (type $void)
  ;; TNH-NEXT:  (local $temp i32)
  ;; TNH-NEXT:  (local $1 (ref $struct))
  ;; TNH-NEXT:  (local $2 (ref $struct))
  ;; TNH-NEXT:  (struct.set $struct 0
  ;; TNH-NEXT:   (block (result (ref $struct))
  ;; TNH-NEXT:    (local.set $1
  ;; TNH-NEXT:     (struct.new $struct
  ;; TNH-NEXT:      (local.tee $temp
  ;; TNH-NEXT:       (i32.const 1)
  ;; TNH-NEXT:      )
  ;; TNH-NEXT:     )
  ;; TNH-NEXT:    )
  ;; TNH-NEXT:    (block
  ;; TNH-NEXT:     (drop
  ;; TNH-NEXT:      (block (result nullref)
  ;; TNH-NEXT:       (local.set $temp
  ;; TNH-NEXT:        (i32.const 2)
  ;; TNH-NEXT:       )
  ;; TNH-NEXT:       (ref.null none)
  ;; TNH-NEXT:      )
  ;; TNH-NEXT:     )
  ;; TNH-NEXT:     (drop
  ;; TNH-NEXT:      (local.get $temp)
  ;; TNH-NEXT:     )
  ;; TNH-NEXT:    )
  ;; TNH-NEXT:    (local.get $1)
  ;; TNH-NEXT:   )
  ;; TNH-NEXT:   (i32.const 1)
  ;; TNH-NEXT:  )
  ;; TNH-NEXT:  (struct.set $struct 0
  ;; TNH-NEXT:   (block (result (ref $struct))
  ;; TNH-NEXT:    (drop
  ;; TNH-NEXT:     (block (result nullref)
  ;; TNH-NEXT:      (local.set $temp
  ;; TNH-NEXT:       (i32.const 2)
  ;; TNH-NEXT:      )
  ;; TNH-NEXT:      (ref.null none)
  ;; TNH-NEXT:     )
  ;; TNH-NEXT:    )
  ;; TNH-NEXT:    (block (result (ref $struct))
  ;; TNH-NEXT:     (local.set $2
  ;; TNH-NEXT:      (struct.new $struct
  ;; TNH-NEXT:       (local.tee $temp
  ;; TNH-NEXT:        (i32.const 1)
  ;; TNH-NEXT:       )
  ;; TNH-NEXT:      )
  ;; TNH-NEXT:     )
  ;; TNH-NEXT:     (drop
  ;; TNH-NEXT:      (local.get $temp)
  ;; TNH-NEXT:     )
  ;; TNH-NEXT:     (local.get $2)
  ;; TNH-NEXT:    )
  ;; TNH-NEXT:   )
  ;; TNH-NEXT:   (i32.const 2)
  ;; TNH-NEXT:  )
  ;; TNH-NEXT: )
  ;; NO_TNH:      (func $select.arm.null.effects (type $void)
  ;; NO_TNH-NEXT:  (local $temp i32)
  ;; NO_TNH-NEXT:  (struct.set $struct 0
  ;; NO_TNH-NEXT:   (select (result (ref null $struct))
  ;; NO_TNH-NEXT:    (struct.new $struct
  ;; NO_TNH-NEXT:     (local.tee $temp
  ;; NO_TNH-NEXT:      (i32.const 1)
  ;; NO_TNH-NEXT:     )
  ;; NO_TNH-NEXT:    )
  ;; NO_TNH-NEXT:    (block (result nullref)
  ;; NO_TNH-NEXT:     (local.set $temp
  ;; NO_TNH-NEXT:      (i32.const 2)
  ;; NO_TNH-NEXT:     )
  ;; NO_TNH-NEXT:     (ref.null none)
  ;; NO_TNH-NEXT:    )
  ;; NO_TNH-NEXT:    (local.get $temp)
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:   (i32.const 1)
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT:  (struct.set $struct 0
  ;; NO_TNH-NEXT:   (select (result (ref null $struct))
  ;; NO_TNH-NEXT:    (block (result nullref)
  ;; NO_TNH-NEXT:     (local.set $temp
  ;; NO_TNH-NEXT:      (i32.const 2)
  ;; NO_TNH-NEXT:     )
  ;; NO_TNH-NEXT:     (ref.null none)
  ;; NO_TNH-NEXT:    )
  ;; NO_TNH-NEXT:    (struct.new $struct
  ;; NO_TNH-NEXT:     (local.tee $temp
  ;; NO_TNH-NEXT:      (i32.const 1)
  ;; NO_TNH-NEXT:     )
  ;; NO_TNH-NEXT:    )
  ;; NO_TNH-NEXT:    (local.get $temp)
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:   (i32.const 2)
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT: )
  (func $select.arm.null.effects
    (local $temp i32)
    ;; As above but there are conflicting effects and we must add a local when
    ;; we optimize.
    (struct.set $struct 0
      (select (result (ref null $struct))
        (struct.new $struct
          (local.tee $temp
            (i32.const 1)
          )
        )
        (block (result (ref null none))
          (local.set $temp
            (i32.const 2)
          )
          (ref.null none)
        )
        (local.get $temp)
      )
      (i32.const 1)
    )
    (struct.set $struct 0
      (select (result (ref null $struct))
        (block (result (ref null none))
          (local.set $temp
            (i32.const 2)
          )
          (ref.null none)
        )
        (struct.new $struct
          (local.tee $temp
            (i32.const 1)
          )
        )
        (local.get $temp)
      )
      (i32.const 2)
    )
  )

  ;; TNH:      (func $null.arm.null.effects (type $void)
  ;; TNH-NEXT:  (block ;; (replaces unreachable StructSet we can't emit)
  ;; TNH-NEXT:   (drop
  ;; TNH-NEXT:    (select
  ;; TNH-NEXT:     (unreachable)
  ;; TNH-NEXT:     (ref.null none)
  ;; TNH-NEXT:     (call $get-i32)
  ;; TNH-NEXT:    )
  ;; TNH-NEXT:   )
  ;; TNH-NEXT:   (drop
  ;; TNH-NEXT:    (i32.const 1)
  ;; TNH-NEXT:   )
  ;; TNH-NEXT:   (unreachable)
  ;; TNH-NEXT:  )
  ;; TNH-NEXT:  (block
  ;; TNH-NEXT:   (drop
  ;; TNH-NEXT:    (block (result nullref)
  ;; TNH-NEXT:     (drop
  ;; TNH-NEXT:      (call $get-i32)
  ;; TNH-NEXT:     )
  ;; TNH-NEXT:     (ref.null none)
  ;; TNH-NEXT:    )
  ;; TNH-NEXT:   )
  ;; TNH-NEXT:   (unreachable)
  ;; TNH-NEXT:  )
  ;; TNH-NEXT: )
  ;; NO_TNH:      (func $null.arm.null.effects (type $void)
  ;; NO_TNH-NEXT:  (block ;; (replaces unreachable StructSet we can't emit)
  ;; NO_TNH-NEXT:   (drop
  ;; NO_TNH-NEXT:    (select
  ;; NO_TNH-NEXT:     (unreachable)
  ;; NO_TNH-NEXT:     (ref.null none)
  ;; NO_TNH-NEXT:     (call $get-i32)
  ;; NO_TNH-NEXT:    )
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:   (drop
  ;; NO_TNH-NEXT:    (i32.const 1)
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:   (unreachable)
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT:  (block
  ;; NO_TNH-NEXT:   (drop
  ;; NO_TNH-NEXT:    (block (result nullref)
  ;; NO_TNH-NEXT:     (drop
  ;; NO_TNH-NEXT:      (call $get-i32)
  ;; NO_TNH-NEXT:     )
  ;; NO_TNH-NEXT:     (ref.null none)
  ;; NO_TNH-NEXT:    )
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:   (unreachable)
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT: )
  (func $null.arm.null.effects
    ;; Verify we do not error on a null reference in a select, even if cast to
    ;; non-null.
    (struct.set $struct 0
      (select (result (ref null $struct))
        (ref.as_non_null
          (ref.null none)
        )
        (ref.null none)
        (call $get-i32)
      )
      (i32.const 1)
    )
    ;; The same, but without ref.as_non_null.
    (struct.set $struct 0
      (select (result (ref null $struct))
        (ref.null none)
        (ref.null none)
        (call $get-i32)
      )
      (i32.const 1)
    )
  )

  ;; TNH:      (func $set-get-cast (type $10) (param $ref structref)
  ;; TNH-NEXT:  (drop
  ;; TNH-NEXT:   (struct.get $struct 0
  ;; TNH-NEXT:    (ref.cast (ref $struct)
  ;; TNH-NEXT:     (local.get $ref)
  ;; TNH-NEXT:    )
  ;; TNH-NEXT:   )
  ;; TNH-NEXT:  )
  ;; TNH-NEXT:  (struct.set $struct 0
  ;; TNH-NEXT:   (ref.cast (ref $struct)
  ;; TNH-NEXT:    (local.get $ref)
  ;; TNH-NEXT:   )
  ;; TNH-NEXT:   (i32.const 1)
  ;; TNH-NEXT:  )
  ;; TNH-NEXT:  (struct.set $struct 0
  ;; TNH-NEXT:   (ref.cast (ref null $struct)
  ;; TNH-NEXT:    (local.get $ref)
  ;; TNH-NEXT:   )
  ;; TNH-NEXT:   (block (result i32)
  ;; TNH-NEXT:    (return)
  ;; TNH-NEXT:    (i32.const 1)
  ;; TNH-NEXT:   )
  ;; TNH-NEXT:  )
  ;; TNH-NEXT: )
  ;; NO_TNH:      (func $set-get-cast (type $10) (param $ref structref)
  ;; NO_TNH-NEXT:  (drop
  ;; NO_TNH-NEXT:   (struct.get $struct 0
  ;; NO_TNH-NEXT:    (ref.cast (ref $struct)
  ;; NO_TNH-NEXT:     (local.get $ref)
  ;; NO_TNH-NEXT:    )
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT:  (struct.set $struct 0
  ;; NO_TNH-NEXT:   (ref.cast (ref null $struct)
  ;; NO_TNH-NEXT:    (local.get $ref)
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:   (i32.const 1)
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT:  (struct.set $struct 0
  ;; NO_TNH-NEXT:   (ref.cast (ref null $struct)
  ;; NO_TNH-NEXT:    (local.get $ref)
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:   (block (result i32)
  ;; NO_TNH-NEXT:    (return)
  ;; NO_TNH-NEXT:    (i32.const 1)
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT: )
  (func $set-get-cast (param $ref (ref null struct))
    ;; A nullable cast flowing into a place that traps on null can become a
    ;; non-nullable cast.
    (drop
      (struct.get $struct 0
        (ref.cast (ref null $struct)
          (local.get $ref)
        )
      )
    )
    ;; Ditto for a set, at least in traps-happen mode.
    ;; TODO handle non-TNH as well, but we need to be careful of effects in
    ;;      other children.
    (struct.set $struct 0
      (ref.cast (ref null $struct)
        (local.get $ref)
      )
      (i32.const 1)
    )
    ;; Even in TNH mode, a child with an effect of control flow transfer
    ;; prevents us from optimizing - if the parent is not necessarily reached,
    ;; we cannot infer the child won't trap.
    (struct.set $struct 0
      (ref.cast (ref null $struct)
        (local.get $ref)
      )
      (block (result i32)
        ;; This block has type i32, to check that we don't just look for
        ;; unreachable. We must scan for any transfer of control flow in the
        ;; child of the struct.set.
        (return)
        (i32.const 1)
      )
    )
  )

  ;; TNH:      (func $cast-if-null (type $5) (param $x (ref none)) (result (ref $struct))
  ;; TNH-NEXT:  (drop
  ;; TNH-NEXT:   (block
  ;; TNH-NEXT:    (drop
  ;; TNH-NEXT:     (i32.const 1)
  ;; TNH-NEXT:    )
  ;; TNH-NEXT:    (unreachable)
  ;; TNH-NEXT:   )
  ;; TNH-NEXT:  )
  ;; TNH-NEXT:  (unreachable)
  ;; TNH-NEXT: )
  ;; NO_TNH:      (func $cast-if-null (type $5) (param $x (ref none)) (result (ref $struct))
  ;; NO_TNH-NEXT:  (drop
  ;; NO_TNH-NEXT:   (if (result (ref none))
  ;; NO_TNH-NEXT:    (i32.const 1)
  ;; NO_TNH-NEXT:    (then
  ;; NO_TNH-NEXT:     (unreachable)
  ;; NO_TNH-NEXT:    )
  ;; NO_TNH-NEXT:    (else
  ;; NO_TNH-NEXT:     (local.get $x)
  ;; NO_TNH-NEXT:    )
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT:  (unreachable)
  ;; NO_TNH-NEXT: )
  (func $cast-if-null (param $x (ref none)) (result (ref $struct))
    ;; We can remove the unreachable arm of the if here in TNH mode. While doing
    ;; so we must refinalize properly or else we'll hit an error in pass-debug
    ;; mode.
    (ref.cast (ref $struct)
      (if (result (ref none))
        (i32.const 1)
        (then
          (unreachable)
        )
        (else
          (local.get $x)
        )
      )
    )
  )

  ;; TNH:      (func $cast-if-null-flip (type $5) (param $x (ref none)) (result (ref $struct))
  ;; TNH-NEXT:  (drop
  ;; TNH-NEXT:   (block
  ;; TNH-NEXT:    (drop
  ;; TNH-NEXT:     (i32.const 1)
  ;; TNH-NEXT:    )
  ;; TNH-NEXT:    (unreachable)
  ;; TNH-NEXT:   )
  ;; TNH-NEXT:  )
  ;; TNH-NEXT:  (unreachable)
  ;; TNH-NEXT: )
  ;; NO_TNH:      (func $cast-if-null-flip (type $5) (param $x (ref none)) (result (ref $struct))
  ;; NO_TNH-NEXT:  (drop
  ;; NO_TNH-NEXT:   (if (result (ref none))
  ;; NO_TNH-NEXT:    (i32.const 1)
  ;; NO_TNH-NEXT:    (then
  ;; NO_TNH-NEXT:     (local.get $x)
  ;; NO_TNH-NEXT:    )
  ;; NO_TNH-NEXT:    (else
  ;; NO_TNH-NEXT:     (unreachable)
  ;; NO_TNH-NEXT:    )
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT:  (unreachable)
  ;; NO_TNH-NEXT: )
  (func $cast-if-null-flip (param $x (ref none)) (result (ref $struct))
    ;; As above but with arms flipped.
    (ref.cast (ref $struct)
      (if (result (ref none))
        (i32.const 1)
        (then
          (local.get $x)
        )
        (else
          (unreachable)
        )
      )
    )
  )

  ;; TNH:      (func $cast-to-bottom (type $11) (param $ref (ref any)) (param $nullable-ref anyref)
  ;; TNH-NEXT:  (drop
  ;; TNH-NEXT:   (block (result (ref none))
  ;; TNH-NEXT:    (drop
  ;; TNH-NEXT:     (local.get $ref)
  ;; TNH-NEXT:    )
  ;; TNH-NEXT:    (unreachable)
  ;; TNH-NEXT:   )
  ;; TNH-NEXT:  )
  ;; TNH-NEXT:  (drop
  ;; TNH-NEXT:   (block (result (ref none))
  ;; TNH-NEXT:    (drop
  ;; TNH-NEXT:     (local.get $nullable-ref)
  ;; TNH-NEXT:    )
  ;; TNH-NEXT:    (unreachable)
  ;; TNH-NEXT:   )
  ;; TNH-NEXT:  )
  ;; TNH-NEXT:  (drop
  ;; TNH-NEXT:   (block (result (ref none))
  ;; TNH-NEXT:    (drop
  ;; TNH-NEXT:     (local.get $ref)
  ;; TNH-NEXT:    )
  ;; TNH-NEXT:    (unreachable)
  ;; TNH-NEXT:   )
  ;; TNH-NEXT:  )
  ;; TNH-NEXT:  (drop
  ;; TNH-NEXT:   (block (result nullref)
  ;; TNH-NEXT:    (drop
  ;; TNH-NEXT:     (local.get $nullable-ref)
  ;; TNH-NEXT:    )
  ;; TNH-NEXT:    (ref.null none)
  ;; TNH-NEXT:   )
  ;; TNH-NEXT:  )
  ;; TNH-NEXT: )
  ;; NO_TNH:      (func $cast-to-bottom (type $11) (param $ref (ref any)) (param $nullable-ref anyref)
  ;; NO_TNH-NEXT:  (drop
  ;; NO_TNH-NEXT:   (block (result (ref none))
  ;; NO_TNH-NEXT:    (drop
  ;; NO_TNH-NEXT:     (local.get $ref)
  ;; NO_TNH-NEXT:    )
  ;; NO_TNH-NEXT:    (unreachable)
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT:  (drop
  ;; NO_TNH-NEXT:   (block (result (ref none))
  ;; NO_TNH-NEXT:    (drop
  ;; NO_TNH-NEXT:     (local.get $nullable-ref)
  ;; NO_TNH-NEXT:    )
  ;; NO_TNH-NEXT:    (unreachable)
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT:  (drop
  ;; NO_TNH-NEXT:   (block (result (ref none))
  ;; NO_TNH-NEXT:    (drop
  ;; NO_TNH-NEXT:     (local.get $ref)
  ;; NO_TNH-NEXT:    )
  ;; NO_TNH-NEXT:    (unreachable)
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT:  (drop
  ;; NO_TNH-NEXT:   (ref.cast nullref
  ;; NO_TNH-NEXT:    (local.get $nullable-ref)
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT: )
  (func $cast-to-bottom (param $ref (ref any)) (param $nullable-ref anyref)
    ;; Non-nullable casts to none must trap (regardless of whether the input is
    ;; nullable or not, the output is an impossible type).
    (drop
      (ref.cast (ref none)
        (local.get $ref)
      )
    )
    (drop
      (ref.cast (ref none)
        (local.get $nullable-ref)
      )
    )
    ;; Nullable casts to null have more possibilities. First, if the input is
    ;; non-nullable then we trap.
    (drop
      (ref.cast nullref
        (local.get $ref)
      )
    )
    ;; Second, if the value may be a null, then we either return a null or we
    ;; trap. In TNH mode we dismiss the possibility of a trap and so we can just
    ;; return a null here. (In non-TNH mode we could do a check for null etc.,
    ;; but we'd be increasing code size.)
    (drop
      (ref.cast nullref
        (local.get $nullable-ref)
      )
    )
  )

  ;; TNH:      (func $null.cast-other.effects (type $12) (param $x (ref null $struct))
  ;; TNH-NEXT:  (local $i i32)
  ;; TNH-NEXT:  (struct.set $struct 0
  ;; TNH-NEXT:   (local.get $x)
  ;; TNH-NEXT:   (call $import)
  ;; TNH-NEXT:  )
  ;; TNH-NEXT:  (struct.set $struct 0
  ;; TNH-NEXT:   (local.get $x)
  ;; TNH-NEXT:   (i32.const 10)
  ;; TNH-NEXT:  )
  ;; TNH-NEXT:  (struct.set $struct 0
  ;; TNH-NEXT:   (local.get $x)
  ;; TNH-NEXT:   (local.tee $i
  ;; TNH-NEXT:    (i32.const 10)
  ;; TNH-NEXT:   )
  ;; TNH-NEXT:  )
  ;; TNH-NEXT: )
  ;; NO_TNH:      (func $null.cast-other.effects (type $12) (param $x (ref null $struct))
  ;; NO_TNH-NEXT:  (local $i i32)
  ;; NO_TNH-NEXT:  (struct.set $struct 0
  ;; NO_TNH-NEXT:   (ref.as_non_null
  ;; NO_TNH-NEXT:    (local.get $x)
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:   (call $import)
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT:  (struct.set $struct 0
  ;; NO_TNH-NEXT:   (local.get $x)
  ;; NO_TNH-NEXT:   (i32.const 10)
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT:  (struct.set $struct 0
  ;; NO_TNH-NEXT:   (local.get $x)
  ;; NO_TNH-NEXT:   (local.tee $i
  ;; NO_TNH-NEXT:    (i32.const 10)
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT: )
  (func $null.cast-other.effects (param $x (ref null $struct))
    (local $i i32)
    (struct.set $struct 0
      ;; We cannot remove this ref.as_non_null, even though the struct.set will
      ;; trap if the ref is null, because that would move the trap from before
      ;; the call to the import to be after it. But in TNH we can assume it does
      ;; not trap, and remove it.
      (ref.as_non_null
        (local.get $x)
      )
      (call $import)
    )
    (struct.set $struct 0
      ;; This one can be removed even without TNH, as there are no effects after
      ;; it.
      (ref.as_non_null
        (local.get $x)
      )
      (i32.const 10)
    )
    (struct.set $struct 0
      ;; This one can be removed even without TNH, even though there are effects
      ;; in it. A tee only has local effects, which do not interfere with a
      ;; trap.
      (ref.as_non_null
        (local.get $x)
      )
      (local.tee $i
        (i32.const 10)
      )
    )
  )

  ;; TNH:      (func $select.unreachable.child (type $6) (param $x (ref $struct)) (result (ref $struct))
  ;; TNH-NEXT:  (block ;; (replaces unreachable RefCast we can't emit)
  ;; TNH-NEXT:   (drop
  ;; TNH-NEXT:    (unreachable)
  ;; TNH-NEXT:   )
  ;; TNH-NEXT:   (unreachable)
  ;; TNH-NEXT:  )
  ;; TNH-NEXT: )
  ;; NO_TNH:      (func $select.unreachable.child (type $6) (param $x (ref $struct)) (result (ref $struct))
  ;; NO_TNH-NEXT:  (block ;; (replaces unreachable RefCast we can't emit)
  ;; NO_TNH-NEXT:   (drop
  ;; NO_TNH-NEXT:    (unreachable)
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:   (unreachable)
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT: )
  (func $select.unreachable.child (param $x (ref $struct)) (result (ref $struct))
    ;; We will turn the false arm of the select into an unreachable first, and
    ;; then process the select. While doing so we must not error, as the select
    ;; itself will still have a reachable type (a full refinalize only
    ;; happens at the very end of the function).
    (ref.cast (ref $struct)
      (select (result (ref $struct))
        (ref.as_non_null
          (ref.null none)
        )
        (local.get $x)
        (i32.const 1)
      )
    )
  )

  ;; TNH:      (func $select.unreachable.child.flip (type $6) (param $x (ref $struct)) (result (ref $struct))
  ;; TNH-NEXT:  (select
  ;; TNH-NEXT:   (local.get $x)
  ;; TNH-NEXT:   (unreachable)
  ;; TNH-NEXT:   (i32.const 1)
  ;; TNH-NEXT:  )
  ;; TNH-NEXT: )
  ;; NO_TNH:      (func $select.unreachable.child.flip (type $6) (param $x (ref $struct)) (result (ref $struct))
  ;; NO_TNH-NEXT:  (select
  ;; NO_TNH-NEXT:   (local.get $x)
  ;; NO_TNH-NEXT:   (unreachable)
  ;; NO_TNH-NEXT:   (i32.const 1)
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT: )
  (func $select.unreachable.child.flip (param $x (ref $struct)) (result (ref $struct))
    ;; Flip case of the above.
    (ref.cast (ref $struct)
      (select (result (ref $struct))
        (local.get $x)
        (ref.as_non_null
          (ref.null none)
        )
        (i32.const 1)
      )
    )
  )

  ;; TNH:      (func $if.null.child.but.no.flow (type $void)
  ;; TNH-NEXT:  (drop
  ;; TNH-NEXT:   (block (result (ref nofunc))
  ;; TNH-NEXT:    (drop
  ;; TNH-NEXT:     (if (result (ref nofunc))
  ;; TNH-NEXT:      (i32.const 1)
  ;; TNH-NEXT:      (then
  ;; TNH-NEXT:       (return)
  ;; TNH-NEXT:      )
  ;; TNH-NEXT:      (else
  ;; TNH-NEXT:       (unreachable)
  ;; TNH-NEXT:      )
  ;; TNH-NEXT:     )
  ;; TNH-NEXT:    )
  ;; TNH-NEXT:    (unreachable)
  ;; TNH-NEXT:   )
  ;; TNH-NEXT:  )
  ;; TNH-NEXT: )
  ;; NO_TNH:      (func $if.null.child.but.no.flow (type $void)
  ;; NO_TNH-NEXT:  (drop
  ;; NO_TNH-NEXT:   (block (result (ref nofunc))
  ;; NO_TNH-NEXT:    (drop
  ;; NO_TNH-NEXT:     (if (result (ref nofunc))
  ;; NO_TNH-NEXT:      (i32.const 1)
  ;; NO_TNH-NEXT:      (then
  ;; NO_TNH-NEXT:       (return)
  ;; NO_TNH-NEXT:      )
  ;; NO_TNH-NEXT:      (else
  ;; NO_TNH-NEXT:       (unreachable)
  ;; NO_TNH-NEXT:      )
  ;; NO_TNH-NEXT:     )
  ;; NO_TNH-NEXT:    )
  ;; NO_TNH-NEXT:    (unreachable)
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT: )
  (func $if.null.child.but.no.flow
    ;; The if's true arm has a bottom type, which the cast would trap on. But we
    ;; cannot optimize using that fact, as the null does not actually flow out -
    ;; we return from the function before. So we should not replace the if with
    ;; the false arm (that would trap, and change the behavior; tnh can remove
    ;; traps, not add them).
    (drop
      (ref.cast (ref func)
        (if (result (ref nofunc))
          (i32.const 1)
          (then
            (block (result (ref nofunc))
              (return)
            )
          )
          (else
            (unreachable)
          )
        )
      )
    )
  )

  ;; TNH:      (func $set-of-as-non-null (type $void)
  ;; TNH-NEXT:  (local $x anyref)
  ;; TNH-NEXT:  (local.set $x
  ;; TNH-NEXT:   (local.get $x)
  ;; TNH-NEXT:  )
  ;; TNH-NEXT:  (drop
  ;; TNH-NEXT:   (ref.as_non_null
  ;; TNH-NEXT:    (local.tee $x
  ;; TNH-NEXT:     (local.get $x)
  ;; TNH-NEXT:    )
  ;; TNH-NEXT:   )
  ;; TNH-NEXT:  )
  ;; TNH-NEXT: )
  ;; NO_TNH:      (func $set-of-as-non-null (type $void)
  ;; NO_TNH-NEXT:  (local $x anyref)
  ;; NO_TNH-NEXT:  (local.set $x
  ;; NO_TNH-NEXT:   (ref.as_non_null
  ;; NO_TNH-NEXT:    (local.get $x)
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT:  (drop
  ;; NO_TNH-NEXT:   (ref.as_non_null
  ;; NO_TNH-NEXT:    (local.tee $x
  ;; NO_TNH-NEXT:     (local.get $x)
  ;; NO_TNH-NEXT:    )
  ;; NO_TNH-NEXT:   )
  ;; NO_TNH-NEXT:  )
  ;; NO_TNH-NEXT: )
  (func $set-of-as-non-null
    (local $x anyref)
    ;; We can remove the ref.as_non_null here because the local is nullable and
    ;; we are ignoring traps.
    ;; TODO: Should we keep the cast to let us refine the local later?
    (local.set $x
      (ref.as_non_null
        (local.get $x)
      )
    )
    ;; The same for a tee.
    (drop
      (local.tee $x
        (ref.as_non_null
          (local.get $x)
        )
      )
    )
  )


  ;; Helper functions.

  ;; TNH:      (func $get-i32 (type $2) (result i32)
  ;; TNH-NEXT:  (unreachable)
  ;; TNH-NEXT: )
  ;; NO_TNH:      (func $get-i32 (type $2) (result i32)
  ;; NO_TNH-NEXT:  (unreachable)
  ;; NO_TNH-NEXT: )
  (func $get-i32 (result i32)
    (unreachable)
  )
  ;; TNH:      (func $get-ref (type $13) (result (ref $struct))
  ;; TNH-NEXT:  (unreachable)
  ;; TNH-NEXT: )
  ;; NO_TNH:      (func $get-ref (type $13) (result (ref $struct))
  ;; NO_TNH-NEXT:  (unreachable)
  ;; NO_TNH-NEXT: )
  (func $get-ref (result (ref $struct))
    (unreachable)
  )
  ;; TNH:      (func $get-null (type $14) (result nullref)
  ;; TNH-NEXT:  (unreachable)
  ;; TNH-NEXT: )
  ;; NO_TNH:      (func $get-null (type $14) (result nullref)
  ;; NO_TNH-NEXT:  (unreachable)
  ;; NO_TNH-NEXT: )
  (func $get-null (result (ref null none))
    (unreachable)
  )
)