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

;; As in monomorphize-types.wast, test in both "always" mode, which always
;; monomorphizes, and in "careful" mode which does it only when it appears to
;; actually help, and use a minimum benefit of 0 to make it easy to write
;; small testcases.

;; RUN: foreach %s %t wasm-opt --monomorphize-always                                -all -S -o - | filecheck %s --check-prefix ALWAYS
;; RUN: foreach %s %t wasm-opt --monomorphize --pass-arg=monomorphize-min-benefit@0 -all -S -o - | filecheck %s --check-prefix CAREFUL

(module
  ;; ALWAYS:      (type $0 (func (param i32) (result i32)))

  ;; ALWAYS:      (type $1 (func (param i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 anyref funcref i32 f64 i32 anyref anyref)))

  ;; ALWAYS:      (type $2 (func (param i32 i32 i32 i32 i32 i32)))

  ;; ALWAYS:      (type $struct (struct))
  (type $struct (struct))

  (memory 10 20)

  ;; ALWAYS:      (global $imm i32 (i32.const 10))
  ;; CAREFUL:      (type $0 (func (param i32) (result i32)))

  ;; CAREFUL:      (type $1 (func (param i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 anyref funcref i32 f64 i32 anyref anyref)))

  ;; CAREFUL:      (type $2 (func (param i32 i32 i32 i32 i32 i32)))

  ;; CAREFUL:      (global $imm i32 (i32.const 10))
  (global $imm i32 (i32.const 10))

  ;; ALWAYS:      (global $mut (mut i32) (i32.const 20))
  ;; CAREFUL:      (global $mut (mut i32) (i32.const 20))
  (global $mut (mut i32) (i32.const 20))

  ;; ALWAYS:      (memory $0 10 20)

  ;; ALWAYS:      (elem declare func $target)

  ;; ALWAYS:      (func $caller (type $0) (param $x i32) (result i32)
  ;; ALWAYS-NEXT:  (block $out (result i32)
  ;; ALWAYS-NEXT:   (call $target_2
  ;; ALWAYS-NEXT:    (br_if $out
  ;; ALWAYS-NEXT:     (i32.const 12)
  ;; ALWAYS-NEXT:     (i32.const 13)
  ;; ALWAYS-NEXT:    )
  ;; ALWAYS-NEXT:    (block (result i32)
  ;; ALWAYS-NEXT:     (i32.const 0)
  ;; ALWAYS-NEXT:    )
  ;; ALWAYS-NEXT:    (if (result i32)
  ;; ALWAYS-NEXT:     (i32.const 1)
  ;; ALWAYS-NEXT:     (then
  ;; ALWAYS-NEXT:      (i32.const 2)
  ;; ALWAYS-NEXT:     )
  ;; ALWAYS-NEXT:     (else
  ;; ALWAYS-NEXT:      (i32.const 3)
  ;; ALWAYS-NEXT:     )
  ;; ALWAYS-NEXT:    )
  ;; ALWAYS-NEXT:    (call $caller
  ;; ALWAYS-NEXT:     (i32.const 4)
  ;; ALWAYS-NEXT:    )
  ;; ALWAYS-NEXT:    (local.get $x)
  ;; ALWAYS-NEXT:    (local.tee $x
  ;; ALWAYS-NEXT:     (i32.const 5)
  ;; ALWAYS-NEXT:    )
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:   (i32.const 14)
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (memory $0 10 20)

  ;; CAREFUL:      (func $caller (type $0) (param $x i32) (result i32)
  ;; CAREFUL-NEXT:  (block $out (result i32)
  ;; CAREFUL-NEXT:   (call $target_2
  ;; CAREFUL-NEXT:    (br_if $out
  ;; CAREFUL-NEXT:     (i32.const 12)
  ;; CAREFUL-NEXT:     (i32.const 13)
  ;; CAREFUL-NEXT:    )
  ;; CAREFUL-NEXT:    (block (result i32)
  ;; CAREFUL-NEXT:     (i32.const 0)
  ;; CAREFUL-NEXT:    )
  ;; CAREFUL-NEXT:    (if (result i32)
  ;; CAREFUL-NEXT:     (i32.const 1)
  ;; CAREFUL-NEXT:     (then
  ;; CAREFUL-NEXT:      (i32.const 2)
  ;; CAREFUL-NEXT:     )
  ;; CAREFUL-NEXT:     (else
  ;; CAREFUL-NEXT:      (i32.const 3)
  ;; CAREFUL-NEXT:     )
  ;; CAREFUL-NEXT:    )
  ;; CAREFUL-NEXT:    (call $caller
  ;; CAREFUL-NEXT:     (i32.const 4)
  ;; CAREFUL-NEXT:    )
  ;; CAREFUL-NEXT:    (local.get $x)
  ;; CAREFUL-NEXT:    (local.tee $x
  ;; CAREFUL-NEXT:     (i32.const 5)
  ;; CAREFUL-NEXT:    )
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:   (i32.const 14)
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT: )
  (func $caller (param $x i32) (result i32)
    ;; Show the variety of things we can and cannot move into the call context.
    ;;
    ;; Note that in CAREFUL mode we only optimize here if we properly take into
    ;; account the call context in the cost. The function we are calling has
    ;; an empty body, so the monomorphized function will contain basically just
    ;; the moved code from the call context. If we didn't measure that in the
    ;; cost before monomorphization then it would seem like we went from cost 0
    ;; (empty body) to the cost of the operations that remain after we
    ;; optimize (which is the i32.load, which might trap so it remains). But if
    ;; we take into account the context, then monomorphization definitely helps
    ;; as it removes a bunch of constants.
    (block $out (result i32)
      (call $target
        ;; We can't move control flow.
        (br_if $out
          (i32.const 12)
          (i32.const 13)
        )
        ;; We can't move control flow structures.
        (block (result i32)
          (i32.const 0)
        )
        (if (result i32)
          (i32.const 1)
          (then
            (i32.const 2)
          )
          (else
            (i32.const 3)
          )
        )
        ;; We don't move calls.
        (call $caller
          (i32.const 4)
        )
        ;; We can't move local operations.
        (local.get $x)
        (local.tee $x
          (i32.const 5)
        )
        ;; We can move globals, even mutable.
        (global.get $imm)
        (global.get $mut)
        ;; We can move loads and other options that might trap.
        (i32.load
          (i32.const 6)
        )
        ;; We can move constants.
        (i32.const 7)
        (ref.null any)
        (ref.func $target)
        ;; We can move math operations.
        (i32.eqz
          (i32.const 8)
        )
        (f64.add
          (f64.const 2.71828)
          (f64.const 3.14159)
        )
        ;; We can move selects.
        (select
          (i32.const 9)
          (i32.const 10)
          (i32.const 11)
        )
        ;; We can move GC operations.
        (ref.cast (ref null none)
          (ref.null none)
        )
        (struct.new $struct)
      )
      (i32.const 14)
    )
  )

  ;; ALWAYS:      (func $target (type $1) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) (param $5 i32) (param $6 i32) (param $7 i32) (param $8 i32) (param $9 i32) (param $10 anyref) (param $11 funcref) (param $12 i32) (param $13 f64) (param $14 i32) (param $15 anyref) (param $16 anyref)
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $target (type $1) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) (param $5 i32) (param $6 i32) (param $7 i32) (param $8 i32) (param $9 i32) (param $10 anyref) (param $11 funcref) (param $12 i32) (param $13 f64) (param $14 i32) (param $15 anyref) (param $16 anyref)
  ;; CAREFUL-NEXT:  (nop)
  ;; CAREFUL-NEXT: )
  (func $target
    (param i32)
    (param i32)
    (param i32)
    (param i32)
    (param i32)
    (param i32)
    (param i32)
    (param i32)
    (param i32)
    (param i32)
    (param anyref)
    (param funcref)
    (param i32)
    (param f64)
    (param i32)
    (param anyref)
    (param anyref)
  )
)

;; ALWAYS:      (func $target_2 (type $2) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) (param $5 i32)
;; ALWAYS-NEXT:  (local $6 i32)
;; ALWAYS-NEXT:  (local $7 i32)
;; ALWAYS-NEXT:  (local $8 i32)
;; ALWAYS-NEXT:  (local $9 i32)
;; ALWAYS-NEXT:  (local $10 i32)
;; ALWAYS-NEXT:  (local $11 i32)
;; ALWAYS-NEXT:  (local $12 i32)
;; ALWAYS-NEXT:  (local $13 i32)
;; ALWAYS-NEXT:  (local $14 i32)
;; ALWAYS-NEXT:  (local $15 i32)
;; ALWAYS-NEXT:  (local $16 anyref)
;; ALWAYS-NEXT:  (local $17 funcref)
;; ALWAYS-NEXT:  (local $18 i32)
;; ALWAYS-NEXT:  (local $19 f64)
;; ALWAYS-NEXT:  (local $20 i32)
;; ALWAYS-NEXT:  (local $21 anyref)
;; ALWAYS-NEXT:  (local $22 anyref)
;; ALWAYS-NEXT:  (local.set $6
;; ALWAYS-NEXT:   (local.get $0)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (local.set $7
;; ALWAYS-NEXT:   (local.get $1)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (local.set $8
;; ALWAYS-NEXT:   (local.get $2)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (local.set $9
;; ALWAYS-NEXT:   (local.get $3)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (local.set $10
;; ALWAYS-NEXT:   (local.get $4)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (local.set $11
;; ALWAYS-NEXT:   (local.get $5)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (local.set $12
;; ALWAYS-NEXT:   (global.get $imm)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (local.set $13
;; ALWAYS-NEXT:   (global.get $mut)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (local.set $14
;; ALWAYS-NEXT:   (i32.load
;; ALWAYS-NEXT:    (i32.const 6)
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (local.set $15
;; ALWAYS-NEXT:   (i32.const 7)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (local.set $16
;; ALWAYS-NEXT:   (ref.null none)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (local.set $17
;; ALWAYS-NEXT:   (ref.func $target)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (local.set $18
;; ALWAYS-NEXT:   (i32.eqz
;; ALWAYS-NEXT:    (i32.const 8)
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (local.set $19
;; ALWAYS-NEXT:   (f64.add
;; ALWAYS-NEXT:    (f64.const 2.71828)
;; ALWAYS-NEXT:    (f64.const 3.14159)
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (local.set $20
;; ALWAYS-NEXT:   (select
;; ALWAYS-NEXT:    (i32.const 9)
;; ALWAYS-NEXT:    (i32.const 10)
;; ALWAYS-NEXT:    (i32.const 11)
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (local.set $21
;; ALWAYS-NEXT:   (ref.cast nullref
;; ALWAYS-NEXT:    (ref.null none)
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (local.set $22
;; ALWAYS-NEXT:   (struct.new_default $struct)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (block
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT: )

;; CAREFUL:      (func $target_2 (type $2) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) (param $5 i32)
;; CAREFUL-NEXT:  (drop
;; CAREFUL-NEXT:   (i32.load
;; CAREFUL-NEXT:    (i32.const 6)
;; CAREFUL-NEXT:   )
;; CAREFUL-NEXT:  )
;; CAREFUL-NEXT: )
(module
  ;; ALWAYS:      (type $0 (func (param i32) (result i32)))

  ;; ALWAYS:      (type $1 (func (param i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 anyref funcref i32 f64 i32 anyref anyref) (result i32)))

  ;; ALWAYS:      (type $2 (func (param i32 i32 i32 i32 i32 i32)))

  ;; ALWAYS:      (type $struct (struct))
  (type $struct (struct))

  (memory 10 20)

  ;; ALWAYS:      (global $imm i32 (i32.const 10))
  ;; CAREFUL:      (type $0 (func (param i32) (result i32)))

  ;; CAREFUL:      (type $1 (func (param i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 anyref funcref i32 f64 i32 anyref anyref) (result i32)))

  ;; CAREFUL:      (type $2 (func (param i32 i32 i32 i32 i32 i32)))

  ;; CAREFUL:      (global $imm i32 (i32.const 10))
  (global $imm i32 (i32.const 10))

  ;; ALWAYS:      (global $mut (mut i32) (i32.const 20))
  ;; CAREFUL:      (global $mut (mut i32) (i32.const 20))
  (global $mut (mut i32) (i32.const 20))

  ;; ALWAYS:      (memory $0 10 20)

  ;; ALWAYS:      (elem declare func $target)

  ;; ALWAYS:      (func $caller (type $0) (param $x i32) (result i32)
  ;; ALWAYS-NEXT:  (block $out (result i32)
  ;; ALWAYS-NEXT:   (call $target_2
  ;; ALWAYS-NEXT:    (br_if $out
  ;; ALWAYS-NEXT:     (i32.const 12)
  ;; ALWAYS-NEXT:     (i32.const 13)
  ;; ALWAYS-NEXT:    )
  ;; ALWAYS-NEXT:    (block (result i32)
  ;; ALWAYS-NEXT:     (i32.const 0)
  ;; ALWAYS-NEXT:    )
  ;; ALWAYS-NEXT:    (if (result i32)
  ;; ALWAYS-NEXT:     (i32.const 1)
  ;; ALWAYS-NEXT:     (then
  ;; ALWAYS-NEXT:      (i32.const 2)
  ;; ALWAYS-NEXT:     )
  ;; ALWAYS-NEXT:     (else
  ;; ALWAYS-NEXT:      (i32.const 3)
  ;; ALWAYS-NEXT:     )
  ;; ALWAYS-NEXT:    )
  ;; ALWAYS-NEXT:    (call $caller
  ;; ALWAYS-NEXT:     (i32.const 4)
  ;; ALWAYS-NEXT:    )
  ;; ALWAYS-NEXT:    (local.get $x)
  ;; ALWAYS-NEXT:    (local.tee $x
  ;; ALWAYS-NEXT:     (i32.const 5)
  ;; ALWAYS-NEXT:    )
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:   (i32.const 14)
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (memory $0 10 20)

  ;; CAREFUL:      (func $caller (type $0) (param $x i32) (result i32)
  ;; CAREFUL-NEXT:  (block $out (result i32)
  ;; CAREFUL-NEXT:   (call $target_2
  ;; CAREFUL-NEXT:    (br_if $out
  ;; CAREFUL-NEXT:     (i32.const 12)
  ;; CAREFUL-NEXT:     (i32.const 13)
  ;; CAREFUL-NEXT:    )
  ;; CAREFUL-NEXT:    (block (result i32)
  ;; CAREFUL-NEXT:     (i32.const 0)
  ;; CAREFUL-NEXT:    )
  ;; CAREFUL-NEXT:    (if (result i32)
  ;; CAREFUL-NEXT:     (i32.const 1)
  ;; CAREFUL-NEXT:     (then
  ;; CAREFUL-NEXT:      (i32.const 2)
  ;; CAREFUL-NEXT:     )
  ;; CAREFUL-NEXT:     (else
  ;; CAREFUL-NEXT:      (i32.const 3)
  ;; CAREFUL-NEXT:     )
  ;; CAREFUL-NEXT:    )
  ;; CAREFUL-NEXT:    (call $caller
  ;; CAREFUL-NEXT:     (i32.const 4)
  ;; CAREFUL-NEXT:    )
  ;; CAREFUL-NEXT:    (local.get $x)
  ;; CAREFUL-NEXT:    (local.tee $x
  ;; CAREFUL-NEXT:     (i32.const 5)
  ;; CAREFUL-NEXT:    )
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:   (i32.const 14)
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT: )
  (func $caller (param $x i32) (result i32)
    ;; As above, but now the call is dropped, so the context can include the
    ;; drop.
    (block $out (result i32)
      (drop
        (call $target
          (br_if $out
            (i32.const 12)
            (i32.const 13)
          )
          (block (result i32)
            (i32.const 0)
          )
          (if (result i32)
            (i32.const 1)
            (then
              (i32.const 2)
            )
            (else
              (i32.const 3)
            )
          )
          (call $caller
            (i32.const 4)
          )
          (local.get $x)
          (local.tee $x
            (i32.const 5)
          )
          (global.get $imm)
          (global.get $mut)
          (i32.load
            (i32.const 6)
          )
          (i32.const 7)
          (ref.null any)
          (ref.func $target)
          (i32.eqz
            (i32.const 8)
          )
          (f64.add
            (f64.const 2.71828)
            (f64.const 3.14159)
          )
          (select
            (i32.const 9)
            (i32.const 10)
            (i32.const 11)
          )
          (ref.cast (ref null none)
            (ref.null none)
          )
          (struct.new $struct)
        )
      )
      (i32.const 14)
    )
  )

  ;; ALWAYS:      (func $target (type $1) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) (param $5 i32) (param $6 i32) (param $7 i32) (param $8 i32) (param $9 i32) (param $10 anyref) (param $11 funcref) (param $12 i32) (param $13 f64) (param $14 i32) (param $15 anyref) (param $16 anyref) (result i32)
  ;; ALWAYS-NEXT:  (local.get $7)
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $target (type $1) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) (param $5 i32) (param $6 i32) (param $7 i32) (param $8 i32) (param $9 i32) (param $10 anyref) (param $11 funcref) (param $12 i32) (param $13 f64) (param $14 i32) (param $15 anyref) (param $16 anyref) (result i32)
  ;; CAREFUL-NEXT:  (local.get $7)
  ;; CAREFUL-NEXT: )
  (func $target
    (param i32)
    (param i32)
    (param i32)
    (param i32)
    (param i32)
    (param i32)
    (param i32)
    (param i32)
    (param i32)
    (param i32)
    (param anyref)
    (param funcref)
    (param i32)
    (param f64)
    (param i32)
    (param anyref)
    (param anyref)
    (result i32)
    (local.get 7)
  )
)




;; ALWAYS:      (func $target_2 (type $2) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) (param $5 i32)
;; ALWAYS-NEXT:  (local $6 i32)
;; ALWAYS-NEXT:  (local $7 i32)
;; ALWAYS-NEXT:  (local $8 i32)
;; ALWAYS-NEXT:  (local $9 i32)
;; ALWAYS-NEXT:  (local $10 i32)
;; ALWAYS-NEXT:  (local $11 i32)
;; ALWAYS-NEXT:  (local $12 i32)
;; ALWAYS-NEXT:  (local $13 i32)
;; ALWAYS-NEXT:  (local $14 i32)
;; ALWAYS-NEXT:  (local $15 i32)
;; ALWAYS-NEXT:  (local $16 anyref)
;; ALWAYS-NEXT:  (local $17 funcref)
;; ALWAYS-NEXT:  (local $18 i32)
;; ALWAYS-NEXT:  (local $19 f64)
;; ALWAYS-NEXT:  (local $20 i32)
;; ALWAYS-NEXT:  (local $21 anyref)
;; ALWAYS-NEXT:  (local $22 anyref)
;; ALWAYS-NEXT:  (drop
;; ALWAYS-NEXT:   (block (result i32)
;; ALWAYS-NEXT:    (local.set $6
;; ALWAYS-NEXT:     (local.get $0)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (local.set $7
;; ALWAYS-NEXT:     (local.get $1)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (local.set $8
;; ALWAYS-NEXT:     (local.get $2)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (local.set $9
;; ALWAYS-NEXT:     (local.get $3)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (local.set $10
;; ALWAYS-NEXT:     (local.get $4)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (local.set $11
;; ALWAYS-NEXT:     (local.get $5)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (local.set $12
;; ALWAYS-NEXT:     (global.get $imm)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (local.set $13
;; ALWAYS-NEXT:     (global.get $mut)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (local.set $14
;; ALWAYS-NEXT:     (i32.load
;; ALWAYS-NEXT:      (i32.const 6)
;; ALWAYS-NEXT:     )
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (local.set $15
;; ALWAYS-NEXT:     (i32.const 7)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (local.set $16
;; ALWAYS-NEXT:     (ref.null none)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (local.set $17
;; ALWAYS-NEXT:     (ref.func $target)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (local.set $18
;; ALWAYS-NEXT:     (i32.eqz
;; ALWAYS-NEXT:      (i32.const 8)
;; ALWAYS-NEXT:     )
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (local.set $19
;; ALWAYS-NEXT:     (f64.add
;; ALWAYS-NEXT:      (f64.const 2.71828)
;; ALWAYS-NEXT:      (f64.const 3.14159)
;; ALWAYS-NEXT:     )
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (local.set $20
;; ALWAYS-NEXT:     (select
;; ALWAYS-NEXT:      (i32.const 9)
;; ALWAYS-NEXT:      (i32.const 10)
;; ALWAYS-NEXT:      (i32.const 11)
;; ALWAYS-NEXT:     )
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (local.set $21
;; ALWAYS-NEXT:     (ref.cast nullref
;; ALWAYS-NEXT:      (ref.null none)
;; ALWAYS-NEXT:     )
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (local.set $22
;; ALWAYS-NEXT:     (struct.new_default $struct)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (local.get $13)
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT: )

;; CAREFUL:      (func $target_2 (type $2) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) (param $5 i32)
;; CAREFUL-NEXT:  (drop
;; CAREFUL-NEXT:   (i32.load
;; CAREFUL-NEXT:    (i32.const 6)
;; CAREFUL-NEXT:   )
;; CAREFUL-NEXT:  )
;; CAREFUL-NEXT: )
(module
  (memory 10 20)

  ;; ALWAYS:      (type $0 (func))

  ;; ALWAYS:      (type $1 (func (param f32)))

  ;; ALWAYS:      (type $2 (func (param f64)))

  ;; ALWAYS:      (memory $0 10 20)

  ;; ALWAYS:      (func $caller (type $0)
  ;; ALWAYS-NEXT:  (call $target_2
  ;; ALWAYS-NEXT:   (block $label$1 (result f64)
  ;; ALWAYS-NEXT:    (f64.const 0)
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT:  (call $target_3)
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (type $0 (func))

  ;; CAREFUL:      (type $1 (func (param f32)))

  ;; CAREFUL:      (memory $0 10 20)

  ;; CAREFUL:      (func $caller (type $0)
  ;; CAREFUL-NEXT:  (call $target
  ;; CAREFUL-NEXT:   (f32.demote_f64
  ;; CAREFUL-NEXT:    (block $label$1 (result f64)
  ;; CAREFUL-NEXT:     (f64.const 0)
  ;; CAREFUL-NEXT:    )
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT:  (call $target_2)
  ;; CAREFUL-NEXT: )
  (func $caller
    ;; Nesting: the f32.demote_f64 operation can be moved into the context, but
    ;; its child cannot, so we stop there. (In CAREFUL mode, we end up doing
    ;; nothing here, as the benefit of monomorphization is not worth it.)
    (call $target
      (f32.demote_f64
        (block $label$1 (result f64)
          (f64.const 0)
        )
      )
    )

    ;; Now the child is an f64.abs, which can be moved into the context, so it
    ;; all is moved. This ends up worthwhile in CAREFUL mode (since we can
    ;; optimize all the math here).
    (call $target
      (f32.demote_f64
        (f64.abs         ;; this changed
          (f64.const 0)
        )
      )
    )
  )

  ;; ALWAYS:      (func $target (type $1) (param $f32 f32)
  ;; ALWAYS-NEXT:  (f32.store
  ;; ALWAYS-NEXT:   (i32.const 42)
  ;; ALWAYS-NEXT:   (local.get $f32)
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $target (type $1) (param $0 f32)
  ;; CAREFUL-NEXT:  (f32.store
  ;; CAREFUL-NEXT:   (i32.const 42)
  ;; CAREFUL-NEXT:   (local.get $0)
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT: )
  (func $target (param $f32 f32)
    ;; When monomorphized the first time, the param here will be f64 and not
    ;; i32, showing we handle a type change.
    ;;
    ;; When monomorphized the second time, the param will go away entirely.
    (f32.store
      (i32.const 42)
      (local.get $f32)
    )
  )
)


;; ALWAYS:      (func $target_2 (type $2) (param $0 f64)
;; ALWAYS-NEXT:  (local $f32 f32)
;; ALWAYS-NEXT:  (local.set $f32
;; ALWAYS-NEXT:   (f32.demote_f64
;; ALWAYS-NEXT:    (local.get $0)
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (f32.store
;; ALWAYS-NEXT:   (i32.const 42)
;; ALWAYS-NEXT:   (local.get $f32)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT: )

;; ALWAYS:      (func $target_3 (type $0)
;; ALWAYS-NEXT:  (local $f32 f32)
;; ALWAYS-NEXT:  (local.set $f32
;; ALWAYS-NEXT:   (f32.demote_f64
;; ALWAYS-NEXT:    (f64.abs
;; ALWAYS-NEXT:     (f64.const 0)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (f32.store
;; ALWAYS-NEXT:   (i32.const 42)
;; ALWAYS-NEXT:   (local.get $f32)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT: )

;; CAREFUL:      (func $target_2 (type $0)
;; CAREFUL-NEXT:  (f32.store
;; CAREFUL-NEXT:   (i32.const 42)
;; CAREFUL-NEXT:   (f32.const 0)
;; CAREFUL-NEXT:  )
;; CAREFUL-NEXT: )
(module
  ;; ALWAYS:      (type $struct (struct (field (mut f32)) (field (mut f64))))
  ;; CAREFUL:      (type $struct (struct (field (mut f32)) (field (mut f64))))
  (type $struct (struct (field (mut f32)) (field (mut f64))))

  ;; ALWAYS:      (type $1 (func (param f32) (result anyref)))

  ;; ALWAYS:      (type $2 (func (param f64) (result anyref)))

  ;; ALWAYS:      (type $3 (func (param f64)))

  ;; ALWAYS:      (type $4 (func (param (ref $struct)) (result anyref)))

  ;; ALWAYS:      (func $caller (type $1) (param $x f32) (result anyref)
  ;; ALWAYS-NEXT:  (call $target_4
  ;; ALWAYS-NEXT:   (local.get $x)
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (type $1 (func (param f64)))

  ;; CAREFUL:      (type $2 (func (param f32) (result anyref)))

  ;; CAREFUL:      (type $3 (func (param f64) (result anyref)))

  ;; CAREFUL:      (type $4 (func (param (ref $struct)) (result anyref)))

  ;; CAREFUL:      (func $caller (type $2) (param $x f32) (result anyref)
  ;; CAREFUL-NEXT:  (call $target
  ;; CAREFUL-NEXT:   (struct.new $struct
  ;; CAREFUL-NEXT:    (local.get $x)
  ;; CAREFUL-NEXT:    (f64.const 4.2)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT: )
  (func $caller (param $x f32) (result anyref)
    ;; We can reverse-inline the struct.new and the nested constant, leaving
    ;; only the local.get as a remaining param. (In CAREFUL mode, however, this
    ;; does not look promising enough to optimize.)
    (call $target
      (struct.new $struct
        (local.get $x)
        (f64.const 4.2)
      )
    )
  )

  ;; ALWAYS:      (func $caller-flip (type $2) (param $x f64) (result anyref)
  ;; ALWAYS-NEXT:  (call $target_5
  ;; ALWAYS-NEXT:   (local.get $x)
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $caller-flip (type $3) (param $x f64) (result anyref)
  ;; CAREFUL-NEXT:  (call $target
  ;; CAREFUL-NEXT:   (struct.new $struct
  ;; CAREFUL-NEXT:    (f32.const 13.369999885559082)
  ;; CAREFUL-NEXT:    (local.get $x)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT: )
  (func $caller-flip (param $x f64) (result anyref)
    ;; As above, but with struct.new's children flipped (which does not change
    ;; anything).
    (call $target
      (struct.new $struct
        (f32.const 13.37)
        (local.get $x)
      )
    )
  )

  ;; ALWAYS:      (func $dropped-caller (type $3) (param $x f64)
  ;; ALWAYS-NEXT:  (call $target_6
  ;; ALWAYS-NEXT:   (local.get $x)
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $dropped-caller (type $1) (param $x f64)
  ;; CAREFUL-NEXT:  (call $target_4
  ;; CAREFUL-NEXT:   (local.get $x)
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT: )
  (func $dropped-caller (param $x f64)
    ;; As above, but the outcome is dropped. As the target function only does
    ;; some struct.sets, escape analysis after monomorphization can prove that
    ;; we can remove all the code, so this is optimized in CAREFUL mode.
    (drop
      (call $target
        (struct.new $struct
          (f32.const 13.37)
          (local.get $x)
        )
      )
    )
  )

  ;; ALWAYS:      (func $target (type $4) (param $ref (ref $struct)) (result anyref)
  ;; ALWAYS-NEXT:  (struct.set $struct 0
  ;; ALWAYS-NEXT:   (local.get $ref)
  ;; ALWAYS-NEXT:   (f32.add
  ;; ALWAYS-NEXT:    (struct.get $struct 0
  ;; ALWAYS-NEXT:     (local.get $ref)
  ;; ALWAYS-NEXT:    )
  ;; ALWAYS-NEXT:    (f32.const 1.100000023841858)
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT:  (struct.set $struct 1
  ;; ALWAYS-NEXT:   (local.get $ref)
  ;; ALWAYS-NEXT:   (f64.max
  ;; ALWAYS-NEXT:    (struct.get $struct 1
  ;; ALWAYS-NEXT:     (local.get $ref)
  ;; ALWAYS-NEXT:    )
  ;; ALWAYS-NEXT:    (f64.const -1.2)
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT:  (local.get $ref)
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $target (type $4) (param $0 (ref $struct)) (result anyref)
  ;; CAREFUL-NEXT:  (struct.set $struct 0
  ;; CAREFUL-NEXT:   (local.get $0)
  ;; CAREFUL-NEXT:   (f32.add
  ;; CAREFUL-NEXT:    (struct.get $struct 0
  ;; CAREFUL-NEXT:     (local.get $0)
  ;; CAREFUL-NEXT:    )
  ;; CAREFUL-NEXT:    (f32.const 1.100000023841858)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT:  (struct.set $struct 1
  ;; CAREFUL-NEXT:   (local.get $0)
  ;; CAREFUL-NEXT:   (f64.max
  ;; CAREFUL-NEXT:    (struct.get $struct 1
  ;; CAREFUL-NEXT:     (local.get $0)
  ;; CAREFUL-NEXT:    )
  ;; CAREFUL-NEXT:    (f64.const -1.2)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT:  (local.get $0)
  ;; CAREFUL-NEXT: )
  (func $target (param $ref (ref $struct)) (result anyref)
    ;; Do some operations on the reference, but do not escape it.
    (struct.set $struct 0
      (local.get $ref)
      (f32.add
        (struct.get $struct 0
          (local.get $ref)
        )
        (f32.const 1.1)
      )
    )
    (struct.set $struct 1
      (local.get $ref)
      (f64.max
        (struct.get $struct 1
          (local.get $ref)
        )
        (f64.const -1.2)
      )
    )
    (local.get $ref)
  )
)

;; ALWAYS:      (func $target_4 (type $1) (param $0 f32) (result anyref)
;; ALWAYS-NEXT:  (local $ref (ref $struct))
;; ALWAYS-NEXT:  (local.set $ref
;; ALWAYS-NEXT:   (struct.new $struct
;; ALWAYS-NEXT:    (local.get $0)
;; ALWAYS-NEXT:    (f64.const 4.2)
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (block (result anyref)
;; ALWAYS-NEXT:   (struct.set $struct 0
;; ALWAYS-NEXT:    (local.get $ref)
;; ALWAYS-NEXT:    (f32.add
;; ALWAYS-NEXT:     (struct.get $struct 0
;; ALWAYS-NEXT:      (local.get $ref)
;; ALWAYS-NEXT:     )
;; ALWAYS-NEXT:     (f32.const 1.100000023841858)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:   (struct.set $struct 1
;; ALWAYS-NEXT:    (local.get $ref)
;; ALWAYS-NEXT:    (f64.max
;; ALWAYS-NEXT:     (struct.get $struct 1
;; ALWAYS-NEXT:      (local.get $ref)
;; ALWAYS-NEXT:     )
;; ALWAYS-NEXT:     (f64.const -1.2)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:   (local.get $ref)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT: )

;; ALWAYS:      (func $target_5 (type $2) (param $0 f64) (result anyref)
;; ALWAYS-NEXT:  (local $ref (ref $struct))
;; ALWAYS-NEXT:  (local.set $ref
;; ALWAYS-NEXT:   (struct.new $struct
;; ALWAYS-NEXT:    (f32.const 13.369999885559082)
;; ALWAYS-NEXT:    (local.get $0)
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (block (result anyref)
;; ALWAYS-NEXT:   (struct.set $struct 0
;; ALWAYS-NEXT:    (local.get $ref)
;; ALWAYS-NEXT:    (f32.add
;; ALWAYS-NEXT:     (struct.get $struct 0
;; ALWAYS-NEXT:      (local.get $ref)
;; ALWAYS-NEXT:     )
;; ALWAYS-NEXT:     (f32.const 1.100000023841858)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:   (struct.set $struct 1
;; ALWAYS-NEXT:    (local.get $ref)
;; ALWAYS-NEXT:    (f64.max
;; ALWAYS-NEXT:     (struct.get $struct 1
;; ALWAYS-NEXT:      (local.get $ref)
;; ALWAYS-NEXT:     )
;; ALWAYS-NEXT:     (f64.const -1.2)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:   (local.get $ref)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT: )

;; ALWAYS:      (func $target_6 (type $3) (param $0 f64)
;; ALWAYS-NEXT:  (local $ref (ref $struct))
;; ALWAYS-NEXT:  (drop
;; ALWAYS-NEXT:   (block (result anyref)
;; ALWAYS-NEXT:    (local.set $ref
;; ALWAYS-NEXT:     (struct.new $struct
;; ALWAYS-NEXT:      (f32.const 13.369999885559082)
;; ALWAYS-NEXT:      (local.get $0)
;; ALWAYS-NEXT:     )
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (block (result anyref)
;; ALWAYS-NEXT:     (struct.set $struct 0
;; ALWAYS-NEXT:      (local.get $ref)
;; ALWAYS-NEXT:      (f32.add
;; ALWAYS-NEXT:       (struct.get $struct 0
;; ALWAYS-NEXT:        (local.get $ref)
;; ALWAYS-NEXT:       )
;; ALWAYS-NEXT:       (f32.const 1.100000023841858)
;; ALWAYS-NEXT:      )
;; ALWAYS-NEXT:     )
;; ALWAYS-NEXT:     (struct.set $struct 1
;; ALWAYS-NEXT:      (local.get $ref)
;; ALWAYS-NEXT:      (f64.max
;; ALWAYS-NEXT:       (struct.get $struct 1
;; ALWAYS-NEXT:        (local.get $ref)
;; ALWAYS-NEXT:       )
;; ALWAYS-NEXT:       (f64.const -1.2)
;; ALWAYS-NEXT:      )
;; ALWAYS-NEXT:     )
;; ALWAYS-NEXT:     (local.get $ref)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT: )

;; CAREFUL:      (func $target_4 (type $1) (param $0 f64)
;; CAREFUL-NEXT:  (nop)
;; CAREFUL-NEXT: )
(module
  ;; ALWAYS:      (type $struct (struct (field i16) (field (mut i8)) (field (mut f64))))
  ;; CAREFUL:      (type $struct (struct (field i16) (field (mut i8)) (field (mut f64))))
  (type $struct (struct (field i16) (field (mut i8)) (field (mut f64))))

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

  ;; ALWAYS:      (type $2 (func (param (ref $struct))))

  ;; ALWAYS:      (type $3 (func (param i32 f64)))

  ;; ALWAYS:      (func $caller (type $1)
  ;; ALWAYS-NEXT:  (local $i32 i32)
  ;; ALWAYS-NEXT:  (local $f64 f64)
  ;; ALWAYS-NEXT:  (call $target_2
  ;; ALWAYS-NEXT:   (local.get $i32)
  ;; ALWAYS-NEXT:   (local.get $f64)
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (type $1 (func))

  ;; CAREFUL:      (type $2 (func (param (ref $struct))))

  ;; CAREFUL:      (type $3 (func (param i32 f64)))

  ;; CAREFUL:      (func $caller (type $1)
  ;; CAREFUL-NEXT:  (local $i32 i32)
  ;; CAREFUL-NEXT:  (local $f64 f64)
  ;; CAREFUL-NEXT:  (call $target_2
  ;; CAREFUL-NEXT:   (local.get $i32)
  ;; CAREFUL-NEXT:   (local.get $f64)
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT: )
  (func $caller
    (local $i32 i32)
    (local $f64 f64)
    ;; The first operand can be moved to the context, but not the other two. Of
    ;; those two, the order of iteration matters, as they have different types
    ;; (if we got mixed up and reordered them, we'd error).
    (call $target
      (struct.new $struct
        (i32.const 0)
        (local.get $i32)
        (local.get $f64)
      )
    )
  )

  ;; ALWAYS:      (func $target (type $2) (param $0 (ref $struct))
  ;; ALWAYS-NEXT:  (nop)
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $target (type $2) (param $0 (ref $struct))
  ;; CAREFUL-NEXT:  (nop)
  ;; CAREFUL-NEXT: )
  (func $target (param (ref $struct))
    (nop)
  )
)

;; ALWAYS:      (func $target_2 (type $3) (param $0 i32) (param $1 f64)
;; ALWAYS-NEXT:  (local $2 (ref $struct))
;; ALWAYS-NEXT:  (local.set $2
;; ALWAYS-NEXT:   (struct.new $struct
;; ALWAYS-NEXT:    (i32.const 0)
;; ALWAYS-NEXT:    (local.get $0)
;; ALWAYS-NEXT:    (local.get $1)
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (nop)
;; ALWAYS-NEXT: )

;; CAREFUL:      (func $target_2 (type $3) (param $0 i32) (param $1 f64)
;; CAREFUL-NEXT:  (nop)
;; CAREFUL-NEXT: )
(module
  ;; ALWAYS:      (type $array (sub (array (mut i8))))
  (type $array (sub (array (mut i8))))

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

  ;; ALWAYS:      (type $2 (func (param i32)))

  ;; ALWAYS:      (type $3 (func (param anyref anyref) (result i32)))

  ;; ALWAYS:      (type $4 (func (param i32 i32 i32)))

  ;; ALWAYS:      (func $caller (type $1)
  ;; ALWAYS-NEXT:  (call $target_3)
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (type $0 (func))

  ;; CAREFUL:      (type $1 (func (param i32)))

  ;; CAREFUL:      (type $2 (func (param anyref anyref) (result i32)))

  ;; CAREFUL:      (type $3 (func (param i32 i32 i32)))

  ;; CAREFUL:      (func $caller (type $0)
  ;; CAREFUL-NEXT:  (call $target_3)
  ;; CAREFUL-NEXT: )
  (func $caller
    ;; Call the target with array.new which has an optional child, the initial
    ;; value. Set it in one and leave it as nullptr in the other to see we
    ;; handle both properly when we move the array.new + children into the
    ;; monomorphized function.
    (drop
      (call $target
        (array.new_default $array
          (i32.const 1)
        )
        (array.new $array
          (i32.const 2)
          (i32.const 3)
        )
      )
    )
  )

  ;; ALWAYS:      (func $caller-unknown (type $2) (param $x i32)
  ;; ALWAYS-NEXT:  (call $target_4
  ;; ALWAYS-NEXT:   (local.get $x)
  ;; ALWAYS-NEXT:   (local.get $x)
  ;; ALWAYS-NEXT:   (local.get $x)
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $caller-unknown (type $1) (param $x i32)
  ;; CAREFUL-NEXT:  (call $target_4
  ;; CAREFUL-NEXT:   (local.get $x)
  ;; CAREFUL-NEXT:   (local.get $x)
  ;; CAREFUL-NEXT:   (local.get $x)
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT: )
  (func $caller-unknown (param $x i32)
    ;; As above, but now there are unknown children, which are not moved.
    (drop
      (call $target
        (array.new_default $array
          (local.get $x)
        )
        (array.new $array
          (local.get $x)
          (local.get $x)
        )
      )
    )
  )

  ;; ALWAYS:      (func $target (type $3) (param $0 anyref) (param $1 anyref) (result i32)
  ;; ALWAYS-NEXT:  (unreachable)
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $target (type $2) (param $0 anyref) (param $1 anyref) (result i32)
  ;; CAREFUL-NEXT:  (unreachable)
  ;; CAREFUL-NEXT: )
  (func $target (param anyref) (param anyref) (result i32)
    (unreachable)
  )
)


;; ALWAYS:      (func $target_3 (type $1)
;; ALWAYS-NEXT:  (local $0 anyref)
;; ALWAYS-NEXT:  (local $1 anyref)
;; ALWAYS-NEXT:  (local.set $0
;; ALWAYS-NEXT:   (array.new_default $array
;; ALWAYS-NEXT:    (i32.const 1)
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (local.set $1
;; ALWAYS-NEXT:   (array.new $array
;; ALWAYS-NEXT:    (i32.const 2)
;; ALWAYS-NEXT:    (i32.const 3)
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (unreachable)
;; ALWAYS-NEXT: )

;; ALWAYS:      (func $target_4 (type $4) (param $0 i32) (param $1 i32) (param $2 i32)
;; ALWAYS-NEXT:  (local $3 anyref)
;; ALWAYS-NEXT:  (local $4 anyref)
;; ALWAYS-NEXT:  (local.set $3
;; ALWAYS-NEXT:   (array.new_default $array
;; ALWAYS-NEXT:    (local.get $0)
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (local.set $4
;; ALWAYS-NEXT:   (array.new $array
;; ALWAYS-NEXT:    (local.get $1)
;; ALWAYS-NEXT:    (local.get $2)
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (unreachable)
;; ALWAYS-NEXT: )

;; CAREFUL:      (func $target_3 (type $0)
;; CAREFUL-NEXT:  (unreachable)
;; CAREFUL-NEXT: )

;; CAREFUL:      (func $target_4 (type $3) (param $0 i32) (param $1 i32) (param $2 i32)
;; CAREFUL-NEXT:  (unreachable)
;; CAREFUL-NEXT: )
(module
  ;; ALWAYS:      (type $struct (struct (field anyref)))
  (type $struct (struct (field anyref)))

  ;; ALWAYS:      (type $1 (func (param anyref) (result anyref)))

  ;; ALWAYS:      (func $caller (type $1) (param $x anyref) (result anyref)
  ;; ALWAYS-NEXT:  (call $target_2
  ;; ALWAYS-NEXT:   (local.get $x)
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (type $0 (func (param anyref) (result anyref)))

  ;; CAREFUL:      (func $caller (type $0) (param $x anyref) (result anyref)
  ;; CAREFUL-NEXT:  (call $target_2
  ;; CAREFUL-NEXT:   (local.get $x)
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT: )
  (func $caller (param $x anyref) (result anyref)
    ;; A call with a deeply nested param. We can move all of it but the
    ;; local.get into the monomorphized function.
    (call $target
      (struct.new $struct
        (struct.new $struct
          (struct.new $struct
            (struct.new $struct
              (struct.new $struct
                (struct.new $struct
                  (local.get $x)
                )
              )
            )
          )
        )
      )
    )
  )

  ;; ALWAYS:      (func $target (type $1) (param $0 anyref) (result anyref)
  ;; ALWAYS-NEXT:  (unreachable)
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $target (type $0) (param $0 anyref) (result anyref)
  ;; CAREFUL-NEXT:  (unreachable)
  ;; CAREFUL-NEXT: )
  (func $target (param anyref) (result anyref)
    (unreachable)
  )
)

;; ALWAYS:      (func $target_2 (type $1) (param $0 anyref) (result anyref)
;; ALWAYS-NEXT:  (local $1 anyref)
;; ALWAYS-NEXT:  (local.set $1
;; ALWAYS-NEXT:   (struct.new $struct
;; ALWAYS-NEXT:    (struct.new $struct
;; ALWAYS-NEXT:     (struct.new $struct
;; ALWAYS-NEXT:      (struct.new $struct
;; ALWAYS-NEXT:       (struct.new $struct
;; ALWAYS-NEXT:        (struct.new $struct
;; ALWAYS-NEXT:         (local.get $0)
;; ALWAYS-NEXT:        )
;; ALWAYS-NEXT:       )
;; ALWAYS-NEXT:      )
;; ALWAYS-NEXT:     )
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (unreachable)
;; ALWAYS-NEXT: )

;; CAREFUL:      (func $target_2 (type $0) (param $0 anyref) (result anyref)
;; CAREFUL-NEXT:  (unreachable)
;; CAREFUL-NEXT: )
(module
  (memory 10 20)

  ;; ALWAYS:      (type $0 (func))

  ;; ALWAYS:      (type $1 (func (param i32 i32)))

  ;; ALWAYS:      (type $2 (func (param i32)))

  ;; ALWAYS:      (memory $0 10 20)

  ;; ALWAYS:      (func $caller (type $0)
  ;; ALWAYS-NEXT:  (call $target
  ;; ALWAYS-NEXT:   (i32.load
  ;; ALWAYS-NEXT:    (i32.const 0)
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:   (block (result i32)
  ;; ALWAYS-NEXT:    (i32.store
  ;; ALWAYS-NEXT:     (i32.const 0)
  ;; ALWAYS-NEXT:     (i32.const -1)
  ;; ALWAYS-NEXT:    )
  ;; ALWAYS-NEXT:    (i32.const 11)
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (type $0 (func))

  ;; CAREFUL:      (type $1 (func (param i32 i32)))

  ;; CAREFUL:      (memory $0 10 20)

  ;; CAREFUL:      (func $caller (type $0)
  ;; CAREFUL-NEXT:  (call $target
  ;; CAREFUL-NEXT:   (i32.load
  ;; CAREFUL-NEXT:    (i32.const 0)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:   (block (result i32)
  ;; CAREFUL-NEXT:    (i32.store
  ;; CAREFUL-NEXT:     (i32.const 0)
  ;; CAREFUL-NEXT:     (i32.const -1)
  ;; CAREFUL-NEXT:    )
  ;; CAREFUL-NEXT:    (i32.const 11)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT: )
  (func $caller
    ;; The two operands here cannot be reordered: the first loads, and the
    ;; second stores. If we move the first into the context but not the second
    ;; (which is what we'd normally do: the first can be copied, while the
    ;; second is a control flow structure) then we'd execute the second before
    ;; the first, as we'd execute the first only after doing the call, which
    ;; would be wrong.
    (call $target
      (i32.load
        (i32.const 0)
      )
      (block (result i32)
        (i32.store
          (i32.const 0)
          (i32.const 0xffffffff)
        )
        (i32.const 11)
      )
    )
  )

  ;; ALWAYS:      (func $caller-flip (type $0)
  ;; ALWAYS-NEXT:  (call $target_3
  ;; ALWAYS-NEXT:   (block (result i32)
  ;; ALWAYS-NEXT:    (i32.store
  ;; ALWAYS-NEXT:     (i32.const 0)
  ;; ALWAYS-NEXT:     (i32.const -1)
  ;; ALWAYS-NEXT:    )
  ;; ALWAYS-NEXT:    (i32.const 11)
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $caller-flip (type $0)
  ;; CAREFUL-NEXT:  (call $target
  ;; CAREFUL-NEXT:   (block (result i32)
  ;; CAREFUL-NEXT:    (i32.store
  ;; CAREFUL-NEXT:     (i32.const 0)
  ;; CAREFUL-NEXT:     (i32.const -1)
  ;; CAREFUL-NEXT:    )
  ;; CAREFUL-NEXT:    (i32.const 11)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:   (i32.load
  ;; CAREFUL-NEXT:    (i32.const 0)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT: )
  (func $caller-flip
    ;; With the order reversed, there is no problem: the load can be moved into
    ;; the context (in ALWAYS, at least).
    (call $target
      (block (result i32)
        (i32.store
          (i32.const 0)
          (i32.const 0xffffffff)
        )
        (i32.const 11)
      )
      (i32.load
        (i32.const 0)
      )
    )
  )

  ;; ALWAYS:      (func $target (type $1) (param $0 i32) (param $1 i32)
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $target (type $1) (param $0 i32) (param $1 i32)
  ;; CAREFUL-NEXT:  (nop)
  ;; CAREFUL-NEXT: )
  (func $target (param i32) (param i32)
  )
)

;; ALWAYS:      (func $target_3 (type $2) (param $0 i32)
;; ALWAYS-NEXT:  (local $1 i32)
;; ALWAYS-NEXT:  (local $2 i32)
;; ALWAYS-NEXT:  (local.set $1
;; ALWAYS-NEXT:   (local.get $0)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (local.set $2
;; ALWAYS-NEXT:   (i32.load
;; ALWAYS-NEXT:    (i32.const 0)
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (block
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT: )
(module
  (memory 10 20)

  ;; ALWAYS:      (type $0 (func (param i32)))

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

  ;; ALWAYS:      (memory $0 10 20)

  ;; ALWAYS:      (func $caller (type $1)
  ;; ALWAYS-NEXT:  (call $target_2
  ;; ALWAYS-NEXT:   (block (result i32)
  ;; ALWAYS-NEXT:    (i32.load
  ;; ALWAYS-NEXT:     (i32.const 0)
  ;; ALWAYS-NEXT:    )
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (type $0 (func))

  ;; CAREFUL:      (type $1 (func (param i32)))

  ;; CAREFUL:      (memory $0 10 20)

  ;; CAREFUL:      (func $caller (type $0)
  ;; CAREFUL-NEXT:  (call $target
  ;; CAREFUL-NEXT:   (i32.atomic.rmw8.cmpxchg_u
  ;; CAREFUL-NEXT:    (i32.const 0)
  ;; CAREFUL-NEXT:    (block (result i32)
  ;; CAREFUL-NEXT:     (i32.load
  ;; CAREFUL-NEXT:      (i32.const 0)
  ;; CAREFUL-NEXT:     )
  ;; CAREFUL-NEXT:    )
  ;; CAREFUL-NEXT:    (i32.const 1)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT: )
  (func $caller
    ;; Effect interaction between a parent and child: the child reads while the
    ;; parent writes (and also reads), so they cannot be reordered. But the
    ;; parent executes later anyhow, so it is fine to optimize the atomic
    ;; operation into the context.
    (call $target
      (i32.atomic.rmw8.cmpxchg_u
        (i32.const 0)
        (block (result i32) ;; Use a block to prevent the child from being
                            ;; moved into the context.
          (i32.load
            (i32.const 0)
          )
        )
        (i32.const 1)
      )
    )
    ;; Note that we cannot test the reverse, since if the block were on the
    ;; outside then anything inside it would not be moved.
  )

  ;; ALWAYS:      (func $target (type $0) (param $0 i32)
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $target (type $1) (param $0 i32)
  ;; CAREFUL-NEXT:  (nop)
  ;; CAREFUL-NEXT: )
  (func $target (param i32)
  )
)

;; ALWAYS:      (func $target_2 (type $0) (param $0 i32)
;; ALWAYS-NEXT:  (local $1 i32)
;; ALWAYS-NEXT:  (local.set $1
;; ALWAYS-NEXT:   (i32.atomic.rmw8.cmpxchg_u
;; ALWAYS-NEXT:    (i32.const 0)
;; ALWAYS-NEXT:    (local.get $0)
;; ALWAYS-NEXT:    (i32.const 1)
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (block
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT: )
(module
  ;; ALWAYS:      (type $0 (func))

  ;; ALWAYS:      (type $struct (struct (field i32) (field i32)))
  (type $struct (struct (field i32) (field i32)))

  (memory 10 20)

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

  ;; ALWAYS:      (type $3 (func (param i32 i32)))

  ;; ALWAYS:      (type $4 (func (param i32)))

  ;; ALWAYS:      (memory $0 10 20)

  ;; ALWAYS:      (func $caller (type $0)
  ;; ALWAYS-NEXT:  (call $target_3
  ;; ALWAYS-NEXT:   (i32.load
  ;; ALWAYS-NEXT:    (i32.const 0)
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:   (block (result i32)
  ;; ALWAYS-NEXT:    (i32.store
  ;; ALWAYS-NEXT:     (i32.const 0)
  ;; ALWAYS-NEXT:     (i32.const 1)
  ;; ALWAYS-NEXT:    )
  ;; ALWAYS-NEXT:    (i32.const 2)
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (type $0 (func))

  ;; CAREFUL:      (type $1 (func (param anyref)))

  ;; CAREFUL:      (type $2 (func (param i32 i32)))

  ;; CAREFUL:      (type $3 (func (param i32)))

  ;; CAREFUL:      (memory $0 10 20)

  ;; CAREFUL:      (func $caller (type $0)
  ;; CAREFUL-NEXT:  (call $target_3
  ;; CAREFUL-NEXT:   (i32.load
  ;; CAREFUL-NEXT:    (i32.const 0)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:   (block (result i32)
  ;; CAREFUL-NEXT:    (i32.store
  ;; CAREFUL-NEXT:     (i32.const 0)
  ;; CAREFUL-NEXT:     (i32.const 1)
  ;; CAREFUL-NEXT:    )
  ;; CAREFUL-NEXT:    (i32.const 2)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT: )
  (func $caller
    ;; Effect interaction between children of a call operand. The read and write
    ;; cannot be reordered, so all we can move into the call context is the
    ;; struct.new.
    (call $target
      (struct.new $struct
        (i32.load
          (i32.const 0)
        )
        (block (result i32) ;; Use a block to prevent the child from being
                            ;; moved into the context.
          (i32.store
            (i32.const 0)
            (i32.const 1)
          )
          (i32.const 2)
        )
      )
    )
  )

  ;; ALWAYS:      (func $caller-flip (type $0)
  ;; ALWAYS-NEXT:  (call $target_4
  ;; ALWAYS-NEXT:   (block (result i32)
  ;; ALWAYS-NEXT:    (i32.store
  ;; ALWAYS-NEXT:     (i32.const 0)
  ;; ALWAYS-NEXT:     (i32.const 1)
  ;; ALWAYS-NEXT:    )
  ;; ALWAYS-NEXT:    (i32.const 2)
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $caller-flip (type $0)
  ;; CAREFUL-NEXT:  (call $target_4
  ;; CAREFUL-NEXT:   (block (result i32)
  ;; CAREFUL-NEXT:    (i32.store
  ;; CAREFUL-NEXT:     (i32.const 0)
  ;; CAREFUL-NEXT:     (i32.const 1)
  ;; CAREFUL-NEXT:    )
  ;; CAREFUL-NEXT:    (i32.const 2)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT: )
  (func $caller-flip
    ;; With the order reversed, there is no problem, and the load can also be
    ;; optimized into the context.
    (call $target
      (struct.new $struct
        (block (result i32)
          (i32.store
            (i32.const 0)
            (i32.const 1)
          )
          (i32.const 2)
        )
        (i32.load
          (i32.const 0)
        )
      )
    )
  )

  ;; ALWAYS:      (func $target (type $2) (param $0 anyref)
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $target (type $1) (param $0 anyref)
  ;; CAREFUL-NEXT:  (nop)
  ;; CAREFUL-NEXT: )
  (func $target (param anyref)
  )
)


;; ALWAYS:      (func $target_3 (type $3) (param $0 i32) (param $1 i32)
;; ALWAYS-NEXT:  (local $2 anyref)
;; ALWAYS-NEXT:  (local.set $2
;; ALWAYS-NEXT:   (struct.new $struct
;; ALWAYS-NEXT:    (local.get $0)
;; ALWAYS-NEXT:    (local.get $1)
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (block
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT: )

;; ALWAYS:      (func $target_4 (type $4) (param $0 i32)
;; ALWAYS-NEXT:  (local $1 anyref)
;; ALWAYS-NEXT:  (local.set $1
;; ALWAYS-NEXT:   (struct.new $struct
;; ALWAYS-NEXT:    (local.get $0)
;; ALWAYS-NEXT:    (i32.load
;; ALWAYS-NEXT:     (i32.const 0)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (block
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT: )

;; CAREFUL:      (func $target_3 (type $2) (param $0 i32) (param $1 i32)
;; CAREFUL-NEXT:  (nop)
;; CAREFUL-NEXT: )

;; CAREFUL:      (func $target_4 (type $3) (param $0 i32)
;; CAREFUL-NEXT:  (drop
;; CAREFUL-NEXT:   (i32.load
;; CAREFUL-NEXT:    (i32.const 0)
;; CAREFUL-NEXT:   )
;; CAREFUL-NEXT:  )
;; CAREFUL-NEXT: )
(module
  (memory 10 20)

  ;; ALWAYS:      (type $0 (func))

  ;; ALWAYS:      (type $1 (func (param i32 i32 i32 i32 i32 i32)))

  ;; ALWAYS:      (type $2 (func (param i32 i32 i32 i32 i32)))

  ;; ALWAYS:      (memory $0 10 20)

  ;; ALWAYS:      (func $caller (type $0)
  ;; ALWAYS-NEXT:  (call $target_2
  ;; ALWAYS-NEXT:   (block (result i32)
  ;; ALWAYS-NEXT:    (i32.store
  ;; ALWAYS-NEXT:     (i32.const 0)
  ;; ALWAYS-NEXT:     (i32.const -1)
  ;; ALWAYS-NEXT:    )
  ;; ALWAYS-NEXT:    (i32.const 11)
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:   (i32.load
  ;; ALWAYS-NEXT:    (i32.const 0)
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:   (block (result i32)
  ;; ALWAYS-NEXT:    (i32.store
  ;; ALWAYS-NEXT:     (i32.const 0)
  ;; ALWAYS-NEXT:     (i32.const -1)
  ;; ALWAYS-NEXT:    )
  ;; ALWAYS-NEXT:    (i32.const 11)
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:   (i32.load
  ;; ALWAYS-NEXT:    (i32.const 0)
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:   (block (result i32)
  ;; ALWAYS-NEXT:    (i32.store
  ;; ALWAYS-NEXT:     (i32.const 0)
  ;; ALWAYS-NEXT:     (i32.const -1)
  ;; ALWAYS-NEXT:    )
  ;; ALWAYS-NEXT:    (i32.const 11)
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (type $0 (func))

  ;; CAREFUL:      (type $1 (func (param i32 i32 i32 i32 i32 i32)))

  ;; CAREFUL:      (memory $0 10 20)

  ;; CAREFUL:      (func $caller (type $0)
  ;; CAREFUL-NEXT:  (call $target
  ;; CAREFUL-NEXT:   (block (result i32)
  ;; CAREFUL-NEXT:    (i32.store
  ;; CAREFUL-NEXT:     (i32.const 0)
  ;; CAREFUL-NEXT:     (i32.const -1)
  ;; CAREFUL-NEXT:    )
  ;; CAREFUL-NEXT:    (i32.const 11)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:   (i32.load
  ;; CAREFUL-NEXT:    (i32.const 0)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:   (block (result i32)
  ;; CAREFUL-NEXT:    (i32.store
  ;; CAREFUL-NEXT:     (i32.const 0)
  ;; CAREFUL-NEXT:     (i32.const -1)
  ;; CAREFUL-NEXT:    )
  ;; CAREFUL-NEXT:    (i32.const 11)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:   (i32.load
  ;; CAREFUL-NEXT:    (i32.const 0)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:   (block (result i32)
  ;; CAREFUL-NEXT:    (i32.store
  ;; CAREFUL-NEXT:     (i32.const 0)
  ;; CAREFUL-NEXT:     (i32.const -1)
  ;; CAREFUL-NEXT:    )
  ;; CAREFUL-NEXT:    (i32.const 11)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:   (i32.load
  ;; CAREFUL-NEXT:    (i32.const 0)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT: )
  (func $caller
    ;; Similar to before, but with a sequence of interleaved things with
    ;; interactions. The same two items repeat three times. Any load cannot be
    ;; moved into the context if there is a store after it, which means that the
    ;; last load can be optimized and nothing else (in CAREFUL mode, however,
    ;; that ends up not worthwhile).
    (call $target
      (block (result i32)
        (i32.store
          (i32.const 0)
          (i32.const 0xffffffff)
        )
        (i32.const 11)
      )
      (i32.load
        (i32.const 0)
      )
      (block (result i32)
        (i32.store
          (i32.const 0)
          (i32.const 0xffffffff)
        )
        (i32.const 11)
      )
      (i32.load
        (i32.const 0)
      )
      (block (result i32)
        (i32.store
          (i32.const 0)
          (i32.const 0xffffffff)
        )
        (i32.const 11)
      )
      (i32.load
        (i32.const 0)
      )
    )
  )

  ;; ALWAYS:      (func $target (type $1) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) (param $5 i32)
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $target (type $1) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) (param $5 i32)
  ;; CAREFUL-NEXT:  (nop)
  ;; CAREFUL-NEXT: )
  (func $target (param i32) (param i32) (param i32) (param i32) (param i32) (param i32)
  )
)


;; ALWAYS:      (func $target_2 (type $2) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32)
;; ALWAYS-NEXT:  (local $5 i32)
;; ALWAYS-NEXT:  (local $6 i32)
;; ALWAYS-NEXT:  (local $7 i32)
;; ALWAYS-NEXT:  (local $8 i32)
;; ALWAYS-NEXT:  (local $9 i32)
;; ALWAYS-NEXT:  (local $10 i32)
;; ALWAYS-NEXT:  (local.set $5
;; ALWAYS-NEXT:   (local.get $0)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (local.set $6
;; ALWAYS-NEXT:   (local.get $1)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (local.set $7
;; ALWAYS-NEXT:   (local.get $2)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (local.set $8
;; ALWAYS-NEXT:   (local.get $3)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (local.set $9
;; ALWAYS-NEXT:   (local.get $4)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (local.set $10
;; ALWAYS-NEXT:   (i32.load
;; ALWAYS-NEXT:    (i32.const 0)
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (block
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT: )
(module
  ;; ALWAYS:      (type $0 (func))

  ;; ALWAYS:      (type $1 (func (param f32)))

  ;; ALWAYS:      (func $caller (type $0)
  ;; ALWAYS-NEXT:  (local $tuple (tuple i32 f32))
  ;; ALWAYS-NEXT:  (call $target
  ;; ALWAYS-NEXT:   (tuple.extract 2 1
  ;; ALWAYS-NEXT:    (local.get $tuple)
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (type $0 (func))

  ;; CAREFUL:      (type $1 (func (param f32)))

  ;; CAREFUL:      (func $caller (type $0)
  ;; CAREFUL-NEXT:  (local $tuple (tuple i32 f32))
  ;; CAREFUL-NEXT:  (call $target
  ;; CAREFUL-NEXT:   (tuple.extract 2 1
  ;; CAREFUL-NEXT:    (local.get $tuple)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT: )
  (func $caller
    (local $tuple (tuple i32 f32))
    ;; We cannot move the tuple.extract into the context, as that would mean the
    ;; new call has a tuple param. Rather than handle that somehow, ignore it.
    (call $target
      (tuple.extract 2 1
        (local.get $tuple)
      )
    )
  )

  ;; ALWAYS:      (func $target (type $1) (param $0 f32)
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $target (type $1) (param $0 f32)
  ;; CAREFUL-NEXT: )
  (func $target (param $0 f32)
  )
)