;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited.
;; RUN: foreach %s %t wasm-opt --remove-unused-module-elements --closed-world -all -S -o - | filecheck %s
;; RUN: foreach %s %t wasm-opt --remove-unused-module-elements                -all -S -o - | filecheck %s --check-prefix OPEN_WORLD

;; Test both open world (default) and closed world. In a closed world we can do
;; more with function refs, as we assume nothing calls them on the outside, so
;; if no calls exist to the right type, the function is not reached.

(module
  (rec
    ;; CHECK:      (rec
    ;; CHECK-NEXT:  (type $A-super (sub (func)))
    ;; OPEN_WORLD:      (rec
    ;; OPEN_WORLD-NEXT:  (type $A-super (sub (func)))
    (type $A-super (sub (func)))

    ;; CHECK:       (type $A (sub $A-super (func)))
    ;; OPEN_WORLD:       (type $A (sub $A-super (func)))
    (type $A (sub $A-super (func)))

    ;; CHECK:       (type $A-sub (sub $A (func)))
    ;; OPEN_WORLD:       (type $A-sub (sub $A (func)))
    (type $A-sub (sub $A (func)))

    ;; CHECK:       (type $B (func))
    ;; OPEN_WORLD:       (type $B (func))
    (type $B (func))
  )

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

  ;; CHECK:      (elem declare func $target-A $target-A-sub $target-A-super $target-B)

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

  ;; CHECK:      (func $foo (type $4)
  ;; CHECK-NEXT:  (local $A (ref null $A))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.func $target-A)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.func $target-A-sub)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.func $target-A-super)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.func $target-B)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call_ref $A
  ;; CHECK-NEXT:   (local.get $A)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (block ;; (replaces unreachable CallRef we can't emit)
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (type $4 (func))

  ;; OPEN_WORLD:      (elem declare func $target-A $target-A-sub $target-A-super $target-B)

  ;; OPEN_WORLD:      (export "foo" (func $foo))

  ;; OPEN_WORLD:      (func $foo (type $4)
  ;; OPEN_WORLD-NEXT:  (local $A (ref null $A))
  ;; OPEN_WORLD-NEXT:  (drop
  ;; OPEN_WORLD-NEXT:   (ref.func $target-A)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (drop
  ;; OPEN_WORLD-NEXT:   (ref.func $target-A-sub)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (drop
  ;; OPEN_WORLD-NEXT:   (ref.func $target-A-super)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (drop
  ;; OPEN_WORLD-NEXT:   (ref.func $target-B)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (call_ref $A
  ;; OPEN_WORLD-NEXT:   (local.get $A)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (block ;; (replaces unreachable CallRef we can't emit)
  ;; OPEN_WORLD-NEXT:   (drop
  ;; OPEN_WORLD-NEXT:    (unreachable)
  ;; OPEN_WORLD-NEXT:   )
  ;; OPEN_WORLD-NEXT:   (unreachable)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT: )
  (func $foo (export "foo")
    (local $A (ref null $A))
    ;; This export has some RefFuncs, and one CallRef.
    (drop
      (ref.func $target-A)
    )
    (drop
      (ref.func $target-A-sub)
    )
    (drop
      (ref.func $target-A-super)
    )
    (drop
      (ref.func $target-B)
    )
    (call_ref $A
      (local.get $A)
    )
    ;; Verify that we do not crash on an unreachable call_ref, which has no
    ;; heap type for us to analyze.
    (call_ref $A
      (unreachable)
    )
  )

  ;; CHECK:      (func $target-A (type $A)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $target-A (type $A)
  ;; OPEN_WORLD-NEXT: )
  (func $target-A (type $A)
    ;; This function is reachable from the export "foo": there is a RefFunc and
    ;; a CallRef for it there.
  )

  (func $target-A-noref (type $A)
    ;; This function is not reachable. We have a CallRef of the right type, but
    ;; no RefFunc.
  )

  ;; CHECK:      (func $target-A-sub (type $A-sub)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $target-A-sub (type $A-sub)
  ;; OPEN_WORLD-NEXT: )
  (func $target-A-sub (type $A-sub)
    ;; This function is reachable because we have a CallRef of a supertype ($A).
  )

  ;; CHECK:      (func $target-A-super (type $A-super)
  ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $target-A-super (type $A-super)
  ;; OPEN_WORLD-NEXT: )
  (func $target-A-super (type $A-super)
    ;; This function is not reachable. We have a CallRef of a subtype ($A), but
    ;; that is not enough.
  )

  ;; CHECK:      (func $target-B (type $B)
  ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $target-B (type $B)
  ;; OPEN_WORLD-NEXT: )
  (func $target-B (type $B)
    ;; This function is not reachable. We have a RefFunc in "foo" but no
    ;; suitable CallRef.
    ;;
    ;; Note that we cannot remove the function, as the RefFunc must refer to
    ;; something in order to validate. But we can clear out the body of this
    ;; function with an unreachable.
    ;;
    ;; As mentioned above, in an open world we cannot optimize here, so the
    ;; function body will remain empty as a nop, and not turn into an
    ;; unreachable.
  )
)

;; As above, but reverse the order inside $foo, so we see the CallRef first.
(module
  ;; CHECK:      (type $A (func))
  ;; OPEN_WORLD:      (type $A (func))
  (type $A (func))
  (type $B (func))

  ;; CHECK:      (elem declare func $target-A)

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

  ;; CHECK:      (func $foo (type $A)
  ;; CHECK-NEXT:  (local $A (ref null $A))
  ;; CHECK-NEXT:  (call_ref $A
  ;; CHECK-NEXT:   (local.get $A)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.func $target-A)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (elem declare func $target-A)

  ;; OPEN_WORLD:      (export "foo" (func $foo))

  ;; OPEN_WORLD:      (func $foo (type $A)
  ;; OPEN_WORLD-NEXT:  (local $A (ref null $A))
  ;; OPEN_WORLD-NEXT:  (call_ref $A
  ;; OPEN_WORLD-NEXT:   (local.get $A)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (drop
  ;; OPEN_WORLD-NEXT:   (ref.func $target-A)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT: )
  (func $foo (export "foo")
    (local $A (ref null $A))
    (call_ref $A
      (local.get $A)
    )
    (drop
      (ref.func $target-A)
    )
  )

  ;; CHECK:      (func $target-A (type $A)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $target-A (type $A)
  ;; OPEN_WORLD-NEXT: )
  (func $target-A (type $A)
    ;; This function is reachable.
  )

  (func $target-A-noref (type $A)
    ;; This function is not reachable.
  )
)

;; As above, but interleave CallRefs with RefFuncs.
(module
  ;; CHECK:      (type $A (func))
  ;; OPEN_WORLD:      (type $A (func))
  (type $A (func))
  (type $B (func))

  ;; CHECK:      (elem declare func $target-A-1 $target-A-2)

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

  ;; CHECK:      (func $foo (type $A)
  ;; CHECK-NEXT:  (local $A (ref null $A))
  ;; CHECK-NEXT:  (call_ref $A
  ;; CHECK-NEXT:   (local.get $A)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.func $target-A-1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call_ref $A
  ;; CHECK-NEXT:   (local.get $A)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.func $target-A-2)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (elem declare func $target-A-1 $target-A-2)

  ;; OPEN_WORLD:      (export "foo" (func $foo))

  ;; OPEN_WORLD:      (func $foo (type $A)
  ;; OPEN_WORLD-NEXT:  (local $A (ref null $A))
  ;; OPEN_WORLD-NEXT:  (call_ref $A
  ;; OPEN_WORLD-NEXT:   (local.get $A)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (drop
  ;; OPEN_WORLD-NEXT:   (ref.func $target-A-1)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (call_ref $A
  ;; OPEN_WORLD-NEXT:   (local.get $A)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (drop
  ;; OPEN_WORLD-NEXT:   (ref.func $target-A-2)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT: )
  (func $foo (export "foo")
    (local $A (ref null $A))
    (call_ref $A
      (local.get $A)
    )
    (drop
      (ref.func $target-A-1)
    )
    (call_ref $A
      (local.get $A)
    )
    (drop
      (ref.func $target-A-2)
    )
  )

  ;; WORLD_OPEN-NEXT: )
  ;; CHECK:      (func $target-A-1 (type $A)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $target-A-1 (type $A)
  ;; OPEN_WORLD-NEXT: )
  (func $target-A-1 (type $A)
    ;; This function is reachable.
  )

  ;; CHECK:      (func $target-A-2 (type $A)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $target-A-2 (type $A)
  ;; OPEN_WORLD-NEXT: )
  (func $target-A-2 (type $A)
    ;; This function is reachable.
  )

  (func $target-A-3 (type $A)
    ;; This function is not reachable.
  )
)

;; As above, with the order reversed inside $foo. The results should be the
;; same.
(module
  ;; CHECK:      (type $A (func))
  ;; OPEN_WORLD:      (type $A (func))
  (type $A (func))
  (type $B (func))

  ;; CHECK:      (elem declare func $target-A-1 $target-A-2)

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

  ;; CHECK:      (func $foo (type $A)
  ;; CHECK-NEXT:  (local $A (ref null $A))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.func $target-A-1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call_ref $A
  ;; CHECK-NEXT:   (local.get $A)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.func $target-A-2)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call_ref $A
  ;; CHECK-NEXT:   (local.get $A)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (elem declare func $target-A-1 $target-A-2)

  ;; OPEN_WORLD:      (export "foo" (func $foo))

  ;; OPEN_WORLD:      (func $foo (type $A)
  ;; OPEN_WORLD-NEXT:  (local $A (ref null $A))
  ;; OPEN_WORLD-NEXT:  (drop
  ;; OPEN_WORLD-NEXT:   (ref.func $target-A-1)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (call_ref $A
  ;; OPEN_WORLD-NEXT:   (local.get $A)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (drop
  ;; OPEN_WORLD-NEXT:   (ref.func $target-A-2)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (call_ref $A
  ;; OPEN_WORLD-NEXT:   (local.get $A)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT: )
  (func $foo (export "foo")
    (local $A (ref null $A))
    (drop
      (ref.func $target-A-1)
    )
    (call_ref $A
      (local.get $A)
    )
    (drop
      (ref.func $target-A-2)
    )
    (call_ref $A
      (local.get $A)
    )
  )

  ;; CHECK:      (func $target-A-1 (type $A)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $target-A-1 (type $A)
  ;; OPEN_WORLD-NEXT: )
  (func $target-A-1 (type $A)
    ;; This function is reachable.
  )

  ;; CHECK:      (func $target-A-2 (type $A)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $target-A-2 (type $A)
  ;; OPEN_WORLD-NEXT: )
  (func $target-A-2 (type $A)
    ;; This function is reachable.
  )

  (func $target-A-3 (type $A)
    ;; This function is not reachable.
  )
)

;; call_indirect can reach things in the table, or that are written to the table
;; during runtime.
(module
  ;; CHECK:      (type $none_=>_none (func))
  ;; OPEN_WORLD:      (type $none_=>_none (func))
  (type $none_=>_none (func))

  ;; CHECK:      (table $table 22 funcref)
  ;; OPEN_WORLD:      (table $table 22 funcref)
  (table $table 22 funcref)

  ;; CHECK:      (elem declare func $func)

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

  ;; CHECK:      (func $run (type $none_=>_none)
  ;; CHECK-NEXT:  (table.set $table
  ;; CHECK-NEXT:   (i32.const 0)
  ;; CHECK-NEXT:   (ref.func $func)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call_indirect $table (type $none_=>_none)
  ;; CHECK-NEXT:   (i32.const 0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (elem declare func $func)

  ;; OPEN_WORLD:      (export "run" (func $run))

  ;; OPEN_WORLD:      (func $run (type $none_=>_none)
  ;; OPEN_WORLD-NEXT:  (table.set $table
  ;; OPEN_WORLD-NEXT:   (i32.const 0)
  ;; OPEN_WORLD-NEXT:   (ref.func $func)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (call_indirect $table (type $none_=>_none)
  ;; OPEN_WORLD-NEXT:   (i32.const 0)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT: )
  (func $run (export "run")
    ;; Set something in the table, and call it.
    (table.set $table
      (i32.const 0)
      (ref.func $func)
    )
    (call_indirect $table (type $none_=>_none)
      (i32.const 0)
    )
  )

  ;; CHECK:      (func $func (type $none_=>_none)
  ;; CHECK-NEXT:  (nop)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $func (type $none_=>_none)
  ;; OPEN_WORLD-NEXT:  (nop)
  ;; OPEN_WORLD-NEXT: )
  (func $func (type $none_=>_none)
    ;; This function will be called indirectly from |run|, so it is reachable
    ;; and this should not be turned into |unreachable|.
    (nop)
  )
)

;; The call.without.effects intrinsic does a call to the reference given to it,
;; but for now other imports do not (until we add a flag for closed-world).
(module
  ;; CHECK:      (type $A (func))
  ;; OPEN_WORLD:      (type $A (func))
  (type $A (func))

  (import "binaryen-intrinsics" "call.without.effects"
    (func $call-without-effects (param funcref)))

  (import "other" "import"
    (func $other-import (param funcref)))

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

  ;; CHECK:      (import "binaryen-intrinsics" "call.without.effects" (func $call-without-effects (type $1) (param funcref)))

  ;; CHECK:      (import "other" "import" (func $other-import (type $1) (param funcref)))

  ;; CHECK:      (elem declare func $target-drop $target-keep)

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

  ;; CHECK:      (func $foo (type $A)
  ;; CHECK-NEXT:  (call $call-without-effects
  ;; CHECK-NEXT:   (ref.func $target-keep)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call $other-import
  ;; CHECK-NEXT:   (ref.func $target-drop)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (type $1 (func (param funcref)))

  ;; OPEN_WORLD:      (import "binaryen-intrinsics" "call.without.effects" (func $call-without-effects (type $1) (param funcref)))

  ;; OPEN_WORLD:      (import "other" "import" (func $other-import (type $1) (param funcref)))

  ;; OPEN_WORLD:      (elem declare func $target-drop $target-keep)

  ;; OPEN_WORLD:      (export "foo" (func $foo))

  ;; OPEN_WORLD:      (func $foo (type $A)
  ;; OPEN_WORLD-NEXT:  (call $call-without-effects
  ;; OPEN_WORLD-NEXT:   (ref.func $target-keep)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (call $other-import
  ;; OPEN_WORLD-NEXT:   (ref.func $target-drop)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT: )
  (func $foo (export "foo")
    ;; Calling the intrinsic with a reference is considered a call of the
    ;; reference, so we will not remove $target-keep.
    (call $call-without-effects
      (ref.func $target-keep)
    )
    ;; The other import is not enough to keep $target-drop alive.
    (call $other-import
      (ref.func $target-drop)
    )
  )

  ;; CHECK:      (func $target-keep (type $A)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $target-keep (type $A)
  ;; OPEN_WORLD-NEXT: )
  (func $target-keep (type $A)
  )

  ;; CHECK:      (func $target-drop (type $A)
  ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $target-drop (type $A)
  ;; OPEN_WORLD-NEXT: )
  (func $target-drop (type $A)
    ;; In a closed world we can turn this body into unreachable.
  )
)

;; As above, but now the call to the intrinsic does not let us see the exact
;; function being called.
(module
  ;; CHECK:      (type $A (func))
  ;; OPEN_WORLD:      (type $A (func))
  (type $A (func))

  (import "binaryen-intrinsics" "call.without.effects"
    (func $call-without-effects (param funcref)))

  (import "other" "import"
    (func $other-import (param funcref)))

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

  ;; CHECK:      (import "binaryen-intrinsics" "call.without.effects" (func $call-without-effects (type $1) (param funcref)))

  ;; CHECK:      (import "other" "import" (func $other-import (type $1) (param funcref)))

  ;; CHECK:      (elem declare func $target-keep $target-keep-2)

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

  ;; CHECK:      (func $foo (type $A)
  ;; CHECK-NEXT:  (local $A (ref null $A))
  ;; CHECK-NEXT:  (call $call-without-effects
  ;; CHECK-NEXT:   (local.get $A)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.func $target-keep)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call $other-import
  ;; CHECK-NEXT:   (ref.func $target-keep-2)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (type $1 (func (param funcref)))

  ;; OPEN_WORLD:      (import "binaryen-intrinsics" "call.without.effects" (func $call-without-effects (type $1) (param funcref)))

  ;; OPEN_WORLD:      (import "other" "import" (func $other-import (type $1) (param funcref)))

  ;; OPEN_WORLD:      (elem declare func $target-keep $target-keep-2)

  ;; OPEN_WORLD:      (export "foo" (func $foo))

  ;; OPEN_WORLD:      (func $foo (type $A)
  ;; OPEN_WORLD-NEXT:  (local $A (ref null $A))
  ;; OPEN_WORLD-NEXT:  (call $call-without-effects
  ;; OPEN_WORLD-NEXT:   (local.get $A)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (drop
  ;; OPEN_WORLD-NEXT:   (ref.func $target-keep)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (call $other-import
  ;; OPEN_WORLD-NEXT:   (ref.func $target-keep-2)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT: )
  (func $foo (export "foo")
    (local $A (ref null $A))
    ;; Call the intrinsic without a RefFunc. All we infer here is the type,
    ;; which means we must assume anything with type $A (and a reference) can be
    ;; called, which will keep alive both $target-keep and $target-keep-2
    (call $call-without-effects
      (local.get $A)
    )
    (drop
      (ref.func $target-keep)
    )
    (call $other-import
      (ref.func $target-keep-2)
    )
  )

  ;; CHECK:      (func $target-keep (type $A)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $target-keep (type $A)
  ;; OPEN_WORLD-NEXT: )
  (func $target-keep (type $A)
  )

  ;; CHECK:      (func $target-keep-2 (type $A)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $target-keep-2 (type $A)
  ;; OPEN_WORLD-NEXT: )
  (func $target-keep-2 (type $A)
  )
)

;; Test reachability of struct fields in globals. Only fields that have actual
;; reads need to be processed.
(module
  ;; CHECK:      (type $void (func))
  ;; OPEN_WORLD:      (type $void (func))
  (type $void (func))

  ;; CHECK:      (type $vtable (sub (struct (field (ref $void)) (field (ref $void)))))
  ;; OPEN_WORLD:      (type $vtable (sub (struct (field (ref $void)) (field (ref $void)))))
  (type $vtable (sub (struct (field (ref $void)) (field (ref $void)))))

  ;; CHECK:      (global $vtable (ref $vtable) (struct.new $vtable
  ;; CHECK-NEXT:  (ref.func $a)
  ;; CHECK-NEXT:  (ref.func $b)
  ;; CHECK-NEXT: ))
  ;; OPEN_WORLD:      (global $vtable (ref $vtable) (struct.new $vtable
  ;; OPEN_WORLD-NEXT:  (ref.func $a)
  ;; OPEN_WORLD-NEXT:  (ref.func $b)
  ;; OPEN_WORLD-NEXT: ))
  (global $vtable (ref $vtable) (struct.new $vtable
    (ref.func $a)
    (ref.func $b)
  ))

  (global $vtable-2 (ref $vtable) (struct.new $vtable
    (ref.func $c)
    (ref.func $d)
  ))

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

  ;; CHECK:      (func $export (type $void)
  ;; CHECK-NEXT:  (call $b)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (export "export" (func $export))

  ;; OPEN_WORLD:      (func $export (type $void)
  ;; OPEN_WORLD-NEXT:  (call $b)
  ;; OPEN_WORLD-NEXT: )
  (func $export (export "export")
    ;; Call $b but not $a or $c
    (call $b)
  )

  ;; CHECK:      (func $a (type $void)
  ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $a (type $void)
  ;; OPEN_WORLD-NEXT:  (call_ref $void
  ;; OPEN_WORLD-NEXT:   (struct.get $vtable 0
  ;; OPEN_WORLD-NEXT:    (global.get $vtable)
  ;; OPEN_WORLD-NEXT:   )
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT: )
  (func $a (type $void)
    ;; $a calls field #0 in the vtable.
    ;;
    ;; Even though $a is in the vtable, it is dead, since the vtable is alive
    ;; but there is no live read of field #0 - the only read is in here, which
    ;; is basically an unreachable cycle that we can collect. We can empty out
    ;; this function since it is dead, but we cannot remove it entirely due to
    ;; the ref in the vtable.
    ;;
    ;; (In open world, however, we cannot do this, as we must assume reads of
    ;; struct fields can occur outside of our view. That is, the vtable could be
    ;; sent somewhere that reads field #0, which would make $a live.)
    (call_ref $void
      (struct.get $vtable 0
        (global.get $vtable)
      )
    )
  )

  ;; CHECK:      (func $b (type $void)
  ;; CHECK-NEXT:  (call_ref $void
  ;; CHECK-NEXT:   (struct.get $vtable 1
  ;; CHECK-NEXT:    (global.get $vtable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $b (type $void)
  ;; OPEN_WORLD-NEXT:  (call_ref $void
  ;; OPEN_WORLD-NEXT:   (struct.get $vtable 1
  ;; OPEN_WORLD-NEXT:    (global.get $vtable)
  ;; OPEN_WORLD-NEXT:   )
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT: )
  (func $b (type $void)
    ;; $b calls field #1 in the vtable.
    ;;
    ;; As $b is called from the export, this function is not dead.
    (call_ref $void
      (struct.get $vtable 1
        (global.get $vtable)
      )
    )
  )

  (func $c (type $void)
    ;; $c is parallel to $a, but using vtable-2, which has no other references,
    ;; so this is dead like $a, and can be removed entirely.
    (call_ref $void
      (struct.get $vtable 0
        (global.get $vtable-2)
      )
    )
  )

  (func $d (type $void)
    ;; $d is parallel to $b, but using vtable-2, which has no other references.
    ;; This is dead, even though the struct type + index have a use (due to the
    ;; other vtable) - there is no use of vtable-2 (except from unreachable
    ;; places like here), so this cannot be reached.
    (call_ref $void
      (struct.get $vtable 0
        (global.get $vtable-2)
      )
    )
  )
)

;; Test struct.news not in globals.
(module
  ;; CHECK:      (type $void (func))
  ;; OPEN_WORLD:      (type $void (func))
  (type $void (func))

  ;; CHECK:      (type $vtable (sub (struct (field (ref $void)) (field (ref $void)))))
  ;; OPEN_WORLD:      (type $vtable (sub (struct (field (ref $void)) (field (ref $void)))))
  (type $vtable (sub (struct (field (ref $void)) (field (ref $void)))))

  ;; CHECK:      (type $struct (sub (struct (field (ref $vtable)) (field (ref $vtable)) (field (ref $vtable)) (field (ref $vtable)))))
  ;; OPEN_WORLD:      (type $struct (sub (struct (field (ref $vtable)) (field (ref $vtable)) (field (ref $vtable)) (field (ref $vtable)))))
  (type $struct (sub (struct (field (ref $vtable)) (field (ref $vtable)) (field (ref $vtable)) (field (ref $vtable)))))

  ;; CHECK:      (global $vtable (ref $vtable) (struct.new $vtable
  ;; CHECK-NEXT:  (ref.func $a)
  ;; CHECK-NEXT:  (ref.func $b)
  ;; CHECK-NEXT: ))
  ;; OPEN_WORLD:      (global $vtable (ref $vtable) (struct.new $vtable
  ;; OPEN_WORLD-NEXT:  (ref.func $a)
  ;; OPEN_WORLD-NEXT:  (ref.func $b)
  ;; OPEN_WORLD-NEXT: ))
  (global $vtable (ref $vtable) (struct.new $vtable
    (ref.func $a)
    (ref.func $b)
  ))

  ;; CHECK:      (elem declare func $c $d $e $f $g $h $void)

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

  ;; CHECK:      (func $func (type $void)
  ;; CHECK-NEXT:  (local $ref (ref $struct))
  ;; CHECK-NEXT:  (local $vtable (ref $vtable))
  ;; CHECK-NEXT:  (local.set $ref
  ;; CHECK-NEXT:   (struct.new $struct
  ;; CHECK-NEXT:    (global.get $vtable)
  ;; CHECK-NEXT:    (struct.new $vtable
  ;; CHECK-NEXT:     (ref.func $c)
  ;; CHECK-NEXT:     (ref.func $d)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.tee $vtable
  ;; CHECK-NEXT:     (struct.new $vtable
  ;; CHECK-NEXT:      (ref.func $e)
  ;; CHECK-NEXT:      (ref.func $f)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (struct.new $vtable
  ;; CHECK-NEXT:     (ref.func $g)
  ;; CHECK-NEXT:     (ref.func $h)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block ;; (replaces unreachable StructNew we can't emit)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (unreachable)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (unreachable)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.get $struct 0
  ;; CHECK-NEXT:    (local.get $ref)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.get $struct 1
  ;; CHECK-NEXT:    (local.get $ref)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.get $struct 2
  ;; CHECK-NEXT:    (local.get $ref)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.get $vtable 1
  ;; CHECK-NEXT:    (local.get $vtable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call_ref $void
  ;; CHECK-NEXT:   (ref.func $void)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (elem declare func $c $d $e $f $g $h $void)

  ;; OPEN_WORLD:      (export "func" (func $func))

  ;; OPEN_WORLD:      (func $func (type $void)
  ;; OPEN_WORLD-NEXT:  (local $ref (ref $struct))
  ;; OPEN_WORLD-NEXT:  (local $vtable (ref $vtable))
  ;; OPEN_WORLD-NEXT:  (local.set $ref
  ;; OPEN_WORLD-NEXT:   (struct.new $struct
  ;; OPEN_WORLD-NEXT:    (global.get $vtable)
  ;; OPEN_WORLD-NEXT:    (struct.new $vtable
  ;; OPEN_WORLD-NEXT:     (ref.func $c)
  ;; OPEN_WORLD-NEXT:     (ref.func $d)
  ;; OPEN_WORLD-NEXT:    )
  ;; OPEN_WORLD-NEXT:    (local.tee $vtable
  ;; OPEN_WORLD-NEXT:     (struct.new $vtable
  ;; OPEN_WORLD-NEXT:      (ref.func $e)
  ;; OPEN_WORLD-NEXT:      (ref.func $f)
  ;; OPEN_WORLD-NEXT:     )
  ;; OPEN_WORLD-NEXT:    )
  ;; OPEN_WORLD-NEXT:    (struct.new $vtable
  ;; OPEN_WORLD-NEXT:     (ref.func $g)
  ;; OPEN_WORLD-NEXT:     (ref.func $h)
  ;; OPEN_WORLD-NEXT:    )
  ;; OPEN_WORLD-NEXT:   )
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (drop
  ;; OPEN_WORLD-NEXT:   (block ;; (replaces unreachable StructNew we can't emit)
  ;; OPEN_WORLD-NEXT:    (drop
  ;; OPEN_WORLD-NEXT:     (unreachable)
  ;; OPEN_WORLD-NEXT:    )
  ;; OPEN_WORLD-NEXT:    (drop
  ;; OPEN_WORLD-NEXT:     (unreachable)
  ;; OPEN_WORLD-NEXT:    )
  ;; OPEN_WORLD-NEXT:    (unreachable)
  ;; OPEN_WORLD-NEXT:   )
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (drop
  ;; OPEN_WORLD-NEXT:   (struct.get $struct 0
  ;; OPEN_WORLD-NEXT:    (local.get $ref)
  ;; OPEN_WORLD-NEXT:   )
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (drop
  ;; OPEN_WORLD-NEXT:   (struct.get $struct 1
  ;; OPEN_WORLD-NEXT:    (local.get $ref)
  ;; OPEN_WORLD-NEXT:   )
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (drop
  ;; OPEN_WORLD-NEXT:   (struct.get $struct 2
  ;; OPEN_WORLD-NEXT:    (local.get $ref)
  ;; OPEN_WORLD-NEXT:   )
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (drop
  ;; OPEN_WORLD-NEXT:   (struct.get $vtable 1
  ;; OPEN_WORLD-NEXT:    (local.get $vtable)
  ;; OPEN_WORLD-NEXT:   )
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (call_ref $void
  ;; OPEN_WORLD-NEXT:   (ref.func $void)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT: )
  (func $func (export "func")
    (local $ref (ref $struct))
    (local $vtable (ref $vtable))

    (local.set $ref
      (struct.new $struct
        ;; Init one field using the global vtable.
        (global.get $vtable)
        ;; Init another field using a vtable we create here - a nested
        ;; struct.new inside this one.
        (struct.new $vtable
          (ref.func $c)
          (ref.func $d)
        )
        ;; Another nested one, but now there is a side effect. Everything here
        ;; is considered to escape due to that.
        (local.tee $vtable
          (struct.new $vtable
            (ref.func $e)
            (ref.func $f)
          )
        )
        ;; Another nested one. This field will not be read.
        (struct.new $vtable
          (ref.func $g)
          (ref.func $h)
        )
      )
    )

    ;; Test that we do not assert on an unreachable struct.new.
    (drop
      (struct.new $vtable
        (unreachable)
        (unreachable)
      )
    )

    ;; Read from all fields of $struct except for the last.
    (drop
      (struct.get $struct 0
        (local.get $ref)
      )
    )
    (drop
      (struct.get $struct 1
        (local.get $ref)
      )
    )
    (drop
      (struct.get $struct 2
        (local.get $ref)
      )
    )

    ;; Read from field #1 of the vtable type, but not #0.
    (drop
      (struct.get $vtable 1
        (local.get $vtable)
      )
    )

    ;; Call something of type void so we don't eliminate them all instantly.
    (call_ref $void
      (ref.func $void)
    )
  )

  ;; CHECK:      (func $void (type $void)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $void (type $void)
  ;; OPEN_WORLD-NEXT: )
  (func $void (type $void)
    ;; Helper function. This is reached via a call_ref.
  )

  ;; CHECK:      (func $a (type $void)
  ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $a (type $void)
  ;; OPEN_WORLD-NEXT: )
  (func $a (type $void)
    ;; This is unreachable (in closed world) since a reference to it only exists
    ;; in field #0 of the vtable type, which is never read from.
  )

  ;; CHECK:      (func $b (type $void)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $b (type $void)
  ;; OPEN_WORLD-NEXT: )
  (func $b (type $void)
    ;; This is reachable. It is in field #1, which is read, and the global
    ;; vtable is also read, and the type $void is call_reffed.
  )

  ;; CHECK:      (func $c (type $void)
  ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $c (type $void)
  ;; OPEN_WORLD-NEXT: )
  (func $c (type $void)
    ;; Like $a, this is unreachable. That it is in a nested struct.new, and not
    ;; in a global, does not matter.
  )

  ;; CHECK:      (func $d (type $void)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $d (type $void)
  ;; OPEN_WORLD-NEXT: )
  (func $d (type $void)
    ;; Like $b, this is reachable. That it is in a nested struct.new, and not
    ;; in a global, does not matter.
  )

  ;; CHECK:      (func $e (type $void)
  ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $e (type $void)
  ;; OPEN_WORLD-NEXT: )
  (func $e (type $void)
    ;; Side effects on the struct field are not enough to make this reachable:
    ;; there is a tee on the struct.new we are in, but field #0 is still not
    ;; read from the relevant struct.
  )

  ;; CHECK:      (func $f (type $void)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $f (type $void)
  ;; OPEN_WORLD-NEXT: )
  (func $f (type $void)
    ;; Like $b, this is reachable (the tee does not matter).
  )

  ;; CHECK:      (func $g (type $void)
  ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $g (type $void)
  ;; OPEN_WORLD-NEXT: )
  (func $g (type $void)
    ;; This is in a struct written to a field that is never read in $struct, so
    ;; it is unreachable.
  )

  ;; CHECK:      (func $h (type $void)
  ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $h (type $void)
  ;; OPEN_WORLD-NEXT: )
  (func $h (type $void)
    ;; This is in a struct written to a field that is never read in $struct, so
    ;; it is unreachable.
  )
)

;; Test side effects causing a value to "leak."
(module
  ;; CHECK:      (type $void (func))
  ;; OPEN_WORLD:      (type $void (func))
  (type $void (func))

  ;; CHECK:      (type $vtable (sub (struct (field (ref $void)) (field (ref $void)))))
  ;; OPEN_WORLD:      (type $vtable (sub (struct (field (ref $void)) (field (ref $void)))))
  (type $vtable (sub (struct (field (ref $void)) (field (ref $void)))))

  ;; CHECK:      (elem declare func $a $b $void)

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

  ;; CHECK:      (func $func (type $void)
  ;; CHECK-NEXT:  (local $vtable (ref $vtable))
  ;; CHECK-NEXT:  (local $void (ref $void))
  ;; CHECK-NEXT:  (local.set $vtable
  ;; CHECK-NEXT:   (struct.new $vtable
  ;; CHECK-NEXT:    (ref.func $a)
  ;; CHECK-NEXT:    (local.tee $void
  ;; CHECK-NEXT:     (ref.func $b)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call_ref $void
  ;; CHECK-NEXT:   (ref.func $void)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (elem declare func $a $b $void)

  ;; OPEN_WORLD:      (export "func" (func $func))

  ;; OPEN_WORLD:      (func $func (type $void)
  ;; OPEN_WORLD-NEXT:  (local $vtable (ref $vtable))
  ;; OPEN_WORLD-NEXT:  (local $void (ref $void))
  ;; OPEN_WORLD-NEXT:  (local.set $vtable
  ;; OPEN_WORLD-NEXT:   (struct.new $vtable
  ;; OPEN_WORLD-NEXT:    (ref.func $a)
  ;; OPEN_WORLD-NEXT:    (local.tee $void
  ;; OPEN_WORLD-NEXT:     (ref.func $b)
  ;; OPEN_WORLD-NEXT:    )
  ;; OPEN_WORLD-NEXT:   )
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (call_ref $void
  ;; OPEN_WORLD-NEXT:   (ref.func $void)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT: )
  (func $func (export "func")
    (local $vtable (ref $vtable))
    (local $void (ref $void))

    ;; Init one field using a tee, and one normally.
    (local.set $vtable
      (struct.new $vtable
        (ref.func $a)
        (local.tee $void
          (ref.func $b)
        )
      )
    )

    ;; Call the type so it is reachable.
    (call_ref $void
      (ref.func $void)
    )
  )

  ;; CHECK:      (func $void (type $void)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $void (type $void)
  ;; OPEN_WORLD-NEXT: )
  (func $void (type $void)
    ;; Helper function. This is reached via a call_ref.
  )

  ;; CHECK:      (func $a (type $void)
  ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $a (type $void)
  ;; OPEN_WORLD-NEXT: )
  (func $a (type $void)
    ;; This is unreachable (in closed world) because we have no reads from the
    ;; struct field it is written in.
  )

  ;; CHECK:      (func $b (type $void)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $b (type $void)
  ;; OPEN_WORLD-NEXT: )
  (func $b (type $void)
    ;; The local.tee makes this reachable: the value is not known to only reside
    ;; in the struct field, so we must assume it can be used even if the struct
    ;; field is not.
  )
)

;; Cycles.
(module
  (rec
    ;; CHECK:      (rec
    ;; CHECK-NEXT:  (type $vtable-func (func (param (ref $vtable))))
    ;; OPEN_WORLD:      (rec
    ;; OPEN_WORLD-NEXT:  (type $vtable-func (func (param (ref $vtable))))
    (type $vtable-func (func (param (ref $vtable))))
    ;; CHECK:       (type $vtable (sub (struct (field (ref $vtable-func)) (field (ref $vtable-func)))))
    ;; OPEN_WORLD:       (type $vtable (sub (struct (field (ref $vtable-func)) (field (ref $vtable-func)))))
    (type $vtable (sub (struct (field (ref $vtable-func)) (field (ref $vtable-func)))))
  )

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

  ;; CHECK:      (elem declare func $a $b $c $d)

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

  ;; CHECK:      (func $func (type $2)
  ;; CHECK-NEXT:  (call_ref $vtable-func
  ;; CHECK-NEXT:   (struct.new $vtable
  ;; CHECK-NEXT:    (ref.func $a)
  ;; CHECK-NEXT:    (ref.func $b)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (struct.get $vtable 0
  ;; CHECK-NEXT:    (struct.new $vtable
  ;; CHECK-NEXT:     (ref.func $a)
  ;; CHECK-NEXT:     (ref.func $b)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.get $vtable 0
  ;; CHECK-NEXT:    (struct.new $vtable
  ;; CHECK-NEXT:     (ref.func $c)
  ;; CHECK-NEXT:     (ref.func $d)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (type $2 (func))

  ;; OPEN_WORLD:      (elem declare func $a $b $c $d)

  ;; OPEN_WORLD:      (export "func" (func $func))

  ;; OPEN_WORLD:      (func $func (type $2)
  ;; OPEN_WORLD-NEXT:  (call_ref $vtable-func
  ;; OPEN_WORLD-NEXT:   (struct.new $vtable
  ;; OPEN_WORLD-NEXT:    (ref.func $a)
  ;; OPEN_WORLD-NEXT:    (ref.func $b)
  ;; OPEN_WORLD-NEXT:   )
  ;; OPEN_WORLD-NEXT:   (struct.get $vtable 0
  ;; OPEN_WORLD-NEXT:    (struct.new $vtable
  ;; OPEN_WORLD-NEXT:     (ref.func $a)
  ;; OPEN_WORLD-NEXT:     (ref.func $b)
  ;; OPEN_WORLD-NEXT:    )
  ;; OPEN_WORLD-NEXT:   )
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (drop
  ;; OPEN_WORLD-NEXT:   (struct.get $vtable 0
  ;; OPEN_WORLD-NEXT:    (struct.new $vtable
  ;; OPEN_WORLD-NEXT:     (ref.func $c)
  ;; OPEN_WORLD-NEXT:     (ref.func $d)
  ;; OPEN_WORLD-NEXT:    )
  ;; OPEN_WORLD-NEXT:   )
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT: )
  (func $func (export "func")
    ;; Read field 0, and call it.
    (call_ref $vtable-func
      (struct.new $vtable
        (ref.func $a)
        (ref.func $b)
      )
      (struct.get $vtable 0
        ;; Duplicate the first vtable.
        (struct.new $vtable
          (ref.func $a)
          (ref.func $b)
        )
      )
    )

    ;; Again, read field #0. No need to call it here (the call before makes the
    ;; type used).
    (drop
      (struct.get $vtable 0
        ;; Make a new vtable with new funcs.
        (struct.new $vtable
          (ref.func $c)
          (ref.func $d)
        )
      )
    )
  )

  ;; CHECK:      (func $a (type $vtable-func) (param $vtable (ref $vtable))
  ;; CHECK-NEXT:  (call_ref $vtable-func
  ;; CHECK-NEXT:   (local.get $vtable)
  ;; CHECK-NEXT:   (struct.get $vtable 0
  ;; CHECK-NEXT:    (local.get $vtable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $a (type $vtable-func) (param $vtable (ref $vtable))
  ;; OPEN_WORLD-NEXT:  (call_ref $vtable-func
  ;; OPEN_WORLD-NEXT:   (local.get $vtable)
  ;; OPEN_WORLD-NEXT:   (struct.get $vtable 0
  ;; OPEN_WORLD-NEXT:    (local.get $vtable)
  ;; OPEN_WORLD-NEXT:   )
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT: )
  (func $a (type $vtable-func) (param $vtable (ref $vtable))
    ;; $a calls $a or $c (using field #0).
    ;; $a is reached from $func, so it is reachable.
    (call_ref $vtable-func
      (local.get $vtable)
      (struct.get $vtable 0
        (local.get $vtable)
      )
    )
  )

  ;; CHECK:      (func $b (type $vtable-func) (param $vtable (ref $vtable))
  ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $b (type $vtable-func) (param $vtable (ref $vtable))
  ;; OPEN_WORLD-NEXT:  (call_ref $vtable-func
  ;; OPEN_WORLD-NEXT:   (local.get $vtable)
  ;; OPEN_WORLD-NEXT:   (struct.get $vtable 1
  ;; OPEN_WORLD-NEXT:    (local.get $vtable)
  ;; OPEN_WORLD-NEXT:   )
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT: )
  (func $b (type $vtable-func) (param $vtable (ref $vtable))
    ;; $b calls $b or $d (using field #1).
    ;; But $b is not reached from $func, so it remains unreachable in closed
    ;; world.
    (call_ref $vtable-func
      (local.get $vtable)
      (struct.get $vtable 1
        (local.get $vtable)
      )
    )
  )

  ;; CHECK:      (func $c (type $vtable-func) (param $vtable (ref $vtable))
  ;; CHECK-NEXT:  (call_ref $vtable-func
  ;; CHECK-NEXT:   (local.get $vtable)
  ;; CHECK-NEXT:   (struct.get $vtable 0
  ;; CHECK-NEXT:    (local.get $vtable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $c (type $vtable-func) (param $vtable (ref $vtable))
  ;; OPEN_WORLD-NEXT:  (call_ref $vtable-func
  ;; OPEN_WORLD-NEXT:   (local.get $vtable)
  ;; OPEN_WORLD-NEXT:   (struct.get $vtable 0
  ;; OPEN_WORLD-NEXT:    (local.get $vtable)
  ;; OPEN_WORLD-NEXT:   )
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT: )
  (func $c (type $vtable-func) (param $vtable (ref $vtable))
    ;; $c forms a cycle with $a.
    (call_ref $vtable-func
      (local.get $vtable)
      (struct.get $vtable 0
        (local.get $vtable)
      )
    )
  )

  ;; CHECK:      (func $d (type $vtable-func) (param $vtable (ref $vtable))
  ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $d (type $vtable-func) (param $vtable (ref $vtable))
  ;; OPEN_WORLD-NEXT:  (call_ref $vtable-func
  ;; OPEN_WORLD-NEXT:   (local.get $vtable)
  ;; OPEN_WORLD-NEXT:   (struct.get $vtable 1
  ;; OPEN_WORLD-NEXT:    (local.get $vtable)
  ;; OPEN_WORLD-NEXT:   )
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT: )
  (func $d (type $vtable-func) (param $vtable (ref $vtable))
    ;; $d forms a cycle with $b.
    (call_ref $vtable-func
      (local.get $vtable)
      (struct.get $vtable 1
        (local.get $vtable)
      )
    )
  )
)

;; Subtyping of struct reads.
(module
  ;; CHECK:      (type $void (func))
  ;; OPEN_WORLD:      (type $void (func))
  (type $void (func))

  ;; CHECK:      (type $struct (sub (struct (field funcref))))
  ;; OPEN_WORLD:      (type $struct (sub (struct (field funcref))))
  (type $struct (sub (struct (field funcref))))

  ;; CHECK:      (type $substruct (sub $struct (struct (field funcref))))
  ;; OPEN_WORLD:      (type $substruct (sub $struct (struct (field funcref))))
  (type $substruct (sub $struct (struct (field funcref))))

  ;; CHECK:      (type $subsubstruct (sub $substruct (struct (field funcref))))
  ;; OPEN_WORLD:      (type $subsubstruct (sub $substruct (struct (field funcref))))
  (type $subsubstruct (sub $substruct (struct (field funcref))))

  ;; CHECK:      (global $g (ref $struct) (struct.new $struct
  ;; CHECK-NEXT:  (ref.func $f)
  ;; CHECK-NEXT: ))
  ;; OPEN_WORLD:      (global $g (ref $struct) (struct.new $struct
  ;; OPEN_WORLD-NEXT:  (ref.func $f)
  ;; OPEN_WORLD-NEXT: ))
  (global $g (ref $struct) (struct.new $struct
    (ref.func $f)
  ))

  ;; CHECK:      (global $subg (ref $substruct) (struct.new $substruct
  ;; CHECK-NEXT:  (ref.func $subf)
  ;; CHECK-NEXT: ))
  ;; OPEN_WORLD:      (global $subg (ref $substruct) (struct.new $substruct
  ;; OPEN_WORLD-NEXT:  (ref.func $subf)
  ;; OPEN_WORLD-NEXT: ))
  (global $subg (ref $substruct) (struct.new $substruct
    (ref.func $subf)
  ))

  ;; CHECK:      (global $subsubg (ref $subsubstruct) (struct.new $subsubstruct
  ;; CHECK-NEXT:  (ref.func $subsubf)
  ;; CHECK-NEXT: ))
  ;; OPEN_WORLD:      (global $subsubg (ref $subsubstruct) (struct.new $subsubstruct
  ;; OPEN_WORLD-NEXT:  (ref.func $subsubf)
  ;; OPEN_WORLD-NEXT: ))
  (global $subsubg (ref $subsubstruct) (struct.new $subsubstruct
    (ref.func $subsubf)
  ))

  ;; CHECK:      (elem declare func $func)

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

  ;; CHECK:      (func $func (type $void)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (global.get $g)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (global.get $subg)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (global.get $subsubg)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.get $substruct 0
  ;; CHECK-NEXT:    (block (result (ref $substruct))
  ;; CHECK-NEXT:     (unreachable)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call_ref $void
  ;; CHECK-NEXT:   (ref.func $func)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (elem declare func $func)

  ;; OPEN_WORLD:      (export "func" (func $func))

  ;; OPEN_WORLD:      (func $func (type $void)
  ;; OPEN_WORLD-NEXT:  (drop
  ;; OPEN_WORLD-NEXT:   (global.get $g)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (drop
  ;; OPEN_WORLD-NEXT:   (global.get $subg)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (drop
  ;; OPEN_WORLD-NEXT:   (global.get $subsubg)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (drop
  ;; OPEN_WORLD-NEXT:   (struct.get $substruct 0
  ;; OPEN_WORLD-NEXT:    (block (result (ref $substruct))
  ;; OPEN_WORLD-NEXT:     (unreachable)
  ;; OPEN_WORLD-NEXT:    )
  ;; OPEN_WORLD-NEXT:   )
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (call_ref $void
  ;; OPEN_WORLD-NEXT:   (ref.func $func)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT: )
  (func $func (export "func")
    ;; Refer to the globals.
    (drop
      (global.get $g)
    )
    (drop
      (global.get $subg)
    )
    (drop
      (global.get $subsubg)
    )

    ;; Read from $substruct's field, but not its super or subtypes.
    (drop
      (struct.get $substruct 0
        (block (result (ref $substruct))
          (unreachable)
        )
      )
    )

    ;; Call the function type to allow functions to be used.
    (call_ref $void
      (ref.func $func)
    )
  )

  (func $void (type $void)
    ;; Helper function. This is reached via a call_ref.
  )

  ;; CHECK:      (func $f (type $void)
  ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $f (type $void)
  ;; OPEN_WORLD-NEXT: )
  (func $f (type $void)
    ;; This is unreachable in closed world. The global it is in has a reference
    ;; but the struct there has no reads of its field.
  )

  ;; CHECK:      (func $subf (type $void)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $subf (type $void)
  ;; OPEN_WORLD-NEXT: )
  (func $subf (type $void)
    ;; There is a read of $substruct's field, which makes this reachable.
  )

  ;; CHECK:      (func $subsubf (type $void)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $subsubf (type $void)
  ;; OPEN_WORLD-NEXT: )
  (func $subsubf (type $void)
    ;; There is a read of $substruct's field, which may read from any subtype,
    ;; which makes this reachable.
  )
)

;; Test references to global function references.
(module
  ;; CHECK:      (type $void (func))
  ;; OPEN_WORLD:      (type $void (func))
  (type $void (func))

  ;; CHECK:      (type $A (struct (field funcref)))
  ;; OPEN_WORLD:      (type $A (struct (field funcref)))
  (type $A (struct (field funcref)))

  ;; CHECK:      (global $g1 (ref func) (ref.func $f1))
  ;; OPEN_WORLD:      (global $g1 (ref func) (ref.func $f1))
  (global $g1 (ref func) (ref.func $f1))

  ;; CHECK:      (global $g2 (ref func) (ref.func $f2))
  ;; OPEN_WORLD:      (global $g2 (ref func) (ref.func $f2))
  (global $g2 (ref func) (ref.func $f2))

  ;; CHECK:      (elem declare func $func)

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

  ;; CHECK:      (func $func (type $void)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (global.get $g1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $A
  ;; CHECK-NEXT:    (global.get $g2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call_ref $void
  ;; CHECK-NEXT:   (ref.func $func)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (elem declare func $func)

  ;; OPEN_WORLD:      (export "func" (func $func))

  ;; OPEN_WORLD:      (func $func (type $void)
  ;; OPEN_WORLD-NEXT:  (drop
  ;; OPEN_WORLD-NEXT:   (global.get $g1)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (drop
  ;; OPEN_WORLD-NEXT:   (struct.new $A
  ;; OPEN_WORLD-NEXT:    (global.get $g2)
  ;; OPEN_WORLD-NEXT:   )
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (call_ref $void
  ;; OPEN_WORLD-NEXT:   (ref.func $func)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT: )
  (func $func (export "func")
    ;; Refer to $g1 directly.
    (drop
      (global.get $g1)
    )
    ;; Refer to $g2 from a struct field that is never read.
    (drop
      (struct.new $A
        (global.get $g2)
      )
    )

    ;; Call the function type to allow functions to be used.
    (call_ref $void
      (ref.func $func)
    )
  )

  (func $void (type $void)
    ;; Helper function. This is reached via a call_ref.
  )

  ;; CHECK:      (func $f1 (type $void)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $f1 (type $void)
  ;; OPEN_WORLD-NEXT: )
  (func $f1 (type $void)
    ;; The global containing this function's reference is used.
  )

  ;; CHECK:      (func $f2 (type $void)
  ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $f2 (type $void)
  ;; OPEN_WORLD-NEXT: )
  (func $f2 (type $void)
    ;; This is unreachable in closed world as the global is referred to from a
    ;; struct field that is never read from.
  )
)

;; As above, but now the globals are struct.news.
(module
  ;; CHECK:      (type $A (struct (field funcref)))

  ;; CHECK:      (type $void (func))
  ;; OPEN_WORLD:      (type $A (struct (field funcref)))

  ;; OPEN_WORLD:      (type $void (func))
  (type $void (func))

  (type $A (struct (field funcref)))

  ;; CHECK:      (type $B (struct (field (ref $A))))
  ;; OPEN_WORLD:      (type $B (struct (field (ref $A))))
  (type $B (struct (field (ref $A))))

  ;; CHECK:      (global $g (ref $A) (struct.new $A
  ;; CHECK-NEXT:  (ref.func $f)
  ;; CHECK-NEXT: ))
  ;; OPEN_WORLD:      (global $g (ref $A) (struct.new $A
  ;; OPEN_WORLD-NEXT:  (ref.func $f)
  ;; OPEN_WORLD-NEXT: ))
  (global $g (ref $A) (struct.new $A
    (ref.func $f)
  ))

  ;; CHECK:      (elem declare func $func)

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

  ;; CHECK:      (func $func (type $void)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $B
  ;; CHECK-NEXT:    (global.get $g)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call_ref $void
  ;; CHECK-NEXT:   (ref.func $func)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.get $A 0
  ;; CHECK-NEXT:    (block (result (ref $A))
  ;; CHECK-NEXT:     (unreachable)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (elem declare func $func)

  ;; OPEN_WORLD:      (export "func" (func $func))

  ;; OPEN_WORLD:      (func $func (type $void)
  ;; OPEN_WORLD-NEXT:  (drop
  ;; OPEN_WORLD-NEXT:   (struct.new $B
  ;; OPEN_WORLD-NEXT:    (global.get $g)
  ;; OPEN_WORLD-NEXT:   )
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (call_ref $void
  ;; OPEN_WORLD-NEXT:   (ref.func $func)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (drop
  ;; OPEN_WORLD-NEXT:   (struct.get $A 0
  ;; OPEN_WORLD-NEXT:    (block (result (ref $A))
  ;; OPEN_WORLD-NEXT:     (unreachable)
  ;; OPEN_WORLD-NEXT:    )
  ;; OPEN_WORLD-NEXT:   )
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT: )
  (func $func (export "func")
    ;; Refer to $g from a struct field that is never read.
    (drop
      (struct.new $B
        (global.get $g)
      )
    )

    ;; Call the function type to allow functions to be used.
    (call_ref $void
      (ref.func $func)
    )

    ;; Read $A's field.
    (drop
      (struct.get $A 0
        (block (result (ref $A))
          (unreachable)
        )
      )
    )
  )

  (func $void (type $void)
    ;; Helper function. This is reached via a call_ref.
  )

  ;; CHECK:      (func $f (type $void)
  ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $f (type $void)
  ;; OPEN_WORLD-NEXT: )
  (func $f (type $void)
    ;; This is unreachable in closed world since $B's field is not read, so the
    ;; global it is in is only referenced and not used.
  )
)

;; As above, but read $B's field. Now $f is reachable.
(module
  ;; CHECK:      (type $A (struct (field funcref)))

  ;; CHECK:      (type $void (func))
  ;; OPEN_WORLD:      (type $A (struct (field funcref)))

  ;; OPEN_WORLD:      (type $void (func))
  (type $void (func))

  (type $A (struct (field funcref)))

  ;; CHECK:      (type $B (struct (field (ref $A))))
  ;; OPEN_WORLD:      (type $B (struct (field (ref $A))))
  (type $B (struct (field (ref $A))))

  ;; CHECK:      (global $g (ref $A) (struct.new $A
  ;; CHECK-NEXT:  (ref.func $f)
  ;; CHECK-NEXT: ))
  ;; OPEN_WORLD:      (global $g (ref $A) (struct.new $A
  ;; OPEN_WORLD-NEXT:  (ref.func $f)
  ;; OPEN_WORLD-NEXT: ))
  (global $g (ref $A) (struct.new $A
    (ref.func $f)
  ))

  ;; CHECK:      (elem declare func $func)

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

  ;; CHECK:      (func $func (type $void)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $B
  ;; CHECK-NEXT:    (global.get $g)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (call_ref $void
  ;; CHECK-NEXT:   (ref.func $func)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.get $A 0
  ;; CHECK-NEXT:    (block (result (ref $A))
  ;; CHECK-NEXT:     (unreachable)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.get $B 0
  ;; CHECK-NEXT:    (block (result (ref $B))
  ;; CHECK-NEXT:     (unreachable)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (elem declare func $func)

  ;; OPEN_WORLD:      (export "func" (func $func))

  ;; OPEN_WORLD:      (func $func (type $void)
  ;; OPEN_WORLD-NEXT:  (drop
  ;; OPEN_WORLD-NEXT:   (struct.new $B
  ;; OPEN_WORLD-NEXT:    (global.get $g)
  ;; OPEN_WORLD-NEXT:   )
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (call_ref $void
  ;; OPEN_WORLD-NEXT:   (ref.func $func)
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (drop
  ;; OPEN_WORLD-NEXT:   (struct.get $A 0
  ;; OPEN_WORLD-NEXT:    (block (result (ref $A))
  ;; OPEN_WORLD-NEXT:     (unreachable)
  ;; OPEN_WORLD-NEXT:    )
  ;; OPEN_WORLD-NEXT:   )
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT:  (drop
  ;; OPEN_WORLD-NEXT:   (struct.get $B 0
  ;; OPEN_WORLD-NEXT:    (block (result (ref $B))
  ;; OPEN_WORLD-NEXT:     (unreachable)
  ;; OPEN_WORLD-NEXT:    )
  ;; OPEN_WORLD-NEXT:   )
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT: )
  (func $func (export "func")
    (drop
      (struct.new $B
        (global.get $g)
      )
    )

    (call_ref $void
      (ref.func $func)
    )

    (drop
      (struct.get $A 0
        (block (result (ref $A))
          (unreachable)
        )
      )
    )

    ;; The change in this testcase is to read $B's field.
    (drop
      (struct.get $B 0
        (block (result (ref $B))
          (unreachable)
        )
      )
    )
  )

  (func $void (type $void)
    ;; Helper function. This is reached via a call_ref.
  )

  ;; CHECK:      (func $f (type $void)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $f (type $void)
  ;; OPEN_WORLD-NEXT: )
  (func $f (type $void)
  )
)

;; The call.without.effects intrinsic reports itself as having no side effects.
;; We do still need to consider the target as being called, however, even if it
;; is in a struct field.
(module
  ;; CHECK:      (type $0 (func (param funcref) (result i32)))

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

  ;; CHECK:      (type $A (struct (field i32)))
  ;; OPEN_WORLD:      (type $0 (func (param funcref) (result i32)))

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

  ;; OPEN_WORLD:      (type $A (struct (field i32)))
  (type $A (struct (field i32)))

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

  ;; CHECK:      (import "binaryen-intrinsics" "call.without.effects" (func $call.without.effects (type $0) (param funcref) (result i32)))
  ;; OPEN_WORLD:      (type $3 (func (result i32)))

  ;; OPEN_WORLD:      (import "binaryen-intrinsics" "call.without.effects" (func $call.without.effects (type $0) (param funcref) (result i32)))
  (import "binaryen-intrinsics" "call.without.effects" (func $call.without.effects (param funcref) (result i32)))

  ;; CHECK:      (elem declare func $getter)

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

  ;; CHECK:      (func $main (type $1)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $A
  ;; CHECK-NEXT:    (call $call.without.effects
  ;; CHECK-NEXT:     (ref.func $getter)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (elem declare func $getter)

  ;; OPEN_WORLD:      (export "main" (func $main))

  ;; OPEN_WORLD:      (func $main (type $1)
  ;; OPEN_WORLD-NEXT:  (drop
  ;; OPEN_WORLD-NEXT:   (struct.new $A
  ;; OPEN_WORLD-NEXT:    (call $call.without.effects
  ;; OPEN_WORLD-NEXT:     (ref.func $getter)
  ;; OPEN_WORLD-NEXT:    )
  ;; OPEN_WORLD-NEXT:   )
  ;; OPEN_WORLD-NEXT:  )
  ;; OPEN_WORLD-NEXT: )
  (func $main (export "main")
    (drop
      (struct.new $A
        (call $call.without.effects
          (ref.func $getter)
        )
      )
    )
  )

  ;; CHECK:      (func $getter (type $3) (result i32)
  ;; CHECK-NEXT:  (i32.const 42)
  ;; CHECK-NEXT: )
  ;; OPEN_WORLD:      (func $getter (type $3) (result i32)
  ;; OPEN_WORLD-NEXT:  (i32.const 42)
  ;; OPEN_WORLD-NEXT: )
  (func $getter (result i32)
    ;; This function body should not be turned into an unreachable. It is
    ;; reached from $main, even though the call is marked as not having effects.
    (i32.const 42)
  )
)