;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited.
;; RUN: foreach %s %t wasm-opt -all --gufa -tnh -S -o - | filecheck %s

(module
  ;; CHECK:      (type $0 (func (param funcref funcref funcref funcref)))

  ;; CHECK:      (type $1 (func))

  ;; CHECK:      (import "a" "b" (global $unknown-i32 i32))
  (import "a" "b" (global $unknown-i32 i32))

  ;; CHECK:      (import "a" "b" (global $unknown-funcref1 funcref))
  (import "a" "b" (global $unknown-funcref1 funcref))

  ;; CHECK:      (import "a" "b" (global $unknown-funcref2 funcref))
  (import "a" "b" (global $unknown-funcref2 funcref))

  ;; CHECK:      (import "a" "b" (global $unknown-nn-func1 (ref func)))
  (import "a" "b" (global $unknown-nn-func1 (ref func)))

  ;; CHECK:      (import "a" "b" (global $unknown-nn-func2 (ref func)))
  (import "a" "b" (global $unknown-nn-func2 (ref func)))

  ;; CHECK:      (func $called (type $0) (param $x funcref) (param $no-cast funcref) (param $y funcref) (param $z funcref)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast (ref func)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast (ref func)
  ;; CHECK-NEXT:    (local.get $y)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast (ref func)
  ;; CHECK-NEXT:    (local.get $z)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $called (param $x funcref) (param $no-cast funcref) (param $y funcref) (param $z funcref)
    ;; All but the second parameter are cast here, which allows some
    ;; optimization in the caller. Nothing significant changes here in this
    ;; function.
    (drop
      (ref.cast (ref func)
        (local.get $x)
      )
    )
    (drop
      (ref.cast (ref func)
        (local.get $y)
      )
    )
    (drop
      (ref.cast (ref func)
        (local.get $z)
      )
    )
  )

  ;; CHECK:      (func $caller (type $1)
  ;; CHECK-NEXT:  (local $f funcref)
  ;; CHECK-NEXT:  (local.set $f
  ;; CHECK-NEXT:   (select (result funcref)
  ;; CHECK-NEXT:    (global.get $unknown-funcref1)
  ;; CHECK-NEXT:    (global.get $unknown-funcref2)
  ;; CHECK-NEXT:    (global.get $unknown-i32)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (ref.cast (ref func)
  ;; CHECK-NEXT:    (local.get $f)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (ref.cast funcref
  ;; CHECK-NEXT:    (local.get $f)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (local.get $f)
  ;; CHECK-NEXT:   (ref.cast (ref func)
  ;; CHECK-NEXT:    (local.get $f)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (ref.cast (ref func)
  ;; CHECK-NEXT:    (local.get $f)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (local.get $f)
  ;; CHECK-NEXT:   (ref.cast (ref func)
  ;; CHECK-NEXT:    (local.get $f)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (ref.cast (ref func)
  ;; CHECK-NEXT:    (local.get $f)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $caller
    (local $f funcref)

    ;; Fill the local with an unknown value (so that trivial inference doesn't
    ;; optimize away the thing we care about below).
    (local.set $f
      (select
        (global.get $unknown-funcref1)
        (global.get $unknown-funcref2)
        (global.get $unknown-i32)
      )
    )

    ;; All but the third parameter are cast here. The cast has no effect by
    ;; itself as the type is funcref, but GUFA will refine casts when it can
    ;; (but not add a new cast, which might not be worth it).
    ;;
    ;; Specifically here, the first and last cast can be refined, since those
    ;; are cast both here and in the called function. Those casts will lose the
    ;; "null" and become non-nullable.
    (call $called
      (ref.cast funcref
        (local.get $f)
      )
      (ref.cast funcref
        (local.get $f)
      )
      (local.get $f)
      (ref.cast funcref
        (local.get $f)
      )
    )

    ;; Another call, but with different casts.
    (call $called
      (ref.cast funcref ;; this is now non-nullable, and will not change
        (local.get $f)
      )
      (local.get $f) ;; this is not cast, and will not change.
      (ref.cast funcref
        (local.get $f) ;; this is now cast, and will be optimized.
      )
      (ref.cast funcref ;; this is the same as before, and will be optimized.
        (local.get $f)
      )
    )

    ;; Test that we do not error in unreachable code.
    (call $called
      (unreachable)
      (unreachable)
      (unreachable)
      (unreachable)
    )
  )
)

(module
  ;; CHECK:      (type $A (sub (struct (field (mut i32)))))
  (type $A (sub (struct (field (mut i32)))))

  ;; CHECK:      (type $B (sub $A (struct (field (mut i32)))))
  (type $B (sub $A (struct (field (mut i32)))))

  ;; CHECK:      (type $2 (func))

  ;; CHECK:      (type $3 (func (param (ref null $A))))

  ;; CHECK:      (type $4 (func (param anyref)))

  ;; CHECK:      (export "out" (func $caller))

  ;; CHECK:      (func $maker (type $2)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $A
  ;; CHECK-NEXT:    (i32.const 10)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $B
  ;; CHECK-NEXT:    (i32.const 20)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $maker
    ;; A always contains 10, and B always contains 20.
    (drop
      (struct.new $A
        (i32.const 10)
      )
    )
    (drop
      (struct.new $B
        (i32.const 20)
      )
    )
  )

  ;; CHECK:      (func $called (type $3) (param $x (ref null $A))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $called (param $x (ref null $A))
    ;; Cast the input to a $B, which will help the caller.
    (drop
      (ref.cast (ref $B)
        (local.get $x)
      )
    )
  )

  ;; CHECK:      (func $caller (type $4) (param $any anyref)
  ;; CHECK-NEXT:  (local $x (ref null $A))
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (local.tee $x
  ;; CHECK-NEXT:    (ref.cast (ref $B)
  ;; CHECK-NEXT:     (local.get $any)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.get $A 0
  ;; CHECK-NEXT:    (ref.cast (ref $A)
  ;; CHECK-NEXT:     (local.get $any)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.test (ref $B)
  ;; CHECK-NEXT:    (local.get $any)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i32.const 20)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i32.const 1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $caller (export "out") (param $any anyref)
    (local $x (ref null $A))
    ;; The called function casts to $B. This lets us infer the value of the
    ;; fallthrough ref.cast, which will turn into $B. Furthermore, that then
    ;; tells us what is written into the local $x, and the forward flow
    ;; analysis will use that fact in the local.get $x below.
    (call $called
      (local.tee $x
        (ref.cast (ref $A)
          (local.get $any)
        )
      )
    )
    ;; We can't infer anything here at the moment, but a more sophisticated
    ;; analysis could. (Other passes can help here, however, by using $x where
    ;; $any appears.)
    (drop
      (struct.get $A 0
        (ref.cast (ref $A)
          (local.get $any)
        )
      )
    )
    (drop
      (ref.test (ref $B)
        (local.get $any)
      )
    )
    ;; We know that $x must contain $B, so this can be inferred to be 20, and
    ;; the ref.is to 1.
    (drop
      (struct.get $A 0
        (local.get $x)
      )
    )
    (drop
      (ref.test (ref $B)
        (local.get $x)
      )
    )
  )
)

;; A local.tee by itself, without a cast.
(module
  ;; CHECK:      (type $A (sub (struct (field (mut i32)))))
  (type $A (sub (struct (field (mut i32)))))

  ;; CHECK:      (type $B (sub $A (struct (field (mut i32)))))
  (type $B (sub $A (struct (field (mut i32)))))

  ;; CHECK:      (type $2 (func (param (ref null $A))))

  ;; CHECK:      (type $3 (func))

  ;; CHECK:      (export "out" (func $caller))

  ;; CHECK:      (func $maker (type $3)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $A
  ;; CHECK-NEXT:    (i32.const 10)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $B
  ;; CHECK-NEXT:    (i32.const 20)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $maker
    ;; A always contains 10, and B always contains 20.
    (drop
      (struct.new $A
        (i32.const 10)
      )
    )
    (drop
      (struct.new $B
        (i32.const 20)
      )
    )
  )

  ;; CHECK:      (func $called (type $2) (param $x (ref null $A))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $called (param $x (ref null $A))
    ;; Cast the input to a $B, which will help the caller.
    (drop
      (ref.cast (ref $B)
        (local.get $x)
      )
    )
  )

  ;; CHECK:      (func $caller (type $2) (param $a (ref null $A))
  ;; CHECK-NEXT:  (local $x (ref null $A))
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (local.tee $x
  ;; CHECK-NEXT:    (local.get $a)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i32.const 20)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $caller (export "out") (param $a (ref null $A))
    (local $x (ref null $A))
    ;; The change compared to before is that we only have a local.tee here, and
    ;; no ref.cast. We can still infer the type of the tee's value, and
    ;; therefore the type of $x when it is read below, and optimize there.
    (call $called
      (local.tee $x
        (local.get $a)
      )
    )
    ;; This can be inferred to be 20.
    (drop
      (struct.get $A 0
        (local.get $x)
      )
    )
  )
)

;; As above, but add a local.tee etc. in the called function.
(module
  ;; CHECK:      (type $A (sub (struct (field (mut i32)))))
  (type $A (sub (struct (field (mut i32)))))

  ;; CHECK:      (type $B (sub $A (struct (field (mut i32)))))
  (type $B (sub $A (struct (field (mut i32)))))

  ;; CHECK:      (type $2 (func (param (ref null $A))))

  ;; CHECK:      (type $3 (func (param anyref)))

  ;; CHECK:      (global $global (mut i32) (i32.const 0))
  (global $global (mut i32) (i32.const 0))

  ;; CHECK:      (export "out" (func $caller))

  ;; CHECK:      (func $called (type $2) (param $x (ref null $A))
  ;; CHECK-NEXT:  (local $local (ref null $A))
  ;; CHECK-NEXT:  (nop)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i32.const 42)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (global.set $global
  ;; CHECK-NEXT:   (i32.const 1337)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.tee $local
  ;; CHECK-NEXT:     (local.get $x)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $called (param $x (ref null $A))
    (local $local (ref null $A))
    ;; Some nops and such do not bother us. Even a side effect like setting a
    ;; global does not.
    (nop)
    (drop
      (i32.const 42)
    )
    (global.set $global
      (i32.const 1337)
    )
    (drop
      (ref.cast (ref $B)
        ;; This local.tee should not stop us from optimizing.
        (local.tee $local
          (local.get $x)
        )
      )
    )
  )

  ;; CHECK:      (func $caller (type $3) (param $any anyref)
  ;; CHECK-NEXT:  (local $x (ref null $A))
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (local.tee $x
  ;; CHECK-NEXT:    (ref.cast (ref $B)
  ;; CHECK-NEXT:     (local.get $any)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $caller (export "out") (param $any anyref)
    (local $x (ref null $A))
    (call $called
      (local.tee $x
        (ref.cast (ref $A) ;; this cast will be refined
          (local.get $any)
        )
      )
    )
  )
)

;; As above, but now add some control flow before the cast in the function.
(module
  ;; CHECK:      (type $A (sub (struct (field (mut i32)))))
  (type $A (sub (struct (field (mut i32)))))

  ;; CHECK:      (type $1 (func (param (ref null $A))))

  ;; CHECK:      (type $B (sub $A (struct (field (mut i32)))))
  (type $B (sub $A (struct (field (mut i32)))))

  ;; CHECK:      (type $3 (func (param anyref)))

  ;; CHECK:      (export "out" (func $caller))

  ;; CHECK:      (func $called (type $1) (param $x (ref null $A))
  ;; CHECK-NEXT:  (local $local (ref null $A))
  ;; CHECK-NEXT:  (if
  ;; CHECK-NEXT:   (i32.const 0)
  ;; CHECK-NEXT:   (then
  ;; CHECK-NEXT:    (return)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $called (param $x (ref null $A))
    (local $local (ref null $A))
    ;; Control flow before the cast *does* stop us from optimizing.
    (if
      (i32.const 0)
      (then
        (return)
      )
    )
    (drop
      (ref.cast (ref $B)
        (local.get $x)
      )
    )
  )

  ;; CHECK:      (func $caller (type $3) (param $any anyref)
  ;; CHECK-NEXT:  (local $x (ref null $A))
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (local.tee $x
  ;; CHECK-NEXT:    (ref.cast (ref $A)
  ;; CHECK-NEXT:     (local.get $any)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $caller (export "out") (param $any anyref)
    (local $x (ref null $A))
    (call $called
      (local.tee $x
        (ref.cast (ref $A) ;; this cast will *not* be refined
          (local.get $any)
        )
      )
    )
  )
)

;; As above, but make the cast uninteresting so we do not optimize.
(module
  ;; CHECK:      (type $A (sub (struct (field (mut i32)))))
  (type $A (sub (struct (field (mut i32)))))

  (type $B (sub $A (struct (field (mut i32)))))

  ;; CHECK:      (type $1 (func (param (ref null $A))))

  ;; CHECK:      (type $2 (func (param anyref)))

  ;; CHECK:      (export "out" (func $caller))

  ;; CHECK:      (func $called (type $1) (param $x (ref null $A))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast (ref $A)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $called (param $x (ref null $A))
    (drop
      (ref.cast (ref $A) ;; This cast only removes nullability.
        (local.get $x)
      )
    )
  )

  ;; CHECK:      (func $caller (type $2) (param $any anyref)
  ;; CHECK-NEXT:  (local $x (ref null $A))
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (local.tee $x
  ;; CHECK-NEXT:    (ref.cast (ref $A)
  ;; CHECK-NEXT:     (local.get $any)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $caller (export "out") (param $any anyref)
    (local $x (ref null $A))
    (call $called
      (local.tee $x
        (ref.cast (ref $A)
                     ;; This cast will *not* be refined, as it is already non-
                     ;; nullable here, and the other cast did not improve the
                     ;; heap type.
          (local.get $any)
        )
      )
    )
  )
)

;; As above, but two casts in the called function.
(module
  ;; CHECK:      (type $A (sub (struct (field (mut i32)))))
  (type $A (sub (struct (field (mut i32)))))

  ;; CHECK:      (type $B (sub $A (struct (field (mut i32)))))
  (type $B (sub $A (struct (field (mut i32)))))

  ;; CHECK:      (type $2 (func (param (ref null $A))))

  ;; CHECK:      (type $C (sub $B (struct (field (mut i32)))))
  (type $C (sub $B (struct (field (mut i32)))))

  ;; CHECK:      (type $4 (func (param anyref)))

  ;; CHECK:      (export "out" (func $caller))

  ;; CHECK:      (func $called (type $2) (param $x (ref null $A))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast (ref $C)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $called (param $x (ref null $A))
    ;; Two casts. We keep the first, which is simple to do, and good enough in
    ;; the general case as other optimizations will leave the most-refined one.
    ;; (But in this test, it is less optimal actually.)
    (drop
      (ref.cast (ref $B)
        (local.get $x)
      )
    )
    (drop
      (ref.cast (ref $C)
        (local.get $x)
      )
    )
  )

  ;; CHECK:      (func $caller (type $4) (param $any anyref)
  ;; CHECK-NEXT:  (local $x (ref null $A))
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (local.tee $x
  ;; CHECK-NEXT:    (ref.cast (ref $B)
  ;; CHECK-NEXT:     (local.get $any)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $caller (export "out") (param $any anyref)
    (local $x (ref null $A))
    (call $called
      (local.tee $x
        (ref.cast (ref $A) ;; this cast will be refined to $B.
          (local.get $any)
        )
      )
    )
  )
)

;; Multiple parameters with control flow between them.
(module
  ;; CHECK:      (type $A (sub (struct (field (mut i32)))))
  (type $A (sub (struct (field (mut i32)))))

  ;; CHECK:      (type $B (sub $A (struct (field (mut i32)))))
  (type $B (sub $A (struct (field (mut i32)))))

  ;; CHECK:      (type $2 (func (param (ref null $A) (ref null $A) (ref null $A))))

  ;; CHECK:      (type $3 (func (param anyref)))

  ;; CHECK:      (export "out" (func $caller))

  ;; CHECK:      (func $called (type $2) (param $x (ref null $A)) (param $y (ref null $A)) (param $z (ref null $A))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $y)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $z)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $called (param $x (ref null $A)) (param $y (ref null $A)) (param $z (ref null $A))
    ;; All parameters are cast.
    (drop
      (ref.cast (ref $B)
        (local.get $x)
      )
    )
    (drop
      (ref.cast (ref $B)
        (local.get $y)
      )
    )
    (drop
      (ref.cast (ref $B)
        (local.get $z)
      )
    )
  )

  ;; CHECK:      (func $caller (type $3) (param $any anyref)
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (block (result (ref $A))
  ;; CHECK-NEXT:    (ref.cast (ref $A)
  ;; CHECK-NEXT:     (local.get $any)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (block (result (ref $B))
  ;; CHECK-NEXT:    (if
  ;; CHECK-NEXT:     (i32.const 0)
  ;; CHECK-NEXT:     (then
  ;; CHECK-NEXT:      (return)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (ref.cast (ref $B)
  ;; CHECK-NEXT:     (local.get $any)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (block (result (ref $B))
  ;; CHECK-NEXT:    (ref.cast (ref $B)
  ;; CHECK-NEXT:     (local.get $any)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $caller (export "out") (param $any anyref)
    ;; All three params get similar blocks+casts, but the middle one might
    ;; transfer control flow, so we cannot optimize the first parameter (we
    ;; might not reach the call, so we can't assume the call's cast suceeds).
    ;; As a result, only the last two casts are refined to $B, but not the
    ;; first.
    (call $called
      (block (result (ref $A))
        (ref.cast (ref $A)
          (local.get $any)
        )
      )
      (block (result (ref $A))
        (if
          (i32.const 0)
          (then
            (return)
          )
        )
        (ref.cast (ref $A)
          (local.get $any)
        )
      )
      (block (result (ref $A))
        (ref.cast (ref $A)
          (local.get $any)
        )
      )
    )
  )
)

;; As above, but without the cast in the middle of the called function.
(module
  ;; CHECK:      (type $A (sub (struct (field (mut i32)))))
  (type $A (sub (struct (field (mut i32)))))

  ;; CHECK:      (type $B (sub $A (struct (field (mut i32)))))
  (type $B (sub $A (struct (field (mut i32)))))

  ;; CHECK:      (type $2 (func (param (ref null $A) (ref null $A) (ref null $A))))

  ;; CHECK:      (type $3 (func (param anyref)))

  ;; CHECK:      (export "out" (func $caller))

  ;; CHECK:      (func $called (type $2) (param $x (ref null $A)) (param $y (ref null $A)) (param $z (ref null $A))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (local.get $y)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $z)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $called (param $x (ref null $A)) (param $y (ref null $A)) (param $z (ref null $A))
    (drop
      (ref.cast (ref $B)
        (local.get $x)
      )
    )
    (drop
      ;; This changed to not have a cast.
      (local.get $y)
    )
    (drop
      (ref.cast (ref $B)
        (local.get $z)
      )
    )
  )

  ;; CHECK:      (func $caller (type $3) (param $any anyref)
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (block (result (ref $A))
  ;; CHECK-NEXT:    (ref.cast (ref $A)
  ;; CHECK-NEXT:     (local.get $any)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (block (result (ref $A))
  ;; CHECK-NEXT:    (if
  ;; CHECK-NEXT:     (i32.const 0)
  ;; CHECK-NEXT:     (then
  ;; CHECK-NEXT:      (return)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (ref.cast (ref $A)
  ;; CHECK-NEXT:     (local.get $any)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (block (result (ref $B))
  ;; CHECK-NEXT:    (ref.cast (ref $B)
  ;; CHECK-NEXT:     (local.get $any)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $caller (export "out") (param $any anyref)
    ;; We can't refine the first cast because of control flow, like before, and
    ;; we can't refine the middle because the called function has no cast, but
    ;; we can still refine the last one.
    (call $called
      (block (result (ref $A))
        (ref.cast (ref $A)
          (local.get $any)
        )
      )
      (block (result (ref $A))
        (if
          (i32.const 0)
          (then
            (return)
          )
        )
        (ref.cast (ref $A)
          (local.get $any)
        )
      )
      (block (result (ref $A))
        (ref.cast (ref $A)
          (local.get $any)
        )
      )
    )
  )
)

;; As above, but with a different control flow transfer in the caller, a call.
(module
  ;; CHECK:      (type $A (sub (struct (field (mut i32)))))
  (type $A (sub (struct (field (mut i32)))))

  ;; CHECK:      (type $B (sub $A (struct (field (mut i32)))))
  (type $B (sub $A (struct (field (mut i32)))))

  ;; CHECK:      (type $2 (func (result anyref)))

  ;; CHECK:      (type $3 (func (param (ref null $A) (ref null $A) (ref null $A))))

  ;; CHECK:      (type $4 (func (param anyref)))

  ;; CHECK:      (import "a" "b" (func $get-any (type $2) (result anyref)))
  (import "a" "b" (func $get-any (result anyref)))

  ;; CHECK:      (export "out" (func $caller))

  ;; CHECK:      (func $called (type $3) (param $x (ref null $A)) (param $y (ref null $A)) (param $z (ref null $A))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $y)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $z)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $called (param $x (ref null $A)) (param $y (ref null $A)) (param $z (ref null $A))
    ;; All parameters are cast.
    (drop
      (ref.cast (ref $B)
        (local.get $x)
      )
    )
    (drop
      (ref.cast (ref $B)
        (local.get $y)
      )
    )
    (drop
      (ref.cast (ref $B)
        (local.get $z)
      )
    )
  )

  ;; CHECK:      (func $caller (type $4) (param $any anyref)
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (ref.cast (ref $A)
  ;; CHECK-NEXT:    (local.get $any)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (call $get-any)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $any)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $caller (export "out") (param $any anyref)
    (call $called
      (ref.cast (ref $A)
        (local.get $any)
      )
      (ref.cast (ref $A)
        ;; This call might transfer control flow (if it throws), so we
        ;; can't optimize before it, but the last two casts will become $B.
        (call $get-any)
      )
      (ref.cast (ref $A)
        (local.get $any)
      )
    )
  )
)

;; As above, but with yet another control flow transfer, using an if.
(module
  ;; CHECK:      (type $A (sub (struct (field (mut i32)))))
  (type $A (sub (struct (field (mut i32)))))

  ;; CHECK:      (type $B (sub $A (struct (field (mut i32)))))
  (type $B (sub $A (struct (field (mut i32)))))

  ;; CHECK:      (type $2 (func (result anyref)))

  ;; CHECK:      (type $3 (func (param (ref null $A) (ref null $A) (ref null $A))))

  ;; CHECK:      (type $4 (func (param anyref)))

  ;; CHECK:      (import "a" "b" (func $get-any (type $2) (result anyref)))
  (import "a" "b" (func $get-any (result anyref)))

  ;; CHECK:      (export "out" (func $caller))

  ;; CHECK:      (func $called (type $3) (param $x (ref null $A)) (param $y (ref null $A)) (param $z (ref null $A))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $y)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $z)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $called (param $x (ref null $A)) (param $y (ref null $A)) (param $z (ref null $A))
    ;; All parameters are cast.
    (drop
      (ref.cast (ref $B)
        (local.get $x)
      )
    )
    (drop
      (ref.cast (ref $B)
        (local.get $y)
      )
    )
    (drop
      (ref.cast (ref $B)
        (local.get $z)
      )
    )
  )

  ;; CHECK:      (func $caller (type $4) (param $any anyref)
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (ref.cast (ref $A)
  ;; CHECK-NEXT:    (local.get $any)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (if (result (ref $A))
  ;; CHECK-NEXT:    (i32.const 0)
  ;; CHECK-NEXT:    (then
  ;; CHECK-NEXT:     (return)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (else
  ;; CHECK-NEXT:     (ref.cast (ref $A)
  ;; CHECK-NEXT:      (local.get $any)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $any)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $caller (export "out") (param $any anyref)
    (call $called
      (ref.cast (ref $A)
        (local.get $any)
      )
      ;; One if arm transfers control flow, so while we have a fallthrough
      ;; value we cannot optimize it (in fact, it might never be reached, at
      ;; least if the constant were not 0). As a result we'll optimize only the
      ;; very last cast.
      (if (result (ref $A))
        (i32.const 0)
        (then
          (return)
        )
        (else
          (ref.cast (ref $A)
            (local.get $any)
          )
        )
      )
      (ref.cast (ref $A)
        (local.get $any)
      )
    )
  )
)

;; A cast that will fail.
(module
  ;; CHECK:      (type $A (sub (struct (field (mut i32)))))
  (type $A (sub (struct (field (mut i32)))))

  ;; CHECK:      (type $B (sub $A (struct (field (mut i32)))))
  (type $B (sub $A (struct (field (mut i32)))))

  ;; CHECK:      (type $2 (func (param (ref null $A))))

  ;; CHECK:      (type $3 (func))

  ;; CHECK:      (export "out" (func $caller))

  ;; CHECK:      (func $called (type $2) (param $x (ref null $A))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast (ref (exact $B))
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $called (param $x (ref null $A))
    (drop
      (ref.cast (ref $B)
        (local.get $x)
      )
    )
  )

  ;; CHECK:      (func $caller (type $3)
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (struct.new $B
  ;; CHECK-NEXT:    (i32.const 20)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $caller (export "out")
    (call $called
      ;; The called function will cast to $B, but this is an $A, so the cast
      ;; will fail. We can infer that the code here is unreachable. Note that no
      ;; ref.cast appears here - we infer this even without seeing a cast.
      (struct.new $A
        (i32.const 10)
      )
    )
    ;; Another call that will not be modified.
    (call $called
      (struct.new $B
        (i32.const 20)
      )
    )
  )
)

;; Test that we refine using ref.as_non_null and not just ref.cast.
(module
  ;; CHECK:      (type $A (struct (field (mut i32))))
  (type $A (struct (field (mut i32))))

  ;; CHECK:      (type $1 (func (param (ref null $A))))

  ;; CHECK:      (type $2 (func (param anyref)))

  ;; CHECK:      (export "out" (func $caller))

  ;; CHECK:      (func $called (type $1) (param $x (ref null $A))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.as_non_null
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $called (param $x (ref null $A))
    (drop
      (ref.as_non_null
        (local.get $x)
      )
    )
  )

  ;; CHECK:      (func $caller (type $2) (param $any anyref)
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (ref.cast (ref $A)
  ;; CHECK-NEXT:    (local.get $any)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $caller (export "out") (param $any anyref)
    (call $called
      ;; This cast can become non-nullable.
      (ref.cast (ref null $A)
        (local.get $any)
      )
    )
  )
)

;; Verify we do not propagate *less*-refined information.
(module
  ;; CHECK:      (type $A (sub (struct (field (mut i32)))))
  (type $A (sub (struct (field (mut i32)))))

  ;; CHECK:      (type $B (sub $A (struct (field (mut i32)))))
  (type $B (sub $A (struct (field (mut i32)))))

  ;; CHECK:      (type $C (sub $B (struct (field (mut i32)))))
  (type $C (sub $B (struct (field (mut i32)))))

  ;; CHECK:      (type $3 (func (param anyref)))

  ;; CHECK:      (type $4 (func (param (ref null $A))))

  ;; CHECK:      (type $5 (func))

  ;; CHECK:      (export "caller-C" (func $caller-C))

  ;; CHECK:      (export "caller-B" (func $caller-B))

  ;; CHECK:      (export "caller-A" (func $caller-A))

  ;; CHECK:      (func $called (type $4) (param $x (ref null $A))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $called (param $x (ref null $A))
    ;; This function casts the A to a B.
    (drop
      (ref.cast (ref $B)
        (local.get $x)
      )
    )
  )

  ;; CHECK:      (func $maker (type $5)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $A
  ;; CHECK-NEXT:    (i32.const 10)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $B
  ;; CHECK-NEXT:    (i32.const 20)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $C
  ;; CHECK-NEXT:    (i32.const 30)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $maker
    ;; A always contains 10, and B 20, and C 30.
    (drop
      (struct.new $A
        (i32.const 10)
      )
    )
    (drop
      (struct.new $B
        (i32.const 20)
      )
    )
    (drop
      (struct.new $C
        (i32.const 30)
      )
    )
  )

  ;; CHECK:      (func $caller-C (type $3) (param $any anyref)
  ;; CHECK-NEXT:  (local $temp-C (ref $C))
  ;; CHECK-NEXT:  (local $temp-any anyref)
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (local.tee $temp-C
  ;; CHECK-NEXT:    (ref.cast (ref $C)
  ;; CHECK-NEXT:     (local.tee $temp-any
  ;; CHECK-NEXT:      (local.get $any)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i32.const 30)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.get $B 0
  ;; CHECK-NEXT:    (ref.cast (ref $B)
  ;; CHECK-NEXT:     (local.get $temp-any)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.get $A 0
  ;; CHECK-NEXT:    (ref.cast (ref $A)
  ;; CHECK-NEXT:     (local.get $any)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $caller-C (export "caller-C") (param $any anyref)
    (local $temp-C (ref $C))
    (local $temp-any anyref)
    (call $called
      (local.tee $temp-C
        (ref.cast (ref $C)
                     ;; This cast is already more refined than even the called
                     ;; function casts to. It should stay as it is.
          (local.tee $temp-any
            (local.get $any)
          )
        )
      )
    )
    (drop
      (struct.get $A 0 ;; the reference contains a C, so this value is 30.
        (ref.cast (ref $A)
          (local.get $temp-C)
        )
      )
    )
    (drop
      (struct.get $A 0 ;; We infer that $temp-any is $B from the cast in the
                       ;; call, so the cast here can be improved, but not the
                       ;; value (which can be 20 or 30).
                       ;; TODO: We can infer from the ref.cast $C in this
                       ;;       function backwards into the tee and its value.
        (ref.cast (ref $A)
          (local.get $temp-any)
        )
      )
    )
    (drop
      (struct.get $A 0 ;; We have not inferred anything about the param, so this
                       ;; is not optimized yet, but it could be. TODO
        (ref.cast (ref $A)
          (local.get $any)
        )
      )
    )
  )

  ;; CHECK:      (func $caller-B (type $3) (param $any anyref)
  ;; CHECK-NEXT:  (local $temp (ref $A))
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (local.tee $temp
  ;; CHECK-NEXT:    (ref.cast (ref $B)
  ;; CHECK-NEXT:     (local.get $any)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.get $A 0
  ;; CHECK-NEXT:    (local.get $temp)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $caller-B (export "caller-B") (param $any anyref)
    (local $temp (ref $A))
    (call $called
      (local.tee $temp
        (ref.cast (ref $B) ;; This cast is equal to the called cast. It should remain.
          (local.get $any)
        )
      )
    )
    (drop
      (struct.get $A 0 ;; Nothing can be inferred here.
        (local.get $temp)
      )
    )
  )

  ;; CHECK:      (func $caller-A (type $3) (param $any anyref)
  ;; CHECK-NEXT:  (local $temp (ref $A))
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (local.tee $temp
  ;; CHECK-NEXT:    (ref.cast (ref $B)
  ;; CHECK-NEXT:     (local.get $any)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.get $A 0
  ;; CHECK-NEXT:    (local.get $temp)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $caller-A (export "caller-A") (param $any anyref)
    (local $temp (ref $A))
    (call $called
      (local.tee $temp
        (ref.cast (ref $A) ;; This cast is less refined, and can be improved to B.
          (local.get $any)
        )
      )
    )
    (drop
      (struct.get $A 0 ;; Nothing can be inferred here.
        (local.get $temp)
      )
    )
  )
)

;; Refine a type to unreachable. B1 and B2 are sibling subtypes of A, and the
;; caller passes in a B1 that is cast in the function to B2.
(module
  ;; CHECK:      (type $A (sub (struct (field (mut i32)))))
  (type $A (sub (struct (field (mut i32)))))

  (rec
    ;; CHECK:      (rec
    ;; CHECK-NEXT:  (type $B1 (sub $A (struct (field (mut i32)))))
    (type $B1 (sub $A (struct (field (mut i32)))))

    ;; CHECK:       (type $B2 (sub $A (struct (field (mut i32)))))
    (type $B2 (sub $A (struct (field (mut i32)))))

    ;; CHECK:       (type $C1 (sub $B1 (struct (field (mut i32)))))
    (type $C1 (sub $B1 (struct (field (mut i32)))))
  )

  ;; CHECK:      (type $4 (func (param (ref null $A))))

  ;; CHECK:      (type $5 (func (param anyref)))

  ;; CHECK:      (export "caller" (func $caller))

  ;; CHECK:      (func $called (type $4) (param $x (ref null $A))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast (ref $B1)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $called (param $x (ref null $A))
    (drop
      (ref.cast (ref $B1)
        (local.get $x)
      )
    )
  )

  ;; CHECK:      (func $caller (type $5) (param $any anyref)
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (struct.new $B1
  ;; CHECK-NEXT:    (i32.const 20)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (struct.new $C1
  ;; CHECK-NEXT:    (i32.const 30)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $caller (export "caller") (param $any anyref)
    ;; The cast of this A to B1 will fail, so it is unreachable.
    (call $called
      (struct.new $A
        (i32.const 10)
      )
    )
    ;; This cast of B1 to itself will succeed, so nothing changes.
    (call $called
      (struct.new $B1
        (i32.const 20)
      )
    )
    ;; The cast of this C1 to its supertype B1 will succeed.
    (call $called
      (struct.new $C1
        (i32.const 30)
      )
    )
    ;; Casting B2 to B1 will fail as they are sibling types.
    (call $called
      (struct.new $B2
        (i32.const 40)
      )
    )
  )
)

;; Check we ignore casts of non-param locals.
(module
  ;; CHECK:      (type $0 (func))

  ;; CHECK:      (type $A (sub (struct (field (mut i32)))))
  (type $A (sub (struct (field (mut i32)))))

  (type $B (sub $A (struct (field (mut i32)))))

  ;; CHECK:      (export "out" (func $caller))

  ;; CHECK:      (func $called (type $0)
  ;; CHECK-NEXT:  (local $x (ref null $A))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.null none)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $called
    (local $x (ref null $A))
    ;; This casts a local in the entry block, but it is not a parameter, so we
    ;; should ignore it and not error.
    (drop
      (ref.cast (ref null $B)
        (local.get $x)
      )
    )
  )

  ;; CHECK:      (func $caller (type $0)
  ;; CHECK-NEXT:  (call $called)
  ;; CHECK-NEXT: )
  (func $caller (export "out")
    (call $called)
  )
)

;; Check all combinations of types passed to a nullable cast.
(module
  ;; CHECK:      (type $A (sub (struct (field (mut i32)))))
  (type $A (sub (struct (field (mut i32)))))

  ;; CHECK:      (type $B (sub $A (struct (field (mut i32)))))
  (type $B (sub $A (struct (field (mut i32)))))

  ;; CHECK:      (type $C (sub $B (struct (field (mut i32)))))
  (type $C (sub $B (struct (field (mut i32)))))

  ;; CHECK:      (type $3 (func (param (ref null $A))))

  ;; CHECK:      (type $4 (func (param anyref)))

  ;; CHECK:      (export "out" (func $caller))

  ;; CHECK:      (func $called (type $3) (param $x (ref null $A))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast (ref null $B)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $called (param $x (ref null $A))
    (drop
      (ref.cast (ref null $B)
        (local.get $x)
      )
    )
  )

  ;; CHECK:      (func $caller (type $4) (param $x anyref)
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (ref.cast (ref null $B)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (ref.cast (ref null $B)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (ref.cast (ref $C)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (ref.cast (ref null $C)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $caller (export "out") (param $x anyref)
    ;; A non-nullable A passed into a cast of B means this value must be a non-
    ;; nullable B.
    (call $called
      (ref.cast (ref $A)
        (local.get $x)
      )
    )
    ;; This will be refined to (nullable) B.
    (call $called
      (ref.cast (ref null $A)
        (local.get $x)
      )
    )
    ;; Casts of B remain the same.
    (call $called
      (ref.cast (ref $B)
        (local.get $x)
      )
    )
    (call $called
      (ref.cast (ref null $B)
        (local.get $x)
      )
    )
    ;; Casts of C remain the same.
    (call $called
      (ref.cast (ref $C)
        (local.get $x)
      )
    )
    (call $called
      (ref.cast (ref null $C)
        (local.get $x)
      )
    )
  )
)

;; Check all combinations of types passed to a *non*-nullable cast.
(module
  ;; CHECK:      (type $A (sub (struct (field (mut i32)))))
  (type $A (sub (struct (field (mut i32)))))

  ;; CHECK:      (type $B (sub $A (struct (field (mut i32)))))
  (type $B (sub $A (struct (field (mut i32)))))

  ;; CHECK:      (type $C (sub $B (struct (field (mut i32)))))
  (type $C (sub $B (struct (field (mut i32)))))

  ;; CHECK:      (type $3 (func (param (ref null $A))))

  ;; CHECK:      (type $4 (func (param anyref)))

  ;; CHECK:      (export "out" (func $caller))

  ;; CHECK:      (func $called (type $3) (param $x (ref null $A))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $called (param $x (ref null $A))
    (drop
      (ref.cast (ref $B)
        (local.get $x)
      )
    )
  )

  ;; CHECK:      (func $caller (type $4) (param $x anyref)
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (ref.cast (ref $C)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (ref.cast (ref $C)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $caller (export "out") (param $x anyref)
    ;; Casts of A are refined.
    (call $called
      (ref.cast (ref $A)
        (local.get $x)
      )
    )
    ;; This will be refined to B.
    (call $called
      (ref.cast (ref null $A)
        (local.get $x)
      )
    )
    ;; Casts of B turn or stay as non-nullable B.
    (call $called
      (ref.cast (ref $B)
        (local.get $x)
      )
    )
    (call $called
      (ref.cast (ref null $B)
        (local.get $x)
      )
    )
    ;; This cast of C remains the same.
    (call $called
      (ref.cast (ref $C)
        (local.get $x)
      )
    )
    ;; A nullable C passed into a cast of non-null B means this value must be a
    ;; non-nullable C.
    (call $called
      (ref.cast (ref null $C)
        (local.get $x)
      )
    )
  )
)

;; A cast of an array.
(module
  ;; CHECK:      (type $0 (func (param anyref)))

  ;; CHECK:      (type $A (array (mut i32)))
  (type $A (array (mut i32)))

  ;; CHECK:      (export "out" (func $caller))

  ;; CHECK:      (func $called (type $0) (param $x anyref)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast (ref $A)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $called (param $x anyref)
    (drop
      (ref.cast (ref $A)
        (local.get $x)
      )
    )
  )

  ;; CHECK:      (func $caller (type $0) (param $x anyref)
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (ref.cast (ref $A)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $caller (export "out") (param $x anyref)
    (call $called
      ;; This will be refined to a non-nullable cast.
      (ref.cast (ref null $A)
        (local.get $x)
      )
    )
  )
)

;; Test array and struct operations.
(module
  ;; CHECK:      (type $B (array (mut i32)))

  ;; CHECK:      (type $A (struct (field (mut i32))))
  (type $A (struct (field (mut i32))))

  (type $B (array (mut i32)))

  ;; CHECK:      (type $C (array (mut funcref)))
  (type $C (array (mut funcref)))


  ;; CHECK:      (type $3 (func (param (ref null $A) (ref null $A) (ref null $B) (ref null $B) (ref null $B) (ref null $B) (ref null $B) (ref null $B) (ref null $B) (ref null $C) (ref null $A))))

  ;; CHECK:      (type $4 (func (param anyref)))

  ;; CHECK:      (data $d "a")
  (data $d "a")

  ;; CHECK:      (elem $e func)
  (elem $e funcref)

  ;; CHECK:      (export "out" (func $caller))

  ;; CHECK:      (func $called (type $3) (param $struct.get (ref null $A)) (param $struct.set (ref null $A)) (param $array.get (ref null $B)) (param $array.set (ref null $B)) (param $array.len (ref null $B)) (param $array.copy.src (ref null $B)) (param $array.copy.dest (ref null $B)) (param $array.fill (ref null $B)) (param $array.init_data (ref null $B)) (param $array.init_elem (ref null $C)) (param $ref.test (ref null $A))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i32.const 0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (struct.set $A 0
  ;; CHECK-NEXT:   (local.get $struct.set)
  ;; CHECK-NEXT:   (i32.const 0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (array.get $B
  ;; CHECK-NEXT:    (local.get $array.get)
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (array.set $B
  ;; CHECK-NEXT:   (local.get $array.set)
  ;; CHECK-NEXT:   (i32.const 2)
  ;; CHECK-NEXT:   (i32.const 3)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (array.len
  ;; CHECK-NEXT:    (local.get $array.len)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (array.copy $B $B
  ;; CHECK-NEXT:   (local.get $array.copy.src)
  ;; CHECK-NEXT:   (i32.const 4)
  ;; CHECK-NEXT:   (local.get $array.copy.dest)
  ;; CHECK-NEXT:   (i32.const 5)
  ;; CHECK-NEXT:   (i32.const 6)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (array.fill $B
  ;; CHECK-NEXT:   (local.get $array.fill)
  ;; CHECK-NEXT:   (i32.const 7)
  ;; CHECK-NEXT:   (i32.const 8)
  ;; CHECK-NEXT:   (i32.const 9)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (array.init_data $B $d
  ;; CHECK-NEXT:   (local.get $array.init_data)
  ;; CHECK-NEXT:   (i32.const 10)
  ;; CHECK-NEXT:   (i32.const 11)
  ;; CHECK-NEXT:   (i32.const 12)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (array.init_elem $C $e
  ;; CHECK-NEXT:   (local.get $array.init_elem)
  ;; CHECK-NEXT:   (i32.const 13)
  ;; CHECK-NEXT:   (i32.const 14)
  ;; CHECK-NEXT:   (i32.const 15)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.test (ref $A)
  ;; CHECK-NEXT:    (local.get $ref.test)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $called
    (param $struct.get (ref null $A))
    (param $struct.set (ref null $A))
    (param $array.get (ref null $B))
    (param $array.set (ref null $B))
    (param $array.len (ref null $B))
    (param $array.copy.src (ref null $B))
    (param $array.copy.dest (ref null $B))
    (param $array.fill (ref null $B))
    (param $array.init_data (ref null $B))
    (param $array.init_elem (ref null $C))
    (param $ref.test (ref null $A))

    ;; All the operations trap on null, aside from ref.test.
    (drop
      (struct.get $A 0
        (local.get $struct.get)
      )
    )
    (struct.set $A 0
      (local.get $struct.set)
      (i32.const 0)
    )
    (drop
      (array.get $B
        (local.get $array.get)
        (i32.const 1)
      )
    )
    (array.set $B
      (local.get $array.set)
      (i32.const 2)
      (i32.const 3)
    )
    (drop
      (array.len
        (local.get $array.len)
      )
    )
    (array.copy $B $B
      (local.get $array.copy.src)
      (i32.const 4)
      (local.get $array.copy.dest)
      (i32.const 5)
      (i32.const 6)
    )
    (array.fill $B
      (local.get $array.fill)
      (i32.const 7)
      (i32.const 8)
      (i32.const 9)
    )
    (array.init_data $B $d
      (local.get $array.init_data)
      (i32.const 10)
      (i32.const 11)
      (i32.const 12)
    )
    (array.init_elem $C $e
      (local.get $array.init_elem)
      (i32.const 13)
      (i32.const 14)
      (i32.const 15)
    )
    (drop
      (ref.test (ref $A)
        (local.get $ref.test)
      )
    )
  )

  ;; CHECK:      (func $caller (type $4) (param $any anyref)
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (ref.cast (ref $A)
  ;; CHECK-NEXT:    (local.get $any)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (ref.cast (ref $A)
  ;; CHECK-NEXT:    (local.get $any)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $any)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $any)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $any)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $any)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $any)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $any)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $any)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (ref.cast (ref $C)
  ;; CHECK-NEXT:    (local.get $any)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (ref.cast (ref null $A)
  ;; CHECK-NEXT:    (local.get $any)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $caller (export "out") (param $any anyref)
    ;; All these casts will be refined to non-nullable, aside from the last
    ;; param which is but a ref.test.
    (call $called
      (ref.cast (ref null $A)
        (local.get $any)
      )
      (ref.cast (ref null $A)
        (local.get $any)
      )
      (ref.cast (ref null $B)
        (local.get $any)
      )
      (ref.cast (ref null $B)
        (local.get $any)
      )
      (ref.cast (ref null $B)
        (local.get $any)
      )
      (ref.cast (ref null $B)
        (local.get $any)
      )
      (ref.cast (ref null $B)
        (local.get $any)
      )
      (ref.cast (ref null $B)
        (local.get $any)
      )
      (ref.cast (ref null $B)
        (local.get $any)
      )
      (ref.cast (ref null $C)
        (local.get $any)
      )
      (ref.cast (ref null $A)
        (local.get $any)
      )
    )
  )
)

;; A CallRef with no non-trapping targets must be unreachable if traps never
;; happen. However, this requires closed world, so we do nothing here. (This
;; test is mirrored in gufa-tnh-closed, where closed world *is* enabled.)
(module
  ;; CHECK:      (type $A (func))
  (type $A (func))

  ;; CHECK:      (type $1 (func (param funcref)))

  ;; CHECK:      (export "out" (func $caller))

  ;; CHECK:      (func $impossible (type $A)
  ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  (func $impossible (type $A)
    ;; This cannot be called if traps never happen.
    (unreachable)
  )

  ;; CHECK:      (func $caller (type $1) (param $x funcref)
  ;; CHECK-NEXT:  (call_ref $A
  ;; CHECK-NEXT:   (ref.cast (ref $A)
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $caller (export "out") (param $x funcref)
    ;; In closed world this call must trap, as the only function of the right
    ;; type will trap. But we are in open world so we do not optimize here.
    ;; TODO: We could analyze publicly visible tables, exports, etc. to see
    ;;       whether any more functions could be possible even in an open world.
    (call_ref $A
      (ref.cast (ref $A)
        (local.get $x)
      )
    )
  )
)

;; Control flow around calls.
(module
  ;; CHECK:      (type $A (sub (struct)))
  (type $A (sub (struct)))

  ;; CHECK:      (type $1 (func))

  ;; CHECK:      (type $B (sub $A (struct)))
  (type $B (sub $A (struct)))

  ;; CHECK:      (type $3 (func (param (ref null $A))))

  ;; CHECK:      (import "a" "b" (func $import-throw (type $1)))
  (import "a" "b" (func $import-throw))

  ;; CHECK:      (export "a" (func $caller))

  ;; CHECK:      (func $called (type $3) (param $0 (ref null $A))
  ;; CHECK-NEXT:  (call $import-throw)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.cast (ref $B)
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $called (param $0 (ref null $A))
    ;; This function calls an import, and later casts. We cannot use those casts
    ;; to infer anything in the callers, since the import might throw (in which
    ;; case we'd never reach the cast).
    (call $import-throw)
    (drop
      (ref.cast (ref $B)
        (local.get $0)
      )
    )
  )

  ;; CHECK:      (func $caller (type $1)
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (struct.new_default $B)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call $called
  ;; CHECK-NEXT:   (struct.new_default $A)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $caller (export "a")
    ;; This call sends a $B which will be cast to $B (assuming the import does
    ;; not trap), so nothing should happen here.
    (call $called
      (struct.new $B)
    )
    ;; This call sends an $A, which would fail the cast if it were reached. But
    ;; it might not, so we do nothing here.
    (call $called
      (struct.new $A)
    )
  )
)

(module
 ;; CHECK:      (type $0 (func (param i32) (result (ref null (shared any)))))

 ;; CHECK:      (table $0 3 3 (ref null (shared any)))
 (table $0 3 3 (ref null (shared any)))
 ;; CHECK:      (elem $0 (table $0) (i32.const 0) (ref null (shared i31)) (item (ref.i31_shared
 ;; CHECK-NEXT:  (i32.const 999)
 ;; CHECK-NEXT: )))
 (elem $0 (table $0) (i32.const 0) (ref null (shared i31)) (item (ref.i31_shared (i32.const 999))))
 ;; CHECK:      (export "get" (func $0))

 ;; CHECK:      (func $0 (type $0) (param $0 i32) (result (ref null (shared any)))
 ;; CHECK-NEXT:  (ref.cast (ref null (shared i31))
 ;; CHECK-NEXT:   (table.get $0
 ;; CHECK-NEXT:    (i32.const 0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $0 (export "get") (param $0 i32) (result (ref null (shared any)))
  ;; Regression test for a bug where subtypes.h did not handle shared types
  ;; correctly, causing this example to be misoptimized to return null.
  (ref.cast (ref null (shared i31))
   (table.get $0
    (i32.const 0)
   )
  )
 )
)

;; Test writes to locals that interfere with inferences about casts.
(module
 (rec
  ;; CHECK:      (rec
  ;; CHECK-NEXT:  (type $top (sub (struct)))
  (type $top (sub (struct)))
  ;; CHECK:       (type $bot (sub $top (struct)))
  (type $bot (sub $top (struct)))
 )

 ;; CHECK:      (type $2 (func (param (ref $top))))

 ;; CHECK:      (type $3 (func (param (ref extern))))

 ;; CHECK:      (export "$invokeMain" (func $invokeMain))

 ;; CHECK:      (func $main-set (type $2) (param $0 (ref $top))
 ;; CHECK-NEXT:  (local.set $0
 ;; CHECK-NEXT:   (struct.new_default $bot)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (ref.cast (ref (exact $bot))
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $main-set (param (ref $top))
  ;; We receive a top as input, but write a bot to it, trampling the ignored
  ;; parameter. Thanks to the trampling, the cast below will succeed, and so we
  ;; should not make anything unreachable in the caller - nothing traps here.
  (local.set 0
   (struct.new $bot)
  )
  (drop
   (ref.cast (ref $bot)
    (local.get 0)
   )
  )
 )

 ;; CHECK:      (func $main-noset (type $2) (param $0 (ref $top))
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (unreachable)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $main-noset (param (ref $top))
  ;; As above, but without the local.set. Here we will trap, so the caller can
  ;; optimize to unreachable.
  (drop
   (ref.cast (ref $bot)
    (local.get 0)
   )
  )
 )

 ;; CHECK:      (func $invokeMain (type $3) (param $0 (ref extern))
 ;; CHECK-NEXT:  (call $main-set
 ;; CHECK-NEXT:   (struct.new_default $top)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (call $main-noset
 ;; CHECK-NEXT:   (unreachable)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $invokeMain (export "$invokeMain") (param (ref extern))
  (call $main-set
   (struct.new $top)
  )
  (call $main-noset
   (struct.new $top)
  )
 )
)