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

;; RUN: foreach %s %t wasm-opt --cfp-reftest -all -S -o - | filecheck %s

;; When a struct.get can only read from two types, and those types have a
;; constant field, we can select between those two values using a ref.test.
(module
  ;; CHECK:      (type $struct (sub (struct (field i32))))
  (type $struct (sub (struct i32)))
  ;; CHECK:      (type $substruct (sub $struct (struct (field i32) (field f64))))
  (type $substruct (sub $struct (struct i32 f64)))

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

  ;; CHECK:      (type $3 (func (param (ref null $struct)) (result i32)))

  ;; CHECK:      (func $create (type $2)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $struct
  ;; CHECK-NEXT:    (i32.const 10)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $substruct
  ;; CHECK-NEXT:    (i32.const 20)
  ;; CHECK-NEXT:    (f64.const 3.14159)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $create
    ;; Used below.
    (drop
      (struct.new $struct
        (i32.const 10)
      )
    )
    (drop
      (struct.new $substruct
        (i32.const 20)
        (f64.const 3.14159)
      )
    )
  )
  ;; CHECK:      (func $get (type $3) (param $struct (ref null $struct)) (result i32)
  ;; CHECK-NEXT:  (select
  ;; CHECK-NEXT:   (i32.const 20)
  ;; CHECK-NEXT:   (i32.const 10)
  ;; CHECK-NEXT:   (ref.test (ref $substruct)
  ;; CHECK-NEXT:    (ref.as_non_null
  ;; CHECK-NEXT:     (local.get $struct)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $get (param $struct (ref null $struct)) (result i32)
    ;; Rather than load from the struct, we can test between the two types
    ;; possible here.
    (struct.get $struct 0
      (local.get $struct)
    )
  )
)

;; As above, but now the child is a final type. This does not matter as we
;; optimize either way, if the child has no children (since without children it
;; could be marked final later, which we assume).
(module
  ;; CHECK:      (type $struct (sub (struct (field i32))))
  (type $struct (sub (struct i32)))
  ;; CHECK:      (type $substruct (sub final $struct (struct (field i32) (field f64))))
  (type $substruct (sub final $struct (struct i32 f64)))

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

  ;; CHECK:      (type $3 (func (param (ref null $struct)) (result i32)))

  ;; CHECK:      (func $create (type $2)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $struct
  ;; CHECK-NEXT:    (i32.const 10)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $substruct
  ;; CHECK-NEXT:    (i32.const 20)
  ;; CHECK-NEXT:    (f64.const 3.14159)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $create
    (drop
      (struct.new $struct
        (i32.const 10)
      )
    )
    (drop
      (struct.new $substruct
        (i32.const 20)
        (f64.const 3.14159)
      )
    )
  )
  ;; CHECK:      (func $get (type $3) (param $struct (ref null $struct)) (result i32)
  ;; CHECK-NEXT:  (select
  ;; CHECK-NEXT:   (i32.const 20)
  ;; CHECK-NEXT:   (i32.const 10)
  ;; CHECK-NEXT:   (ref.test (ref $substruct)
  ;; CHECK-NEXT:    (ref.as_non_null
  ;; CHECK-NEXT:     (local.get $struct)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $get (param $struct (ref null $struct)) (result i32)
    (struct.get $struct 0
      (local.get $struct)
    )
  )
)

;; As above, but now the subtype has subtypes.
(module
  ;; CHECK:      (type $struct (sub (struct (field i32))))
  (type $struct (sub (struct i32)))
  ;; CHECK:      (type $substruct (sub $struct (struct (field i32) (field f64))))
  (type $substruct (sub $struct (struct i32 f64)))

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

  ;; CHECK:      (type $3 (func (param (ref null $struct)) (result i32)))

  ;; CHECK:      (type $subsubstruct (sub $substruct (struct (field i32) (field f64))))
  (type $subsubstruct (sub $substruct (struct i32 f64)))

  ;; CHECK:      (func $create (type $2)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $struct
  ;; CHECK-NEXT:    (i32.const 10)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $substruct
  ;; CHECK-NEXT:    (i32.const 20)
  ;; CHECK-NEXT:    (f64.const 3.14159)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $create
    ;; Used below.
    (drop
      (struct.new $struct
        (i32.const 10)
      )
    )
    (drop
      (struct.new $substruct
        (i32.const 20)
        (f64.const 3.14159)
      )
    )
  )
  ;; CHECK:      (func $get (type $3) (param $struct (ref null $struct)) (result i32)
  ;; CHECK-NEXT:  (local $x (ref $subsubstruct))
  ;; CHECK-NEXT:  (struct.get $struct 0
  ;; CHECK-NEXT:   (local.get $struct)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $get (param $struct (ref null $struct)) (result i32)
    ;; Keep this type alive.
    (local $x (ref $subsubstruct))

    ;; We only test on final types for efficiency, so we do not optimize here.
    ;; The type we'd like to test on here has subtypes so it cannot be marked
    ;; final; otherwise if there are no subtypes we assume it will be marked
    ;; final later and optimize.
    (struct.get $struct 0
      (local.get $struct)
    )
  )
)

;; As above, but now one value is not constant.
(module
  ;; CHECK:      (type $struct (sub (struct (field i32))))
  (type $struct (sub (struct i32)))
  ;; CHECK:      (type $1 (func (param i32)))

  ;; CHECK:      (type $substruct (sub $struct (struct (field i32) (field f64))))
  (type $substruct (sub $struct (struct i32 f64)))

  ;; CHECK:      (type $3 (func (param (ref null $struct)) (result i32)))

  ;; CHECK:      (func $create (type $1) (param $x i32)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $struct
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $substruct
  ;; CHECK-NEXT:    (i32.const 20)
  ;; CHECK-NEXT:    (f64.const 3.14159)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $create (param $x i32)
    (drop
      (struct.new $struct
        (local.get $x) ;; this changed
      )
    )
    (drop
      (struct.new $substruct
        (i32.const 20)
        (f64.const 3.14159)
      )
    )
  )
  ;; CHECK:      (func $get (type $3) (param $struct (ref null $struct)) (result i32)
  ;; CHECK-NEXT:  (struct.get $struct 0
  ;; CHECK-NEXT:   (local.get $struct)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $get (param $struct (ref null $struct)) (result i32)
    ;; We cannot optimize here.
    (struct.get $struct 0
      (local.get $struct)
    )
  )
)

;; As above, but now the other value is not constant.
(module
  ;; CHECK:      (type $struct (sub (struct (field i32))))
  (type $struct (sub (struct i32)))
  ;; CHECK:      (type $1 (func (param i32)))

  ;; CHECK:      (type $substruct (sub $struct (struct (field i32) (field f64))))
  (type $substruct (sub $struct (struct i32 f64)))

  ;; CHECK:      (type $3 (func (param (ref null $struct)) (result i32)))

  ;; CHECK:      (func $create (type $1) (param $x i32)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $struct
  ;; CHECK-NEXT:    (i32.const 10)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $substruct
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:    (f64.const 3.14159)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $create (param $x i32)
    (drop
      (struct.new $struct
        (i32.const 10) ;; this changed
      )
    )
    (drop
      (struct.new $substruct
        (local.get $x) ;; this changed
        (f64.const 3.14159)
      )
    )
  )
  ;; CHECK:      (func $get (type $3) (param $struct (ref null $struct)) (result i32)
  ;; CHECK-NEXT:  (struct.get $struct 0
  ;; CHECK-NEXT:   (local.get $struct)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $get (param $struct (ref null $struct)) (result i32)
    ;; We cannot optimize here.
    (struct.get $struct 0
      (local.get $struct)
    )
  )
)

;; Almost optimizable, but the field is mutable, so we can't.
(module
  ;; CHECK:      (type $struct (sub (struct (field (mut i32)))))
  (type $struct (sub (struct (mut i32))))
  ;; CHECK:      (type $1 (func))

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

  ;; CHECK:      (type $3 (func (param (ref null $struct)) (result i32)))

  ;; CHECK:      (func $create (type $1)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $struct
  ;; CHECK-NEXT:    (i32.const 10)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $substruct
  ;; CHECK-NEXT:    (i32.const 20)
  ;; CHECK-NEXT:    (f64.const 3.14159)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $create
    (drop
      (struct.new $struct
        (i32.const 10)
      )
    )
    (drop
      (struct.new $substruct
        (i32.const 20)
        (f64.const 3.14159)
      )
    )
  )
  ;; CHECK:      (func $get (type $3) (param $struct (ref null $struct)) (result i32)
  ;; CHECK-NEXT:  (struct.get $struct 0
  ;; CHECK-NEXT:   (local.get $struct)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $get (param $struct (ref null $struct)) (result i32)
    ;; We cannot optimize here.
    (struct.get $struct 0
      (local.get $struct)
    )
  )
)

;; Three types (in a chain) with three values, 10, 20, 30.
(module
  ;; CHECK:      (type $struct (sub (struct (field i32))))
  (type $struct (sub (struct i32)))
  ;; CHECK:      (type $substruct (sub $struct (struct (field i32) (field f64))))
  (type $substruct (sub $struct (struct i32 f64)))

  ;; CHECK:      (type $subsubstruct (sub $substruct (struct (field i32) (field f64) (field anyref))))
  (type $subsubstruct (sub $substruct (struct i32 f64 anyref)))

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

  ;; CHECK:      (type $4 (func (param (ref null $struct)) (result i32)))

  ;; CHECK:      (type $5 (func (param (ref null $substruct)) (result i32)))

  ;; CHECK:      (func $create (type $3)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $struct
  ;; CHECK-NEXT:    (i32.const 10)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $substruct
  ;; CHECK-NEXT:    (i32.const 20)
  ;; CHECK-NEXT:    (f64.const 3.14159)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $subsubstruct
  ;; CHECK-NEXT:    (i32.const 30)
  ;; CHECK-NEXT:    (f64.const 3.14159)
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $create
    (drop
      (struct.new $struct
        (i32.const 10)
      )
    )
    (drop
      (struct.new $substruct
        (i32.const 20)
        (f64.const 3.14159)
      )
    )
    (drop
      (struct.new $subsubstruct
        (i32.const 30)
        (f64.const 3.14159)
        (ref.null any)
      )
    )
  )
  ;; CHECK:      (func $get (type $4) (param $struct (ref null $struct)) (result i32)
  ;; CHECK-NEXT:  (struct.get $struct 0
  ;; CHECK-NEXT:   (local.get $struct)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $get (param $struct (ref null $struct)) (result i32)
    ;; Three types are possible here, with three different values, so we do not
    ;; optimize.
    (struct.get $struct 0
      (local.get $struct)
    )
  )

  ;; CHECK:      (func $get-sub (type $5) (param $substruct (ref null $substruct)) (result i32)
  ;; CHECK-NEXT:  (select
  ;; CHECK-NEXT:   (i32.const 30)
  ;; CHECK-NEXT:   (i32.const 20)
  ;; CHECK-NEXT:   (ref.test (ref $subsubstruct)
  ;; CHECK-NEXT:    (ref.as_non_null
  ;; CHECK-NEXT:     (local.get $substruct)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $get-sub (param $substruct (ref null $substruct)) (result i32)
    ;; Only two types are relevant here, so we do optimize.
    (struct.get $substruct 0
      (local.get $substruct)
    )
  )
)

;; Three types with two values, 10, 20, 20.
(module
  ;; CHECK:      (type $struct (sub (struct (field i32))))
  (type $struct (sub (struct i32)))
  ;; CHECK:      (type $substruct (sub $struct (struct (field i32) (field f64))))
  (type $substruct (sub $struct (struct i32 f64)))

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

  ;; CHECK:      (type $subsubstruct (sub $substruct (struct (field i32) (field f64) (field anyref))))
  (type $subsubstruct (sub $substruct (struct i32 f64 anyref)))

  ;; CHECK:      (type $4 (func (param (ref null $struct)) (result i32)))

  ;; CHECK:      (func $create (type $2)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $struct
  ;; CHECK-NEXT:    (i32.const 10)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $substruct
  ;; CHECK-NEXT:    (i32.const 20)
  ;; CHECK-NEXT:    (f64.const 3.14159)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $subsubstruct
  ;; CHECK-NEXT:    (i32.const 20)
  ;; CHECK-NEXT:    (f64.const 3.14159)
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $create
    (drop
      (struct.new $struct
        (i32.const 10)
      )
    )
    (drop
      (struct.new $substruct
        (i32.const 20)
        (f64.const 3.14159)
      )
    )
    (drop
      (struct.new $subsubstruct
        (i32.const 20) ;; this changed
        (f64.const 3.14159)
        (ref.null any)
      )
    )
  )
  ;; CHECK:      (func $get (type $4) (param $struct (ref null $struct)) (result i32)
  ;; CHECK-NEXT:  (struct.get $struct 0
  ;; CHECK-NEXT:   (local.get $struct)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $get (param $struct (ref null $struct)) (result i32)
    ;; Three types are possible here, but two have the same value, and we can
    ;; differentiate between them with a test. However, the test would be on
    ;; $substruct, which is not a final type, so we do not optimize.
    (struct.get $struct 0
      (local.get $struct)
    )
  )
)

;; Three types with two values, but non-consecutive: 20, 10, 20.
(module
  ;; CHECK:      (type $struct (sub (struct (field i32))))
  (type $struct (sub (struct i32)))
  ;; CHECK:      (type $substruct (sub $struct (struct (field i32) (field f64))))
  (type $substruct (sub $struct (struct i32 f64)))

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

  ;; CHECK:      (type $subsubstruct (sub $substruct (struct (field i32) (field f64) (field anyref))))
  (type $subsubstruct (sub $substruct (struct i32 f64 anyref)))

  ;; CHECK:      (type $4 (func (param (ref null $struct)) (result i32)))

  ;; CHECK:      (func $create (type $2)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $struct
  ;; CHECK-NEXT:    (i32.const 20)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $substruct
  ;; CHECK-NEXT:    (i32.const 10)
  ;; CHECK-NEXT:    (f64.const 3.14159)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $subsubstruct
  ;; CHECK-NEXT:    (i32.const 20)
  ;; CHECK-NEXT:    (f64.const 3.14159)
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $create
    (drop
      (struct.new $struct
        (i32.const 20) ;; this changed
      )
    )
    (drop
      (struct.new $substruct
        (i32.const 10) ;; this changed
        (f64.const 3.14159)
      )
    )
    (drop
      (struct.new $subsubstruct
        (i32.const 20)
        (f64.const 3.14159)
        (ref.null any)
      )
    )
  )
  ;; CHECK:      (func $get (type $4) (param $struct (ref null $struct)) (result i32)
  ;; CHECK-NEXT:  (struct.get $struct 0
  ;; CHECK-NEXT:   (local.get $struct)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $get (param $struct (ref null $struct)) (result i32)
    ;; Three types are possible here, and two have the same value, but we still
    ;; cannot optimize: the chain of types has values A->B->A so there is no
    ;; ref.test that can differentiate the two sets.
    (struct.get $struct 0
      (local.get $struct)
    )
  )
)

;; Three types with two values, 10, 10, 20.
(module
  ;; CHECK:      (type $struct (sub (struct (field i32))))
  (type $struct (sub (struct i32)))
  ;; CHECK:      (type $substruct (sub $struct (struct (field i32) (field f64))))
  (type $substruct (sub $struct (struct i32 f64)))

  ;; CHECK:      (type $subsubstruct (sub $substruct (struct (field i32) (field f64) (field anyref))))
  (type $subsubstruct (sub $substruct (struct i32 f64 anyref)))

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

  ;; CHECK:      (type $4 (func (param (ref null $struct)) (result i32)))

  ;; CHECK:      (func $create (type $3)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $struct
  ;; CHECK-NEXT:    (i32.const 10)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $substruct
  ;; CHECK-NEXT:    (i32.const 10)
  ;; CHECK-NEXT:    (f64.const 3.14159)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $subsubstruct
  ;; CHECK-NEXT:    (i32.const 20)
  ;; CHECK-NEXT:    (f64.const 3.14159)
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $create
    (drop
      (struct.new $struct
        (i32.const 10) ;; this changed
      )
    )
    (drop
      (struct.new $substruct
        (i32.const 10)
        (f64.const 3.14159)
      )
    )
    (drop
      (struct.new $subsubstruct
        (i32.const 20)
        (f64.const 3.14159)
        (ref.null any)
      )
    )
  )
  ;; CHECK:      (func $get (type $4) (param $struct (ref null $struct)) (result i32)
  ;; CHECK-NEXT:  (select
  ;; CHECK-NEXT:   (i32.const 20)
  ;; CHECK-NEXT:   (i32.const 10)
  ;; CHECK-NEXT:   (ref.test (ref $subsubstruct)
  ;; CHECK-NEXT:    (ref.as_non_null
  ;; CHECK-NEXT:     (local.get $struct)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $get (param $struct (ref null $struct)) (result i32)
    ;; We can differentiate between the first 2 and the last 1 by testing on the
    ;; last, so we can optimize here.
    (struct.get $struct 0
      (local.get $struct)
    )
  )
)

;; Three types with two values and an abstract type.
(module
  ;; CHECK:      (type $struct (sub (struct (field i32))))
  (type $struct (sub (struct i32)))
  ;; CHECK:      (type $substruct (sub $struct (struct (field i32) (field f64))))
  (type $substruct (sub $struct (struct i32 f64)))

  ;; CHECK:      (type $subsubstruct (sub $substruct (struct (field i32) (field f64) (field anyref))))
  (type $subsubstruct (sub $substruct (struct i32 f64 anyref)))

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

  ;; CHECK:      (type $4 (func (param (ref null $struct)) (result i32)))

  ;; CHECK:      (func $create (type $3)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $struct
  ;; CHECK-NEXT:    (i32.const 10)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $subsubstruct
  ;; CHECK-NEXT:    (i32.const 30)
  ;; CHECK-NEXT:    (f64.const 3.14159)
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $create
    (drop
      (struct.new $struct
        (i32.const 10)
      )
    )
    ;; We never create $substruct, so it doesn't matter (we use a local to
    ;; keep it alive).
    (drop
      (struct.new $subsubstruct
        (i32.const 30)
        (f64.const 3.14159)
        (ref.null any)
      )
    )
  )
  ;; CHECK:      (func $get (type $4) (param $struct (ref null $struct)) (result i32)
  ;; CHECK-NEXT:  (select
  ;; CHECK-NEXT:   (i32.const 30)
  ;; CHECK-NEXT:   (i32.const 10)
  ;; CHECK-NEXT:   (ref.test (ref $subsubstruct)
  ;; CHECK-NEXT:    (ref.as_non_null
  ;; CHECK-NEXT:     (local.get $struct)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $get (param $struct (ref null $struct)) (result i32)
    ;; We can optimize since only two types are actually possible.
    (struct.get $struct 0
      (local.get $struct)
    )
  )
)

;; Three types with three values, now in a triangle.
(module
  ;; CHECK:      (type $struct (sub (struct (field i32))))
  (type $struct (sub (struct i32)))
  ;; CHECK:      (type $1 (func))

  ;; CHECK:      (type $substruct.A (sub $struct (struct (field i32) (field f64))))
  (type $substruct.A (sub $struct (struct i32 f64)))

  ;; CHECK:      (type $substruct.B (sub $struct (struct (field i32) (field f64) (field anyref))))
  (type $substruct.B (sub $struct (struct i32 f64 anyref)))

  ;; CHECK:      (type $4 (func (param (ref null $struct)) (result i32)))

  ;; CHECK:      (func $create (type $1)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $struct
  ;; CHECK-NEXT:    (i32.const 10)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $substruct.A
  ;; CHECK-NEXT:    (i32.const 20)
  ;; CHECK-NEXT:    (f64.const 3.14159)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $substruct.B
  ;; CHECK-NEXT:    (i32.const -20)
  ;; CHECK-NEXT:    (f64.const 3.14159)
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $create
    (drop
      (struct.new $struct
        (i32.const 10)
      )
    )
    (drop
      (struct.new $substruct.A
        (i32.const 20)
        (f64.const 3.14159)
      )
    )
    (drop
      (struct.new $substruct.B
        (i32.const -20)
        (f64.const 3.14159)
        (ref.null any)
      )
    )
  )
  ;; CHECK:      (func $get (type $4) (param $struct (ref null $struct)) (result i32)
  ;; CHECK-NEXT:  (struct.get $struct 0
  ;; CHECK-NEXT:   (local.get $struct)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $get (param $struct (ref null $struct)) (result i32)
    ;; Three types are possible here, with three different values, so we do not
    ;; optimize.
    (struct.get $struct 0
      (local.get $struct)
    )
  )
)

;; Three types in a triangle, with only two values.
(module
  ;; CHECK:      (type $struct (sub (struct (field i32))))
  (type $struct (sub (struct i32)))
  ;; CHECK:      (type $1 (func))

  ;; CHECK:      (type $substruct.A (sub $struct (struct (field i32) (field f64))))
  (type $substruct.A (sub $struct (struct i32 f64)))

  ;; CHECK:      (type $substruct.B (sub $struct (struct (field i32) (field f64) (field anyref))))
  (type $substruct.B (sub $struct (struct i32 f64 anyref)))

  ;; CHECK:      (type $4 (func (param (ref null $struct)) (result i32)))

  ;; CHECK:      (func $create (type $1)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $struct
  ;; CHECK-NEXT:    (i32.const 10)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $substruct.A
  ;; CHECK-NEXT:    (i32.const 20)
  ;; CHECK-NEXT:    (f64.const 3.14159)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $substruct.B
  ;; CHECK-NEXT:    (i32.const 20)
  ;; CHECK-NEXT:    (f64.const 3.14159)
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $create
    (drop
      (struct.new $struct
        (i32.const 10)
      )
    )
    (drop
      (struct.new $substruct.A
        (i32.const 20)
        (f64.const 3.14159)
      )
    )
    (drop
      (struct.new $substruct.B
        (i32.const 20) ;; this changed
        (f64.const 3.14159)
        (ref.null any)
      )
    )
  )
  ;; CHECK:      (func $get (type $4) (param $struct (ref null $struct)) (result i32)
  ;; CHECK-NEXT:  (struct.get $struct 0
  ;; CHECK-NEXT:   (local.get $struct)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $get (param $struct (ref null $struct)) (result i32)
    ;; There is no ref.test that can separate the parent from the two children,
    ;; so we cannot optimize.
    (struct.get $struct 0
      (local.get $struct)
    )
  )
)

;; As above, but the singular value is moved.
(module
  ;; CHECK:      (type $struct (sub (struct (field i32))))
  (type $struct (sub (struct i32)))
  ;; CHECK:      (type $substruct.A (sub $struct (struct (field i32) (field f64))))
  (type $substruct.A (sub $struct (struct i32 f64)))

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

  ;; CHECK:      (type $substruct.B (sub $struct (struct (field i32) (field f64) (field anyref))))
  (type $substruct.B (sub $struct (struct i32 f64 anyref)))

  ;; CHECK:      (type $4 (func (param (ref null $struct)) (result i32)))

  ;; CHECK:      (func $create (type $2)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $struct
  ;; CHECK-NEXT:    (i32.const 20)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $substruct.A
  ;; CHECK-NEXT:    (i32.const 10)
  ;; CHECK-NEXT:    (f64.const 3.14159)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $substruct.B
  ;; CHECK-NEXT:    (i32.const 20)
  ;; CHECK-NEXT:    (f64.const 3.14159)
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $create
    (drop
      (struct.new $struct
        (i32.const 20) ;; this changed
      )
    )
    (drop
      (struct.new $substruct.A
        (i32.const 10) ;; this changed
        (f64.const 3.14159)
      )
    )
    (drop
      (struct.new $substruct.B
        (i32.const 20)
        (f64.const 3.14159)
        (ref.null any)
      )
    )
  )
  ;; CHECK:      (func $get (type $4) (param $struct (ref null $struct)) (result i32)
  ;; CHECK-NEXT:  (select
  ;; CHECK-NEXT:   (i32.const 10)
  ;; CHECK-NEXT:   (i32.const 20)
  ;; CHECK-NEXT:   (ref.test (ref $substruct.A)
  ;; CHECK-NEXT:    (ref.as_non_null
  ;; CHECK-NEXT:     (local.get $struct)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $get (param $struct (ref null $struct)) (result i32)
    ;; We can ref.test on $substruct.A now, and optimize.
    (struct.get $struct 0
      (local.get $struct)
    )
  )
)

;; As above, but the singular value is moved again.
(module
  ;; CHECK:      (type $struct (sub (struct (field i32))))
  (type $struct (sub (struct i32)))
  ;; CHECK:      (type $substruct.B (sub $struct (struct (field i32) (field f64) (field anyref))))

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

  ;; CHECK:      (type $substruct.A (sub $struct (struct (field i32) (field f64))))
  (type $substruct.A (sub $struct (struct i32 f64)))

  (type $substruct.B (sub $struct (struct i32 f64 anyref)))

  ;; CHECK:      (type $4 (func (param (ref null $struct)) (result i32)))

  ;; CHECK:      (func $create (type $2)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $struct
  ;; CHECK-NEXT:    (i32.const 20)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $substruct.A
  ;; CHECK-NEXT:    (i32.const 20)
  ;; CHECK-NEXT:    (f64.const 3.14159)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $substruct.B
  ;; CHECK-NEXT:    (i32.const 10)
  ;; CHECK-NEXT:    (f64.const 3.14159)
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $create
    (drop
      (struct.new $struct
        (i32.const 20)
      )
    )
    (drop
      (struct.new $substruct.A
        (i32.const 20) ;; this changed
        (f64.const 3.14159)
      )
    )
    (drop
      (struct.new $substruct.B
        (i32.const 10) ;; this changed
        (f64.const 3.14159)
        (ref.null any)
      )
    )
  )
  ;; CHECK:      (func $get (type $4) (param $struct (ref null $struct)) (result i32)
  ;; CHECK-NEXT:  (select
  ;; CHECK-NEXT:   (i32.const 10)
  ;; CHECK-NEXT:   (i32.const 20)
  ;; CHECK-NEXT:   (ref.test (ref $substruct.B)
  ;; CHECK-NEXT:    (ref.as_non_null
  ;; CHECK-NEXT:     (local.get $struct)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $get (param $struct (ref null $struct)) (result i32)
    ;; We can ref.test on $substruct.B now, and optimize.
    (struct.get $struct 0
      (local.get $struct)
    )
  )
)

;; A triangle with an abstract type at the top.
(module
  ;; CHECK:      (type $struct (sub (struct (field i32))))
  (type $struct (sub (struct i32)))
  ;; CHECK:      (type $substruct.A (sub $struct (struct (field i32) (field f64))))
  (type $substruct.A (sub $struct (struct i32 f64)))

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

  ;; CHECK:      (type $substruct.B (sub $struct (struct (field i32) (field f64) (field anyref))))
  (type $substruct.B (sub $struct (struct i32 f64 anyref)))

  ;; CHECK:      (type $4 (func (param (ref null $struct)) (result i32)))

  ;; CHECK:      (func $create (type $2)
  ;; CHECK-NEXT:  (local $keepalive (ref $struct))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $substruct.A
  ;; CHECK-NEXT:    (i32.const 20)
  ;; CHECK-NEXT:    (f64.const 3.14159)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $substruct.B
  ;; CHECK-NEXT:    (i32.const 30)
  ;; CHECK-NEXT:    (f64.const 3.14159)
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $create
    (local $keepalive (ref $struct))
    ;; $struct is never created.
    (drop
      (struct.new $substruct.A
        (i32.const 20)
        (f64.const 3.14159)
      )
    )
    (drop
      (struct.new $substruct.B
        (i32.const 30)
        (f64.const 3.14159)
        (ref.null any)
      )
    )
  )
  ;; CHECK:      (func $get (type $4) (param $struct (ref null $struct)) (result i32)
  ;; CHECK-NEXT:  (select
  ;; CHECK-NEXT:   (i32.const 20)
  ;; CHECK-NEXT:   (i32.const 30)
  ;; CHECK-NEXT:   (ref.test (ref $substruct.A)
  ;; CHECK-NEXT:    (ref.as_non_null
  ;; CHECK-NEXT:     (local.get $struct)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $get (param $struct (ref null $struct)) (result i32)
    ;; We can optimize here as only two types are non-abstract, and picking
    ;; between the two siblings is easy.
    (struct.get $struct 0
      (local.get $struct)
    )
  )
)

;; A triangle with an abstract type in a sibling.
(module
  ;; CHECK:      (type $struct (sub (struct (field i32))))
  (type $struct (sub (struct i32)))
  ;; CHECK:      (type $substruct.B (sub $struct (struct (field i32) (field f64) (field anyref))))

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

  ;; CHECK:      (type $substruct.A (sub $struct (struct (field i32) (field f64))))
  (type $substruct.A (sub $struct (struct i32 f64)))

  (type $substruct.B (sub $struct (struct i32 f64 anyref)))

  ;; CHECK:      (type $4 (func (param (ref null $struct)) (result i32)))

  ;; CHECK:      (func $create (type $2)
  ;; CHECK-NEXT:  (local $keepalive (ref $substruct.A))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $struct
  ;; CHECK-NEXT:    (i32.const 10)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $substruct.B
  ;; CHECK-NEXT:    (i32.const 30)
  ;; CHECK-NEXT:    (f64.const 3.14159)
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $create
    (local $keepalive (ref $substruct.A))
    (drop
      (struct.new $struct
        (i32.const 10)
      )
    )
    ;; $substruct.A is never created.
    (drop
      (struct.new $substruct.B
        (i32.const 30)
        (f64.const 3.14159)
        (ref.null any)
      )
    )
  )
  ;; CHECK:      (func $get (type $4) (param $struct (ref null $struct)) (result i32)
  ;; CHECK-NEXT:  (select
  ;; CHECK-NEXT:   (i32.const 30)
  ;; CHECK-NEXT:   (i32.const 10)
  ;; CHECK-NEXT:   (ref.test (ref $substruct.B)
  ;; CHECK-NEXT:    (ref.as_non_null
  ;; CHECK-NEXT:     (local.get $struct)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $get (param $struct (ref null $struct)) (result i32)
    ;; We can optimize here as only two types are non-abstract, and we can test
    ;; on the non-abstract sibling.
    (struct.get $struct 0
      (local.get $struct)
    )
  )
)

;; A triangle with an abstract type in the other sibling.
(module
  ;; CHECK:      (type $struct (sub (struct (field i32))))
  (type $struct (sub (struct i32)))
  ;; CHECK:      (type $substruct.A (sub $struct (struct (field i32) (field f64))))
  (type $substruct.A (sub $struct (struct i32 f64)))

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

  ;; CHECK:      (type $substruct.B (sub $struct (struct (field i32) (field f64) (field anyref))))
  (type $substruct.B (sub $struct (struct i32 f64 anyref)))

  ;; CHECK:      (type $4 (func (param (ref null $struct)) (result i32)))

  ;; CHECK:      (func $create (type $2)
  ;; CHECK-NEXT:  (local $keepalive (ref $substruct.B))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $struct
  ;; CHECK-NEXT:    (i32.const 10)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $substruct.A
  ;; CHECK-NEXT:    (i32.const 20)
  ;; CHECK-NEXT:    (f64.const 3.14159)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $create
    (local $keepalive (ref $substruct.B))
    (drop
      (struct.new $struct
        (i32.const 10)
      )
    )
    (drop
      (struct.new $substruct.A
        (i32.const 20)
        (f64.const 3.14159)
      )
    )
    ;; $substruct.B is never created.
  )
  ;; CHECK:      (func $get (type $4) (param $struct (ref null $struct)) (result i32)
  ;; CHECK-NEXT:  (select
  ;; CHECK-NEXT:   (i32.const 20)
  ;; CHECK-NEXT:   (i32.const 10)
  ;; CHECK-NEXT:   (ref.test (ref $substruct.A)
  ;; CHECK-NEXT:    (ref.as_non_null
  ;; CHECK-NEXT:     (local.get $struct)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $get (param $struct (ref null $struct)) (result i32)
    ;; We can optimize here as only two types are non-abstract, and we can test
    ;; on the non-abstract sibling.
    (struct.get $struct 0
      (local.get $struct)
    )
  )
)

;; Several fields and several news.
(module
  ;; CHECK:      (type $struct (sub (struct (field i32) (field i64) (field f64) (field f32))))
  (type $struct (sub (struct i32 i64 f64 f32)))
  ;; CHECK:      (type $substruct (sub $struct (struct (field i32) (field i64) (field f64) (field f32))))
  (type $substruct (sub $struct (struct i32 i64 f64 f32)))

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

  ;; CHECK:      (type $3 (func (param (ref null $struct)) (result i32)))

  ;; CHECK:      (type $4 (func (param (ref null $struct)) (result i64)))

  ;; CHECK:      (type $5 (func (param (ref null $struct)) (result f64)))

  ;; CHECK:      (type $6 (func (param (ref null $struct)) (result f32)))

  ;; CHECK:      (func $create (type $2)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $struct
  ;; CHECK-NEXT:    (i32.const 10)
  ;; CHECK-NEXT:    (i64.const 20)
  ;; CHECK-NEXT:    (f64.const 30.3)
  ;; CHECK-NEXT:    (f32.const 40.400001525878906)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $substruct
  ;; CHECK-NEXT:    (i32.const 10)
  ;; CHECK-NEXT:    (i64.const 22)
  ;; CHECK-NEXT:    (f64.const 36.36)
  ;; CHECK-NEXT:    (f32.const 40.79999923706055)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $substruct
  ;; CHECK-NEXT:    (i32.const 11)
  ;; CHECK-NEXT:    (i64.const 22)
  ;; CHECK-NEXT:    (f64.const 30.3)
  ;; CHECK-NEXT:    (f32.const 40.79999923706055)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $create
    ;; The first new is for $struct, the last two for $substruct.
    ;; The first two news agree on field 0; the last two on fields 1&3; and the
    ;; first and last on field 2. As a result, we can optimize only fields 1&3.
    ;; field.
    (drop
      (struct.new $struct
        (i32.const 10)
        (i64.const 20)
        (f64.const 30.3)
        (f32.const 40.4)
      )
    )
    (drop
      (struct.new $substruct
        (i32.const 10)
        (i64.const 22)
        (f64.const 36.36)
        (f32.const 40.8)
      )
    )
    (drop
      (struct.new $substruct
        (i32.const 11)
        (i64.const 22)
        (f64.const 30.3)
        (f32.const 40.8)
      )
    )
  )
  ;; CHECK:      (func $get-0 (type $3) (param $struct (ref null $struct)) (result i32)
  ;; CHECK-NEXT:  (struct.get $struct 0
  ;; CHECK-NEXT:   (local.get $struct)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $get-0 (param $struct (ref null $struct)) (result i32)
    (struct.get $struct 0
      (local.get $struct)
    )
  )

  ;; CHECK:      (func $get-1 (type $4) (param $struct (ref null $struct)) (result i64)
  ;; CHECK-NEXT:  (select
  ;; CHECK-NEXT:   (i64.const 22)
  ;; CHECK-NEXT:   (i64.const 20)
  ;; CHECK-NEXT:   (ref.test (ref $substruct)
  ;; CHECK-NEXT:    (ref.as_non_null
  ;; CHECK-NEXT:     (local.get $struct)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $get-1 (param $struct (ref null $struct)) (result i64)
    (struct.get $struct 1
      (local.get $struct)
    )
  )

  ;; CHECK:      (func $get-2 (type $5) (param $struct (ref null $struct)) (result f64)
  ;; CHECK-NEXT:  (struct.get $struct 2
  ;; CHECK-NEXT:   (local.get $struct)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $get-2 (param $struct (ref null $struct)) (result f64)
    (struct.get $struct 2
      (local.get $struct)
    )
  )

  ;; CHECK:      (func $get-3 (type $6) (param $struct (ref null $struct)) (result f32)
  ;; CHECK-NEXT:  (select
  ;; CHECK-NEXT:   (f32.const 40.79999923706055)
  ;; CHECK-NEXT:   (f32.const 40.400001525878906)
  ;; CHECK-NEXT:   (ref.test (ref $substruct)
  ;; CHECK-NEXT:    (ref.as_non_null
  ;; CHECK-NEXT:     (local.get $struct)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $get-3 (param $struct (ref null $struct)) (result f32)
    (struct.get $struct 3
      (local.get $struct)
    )
  )
)

;; Three top-level struct hierarchies.
(module
  (rec
    ;; CHECK:      (rec
    ;; CHECK-NEXT:  (type $A (sub (struct (field i32))))
    (type $A (sub (struct i32)))
    ;; CHECK:       (type $subA (sub $A (struct (field i32) (field f64))))
    (type $subA (sub $A (struct i32 f64)))

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

    ;; CHECK:       (type $subB (sub $B (struct (field i32) (field f64))))
    (type $subB (sub $B (struct i32 f64)))

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

    ;; CHECK:       (type $subC (sub $C (struct (field i32) (field f64))))
    (type $subC (sub $C (struct i32 f64)))
  )

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

  ;; CHECK:      (type $7 (func (param (ref null $A)) (result i32)))

  ;; CHECK:      (type $8 (func (param (ref null $B)) (result i32)))

  ;; CHECK:      (type $9 (func (param (ref null $C)) (result i32)))

  ;; CHECK:      (func $create (type $6)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $A
  ;; CHECK-NEXT:    (i32.const 10)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $subA
  ;; CHECK-NEXT:    (i32.const 20)
  ;; CHECK-NEXT:    (f64.const 3.14159)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $B
  ;; CHECK-NEXT:    (i32.const 30)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $subB
  ;; CHECK-NEXT:    (i32.const 40)
  ;; CHECK-NEXT:    (f64.const 2.61828)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $C
  ;; CHECK-NEXT:    (i32.add
  ;; CHECK-NEXT:     (i32.const 1000)
  ;; CHECK-NEXT:     (i32.const 2000)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.new $subC
  ;; CHECK-NEXT:    (i32.const 50)
  ;; CHECK-NEXT:    (f64.const 999999.9)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $create
    (drop
      (struct.new $A
        (i32.const 10)
      )
    )
    (drop
      (struct.new $subA
        (i32.const 20)
        (f64.const 3.14159)
      )
    )
    (drop
      (struct.new $B
        (i32.const 30)
      )
    )
    (drop
      (struct.new $subB
        (i32.const 40)
        (f64.const 2.61828)
      )
    )
    (drop
      (struct.new $C
        ;; Something not constant enough for us to reason about
        (i32.add
          (i32.const 1000)
          (i32.const 2000)
        )
      )
    )
    (drop
      (struct.new $subC
        (i32.const 50)
        (f64.const 999999.9)
      )
    )
  )
  ;; CHECK:      (func $get-A (type $7) (param $A (ref null $A)) (result i32)
  ;; CHECK-NEXT:  (select
  ;; CHECK-NEXT:   (i32.const 20)
  ;; CHECK-NEXT:   (i32.const 10)
  ;; CHECK-NEXT:   (ref.test (ref $subA)
  ;; CHECK-NEXT:    (ref.as_non_null
  ;; CHECK-NEXT:     (local.get $A)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $get-A (param $A (ref null $A)) (result i32)
    ;; We can optimize here, picking 10 or 20.
    (struct.get $A 0
      (local.get $A)
    )
  )

  ;; CHECK:      (func $get-B (type $8) (param $B (ref null $B)) (result i32)
  ;; CHECK-NEXT:  (select
  ;; CHECK-NEXT:   (i32.const 40)
  ;; CHECK-NEXT:   (i32.const 30)
  ;; CHECK-NEXT:   (ref.test (ref $subB)
  ;; CHECK-NEXT:    (ref.as_non_null
  ;; CHECK-NEXT:     (local.get $B)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $get-B (param $B (ref null $B)) (result i32)
    ;; We can optimize here, picking 30 or 40.
    (struct.get $B 0
      (local.get $B)
    )
  )

  ;; CHECK:      (func $get-C (type $9) (param $C (ref null $C)) (result i32)
  ;; CHECK-NEXT:  (struct.get $C 0
  ;; CHECK-NEXT:   (local.get $C)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $get-C (param $C (ref null $C)) (result i32)
    ;; We can't optimize here.
    (struct.get $C 0
      (local.get $C)
    )
  )
)