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

;; (remove-unused-names allows the pass to see that blocks flow values)
;; RUN: foreach %s %t wasm-opt -all --remove-unused-names --heap2local -S -o - | filecheck %s

(module
  (rec
    ;; CHECK:      (rec
    ;; CHECK-NEXT:  (type $described (descriptor $descriptor) (struct (field i32)))
    (type $described (descriptor $descriptor) (struct (field i32)))
    ;; CHECK:       (type $descriptor (describes $described) (struct (field i64)))
    (type $descriptor (describes $described) (struct (field i64)))

    ;; CHECK:       (type $super (sub (descriptor $super.desc) (struct)))
    (type $super (sub (descriptor $super.desc) (struct)))
    ;; CHECK:       (type $super.desc (sub (describes $super) (struct)))
    (type $super.desc (sub (describes $super) (struct)))

    ;; CHECK:       (type $sub (sub $super (descriptor $sub.desc) (struct)))
    (type $sub (sub $super (descriptor $sub.desc) (struct)))
    ;; CHECK:       (type $sub.desc (sub $super.desc (describes $sub) (struct)))
    (type $sub.desc (sub $super.desc (describes $sub) (struct)))

    ;; CHECK:       (type $no-desc (struct))
    (type $no-desc (struct))

    ;; CHECK:       (type $chain-described (descriptor $chain-middle) (struct))
    (type $chain-described (descriptor $chain-middle) (struct))
    ;; CHECK:       (type $chain-middle (describes $chain-described) (descriptor $chain-descriptor) (struct))
    (type $chain-middle (describes $chain-described) (descriptor $chain-descriptor) (struct))
    ;; CHECK:       (type $chain-descriptor (describes $chain-middle) (struct))
    (type $chain-descriptor (describes $chain-middle) (struct))
  )

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

  ;; CHECK:      (type $11 (func (param (ref null (exact $super.desc)))))

  ;; CHECK:      (type $12 (func (param (ref null (exact $super)))))

  ;; CHECK:      (type $13 (func (result (ref null $super.desc))))

  ;; CHECK:      (type $14 (func (param (ref null (exact $chain-descriptor)))))

  ;; CHECK:      (type $15 (func (result (ref (exact $super)))))

  ;; CHECK:      (type $16 (func (result (ref (exact $super.desc)))))

  ;; CHECK:      (import "" "" (func $effect (type $10)))
  (import "" "" (func $effect))

  ;; CHECK:      (global $desc (ref null (exact $descriptor)) (ref.null none))
  (global $desc (ref null (exact $descriptor)) (ref.null none))

  ;; CHECK:      (func $dropped (type $10)
  ;; CHECK-NEXT:  (local $0 i32)
  ;; CHECK-NEXT:  (local $1 (ref (exact $descriptor)))
  ;; CHECK-NEXT:  (local $2 i32)
  ;; CHECK-NEXT:  (local $3 (ref (exact $descriptor)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block (result nullref)
  ;; CHECK-NEXT:    (local.set $2
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.set $3
  ;; CHECK-NEXT:     (ref.as_non_null
  ;; CHECK-NEXT:      (global.get $desc)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.set $0
  ;; CHECK-NEXT:     (local.get $2)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.set $1
  ;; CHECK-NEXT:     (local.get $3)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $dropped
    (drop
      (struct.new_desc $described
        (i32.const 1)
        (global.get $desc)
      )
    )
  )

  ;; CHECK:      (func $dropped-default (type $10)
  ;; CHECK-NEXT:  (local $0 i32)
  ;; CHECK-NEXT:  (local $1 (ref (exact $descriptor)))
  ;; CHECK-NEXT:  (local $2 (ref (exact $descriptor)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block (result nullref)
  ;; CHECK-NEXT:    (local.set $2
  ;; CHECK-NEXT:     (ref.as_non_null
  ;; CHECK-NEXT:      (global.get $desc)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.set $0
  ;; CHECK-NEXT:     (i32.const 0)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.set $1
  ;; CHECK-NEXT:     (local.get $2)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $dropped-default
    (drop
      (struct.new_default_desc $described
        (global.get $desc)
      )
    )
  )

  ;; CHECK:      (func $dropped-alloc-desc (type $10)
  ;; CHECK-NEXT:  (local $0 i32)
  ;; CHECK-NEXT:  (local $1 (ref (exact $descriptor)))
  ;; CHECK-NEXT:  (local $2 i32)
  ;; CHECK-NEXT:  (local $3 (ref (exact $descriptor)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block (result nullref)
  ;; CHECK-NEXT:    (local.set $2
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.set $3
  ;; CHECK-NEXT:     (struct.new $descriptor
  ;; CHECK-NEXT:      (i64.const 2)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.set $0
  ;; CHECK-NEXT:     (local.get $2)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.set $1
  ;; CHECK-NEXT:     (local.get $3)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $dropped-alloc-desc
    (drop
      (struct.new_desc $described
        (i32.const 1)
        (struct.new $descriptor
          (i64.const 2)
        )
      )
    )
  )

  ;; CHECK:      (func $dropped-default-alloc-desc (type $10)
  ;; CHECK-NEXT:  (local $0 i32)
  ;; CHECK-NEXT:  (local $1 (ref (exact $descriptor)))
  ;; CHECK-NEXT:  (local $2 (ref (exact $descriptor)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block (result nullref)
  ;; CHECK-NEXT:    (local.set $2
  ;; CHECK-NEXT:     (struct.new $descriptor
  ;; CHECK-NEXT:      (i64.const 2)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.set $0
  ;; CHECK-NEXT:     (i32.const 0)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.set $1
  ;; CHECK-NEXT:     (local.get $2)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $dropped-default-alloc-desc
    (drop
      (struct.new_default_desc $described
        (struct.new $descriptor
          (i64.const 2)
        )
      )
    )
  )

  ;; CHECK:      (func $get-desc (type $13) (result (ref null $super.desc))
  ;; CHECK-NEXT:  (local $0 (ref (exact $super.desc)))
  ;; CHECK-NEXT:  (local $1 (ref (exact $super.desc)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block (result nullref)
  ;; CHECK-NEXT:    (local.set $1
  ;; CHECK-NEXT:     (struct.new_default $super.desc)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.set $0
  ;; CHECK-NEXT:     (local.get $1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.get $0)
  ;; CHECK-NEXT: )
  (func $get-desc (result (ref null $super.desc))
    (ref.get_desc $super
      (struct.new_desc $super
        (struct.new $super.desc)
      )
    )
  )

  ;; CHECK:      (func $get-desc-refinalize (type $13) (result (ref null $super.desc))
  ;; CHECK-NEXT:  (local $0 (ref (exact $sub.desc)))
  ;; CHECK-NEXT:  (local $1 (ref (exact $sub.desc)))
  ;; CHECK-NEXT:  (block (result (ref (exact $sub.desc)))
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (block (result nullref)
  ;; CHECK-NEXT:     (block (result nullref)
  ;; CHECK-NEXT:      (local.set $1
  ;; CHECK-NEXT:       (struct.new_default $sub.desc)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (local.set $0
  ;; CHECK-NEXT:       (local.get $1)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (ref.null none)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $get-desc-refinalize (result (ref null $super.desc))
    ;; This block should be refinalized.
    (block (result (ref null $super.desc))
      (ref.get_desc $super
        (block (result (ref null $super))
          (struct.new_desc $sub
            (struct.new $sub.desc)
          )
        )
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-success (type $10)
  ;; CHECK-NEXT:  (local $desc (ref null (exact $super.desc)))
  ;; CHECK-NEXT:  (local $1 (ref (exact $super.desc)))
  ;; CHECK-NEXT:  (local $2 (ref (exact $super.desc)))
  ;; CHECK-NEXT:  (local.set $desc
  ;; CHECK-NEXT:   (struct.new_default $super.desc)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block (result nullref)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block (result nullref)
  ;; CHECK-NEXT:      (local.set $2
  ;; CHECK-NEXT:       (ref.as_non_null
  ;; CHECK-NEXT:        (local.get $desc)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (local.set $1
  ;; CHECK-NEXT:       (local.get $2)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (ref.null none)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (if (result nullref)
  ;; CHECK-NEXT:     (ref.eq
  ;; CHECK-NEXT:      (local.get $desc)
  ;; CHECK-NEXT:      (local.get $1)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (then
  ;; CHECK-NEXT:      (ref.null none)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (else
  ;; CHECK-NEXT:      (unreachable)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $cast-desc-eq-success
    (local $desc (ref null (exact $super.desc)))
    (local.set $desc
      (struct.new $super.desc)
    )
    (drop
      (ref.cast_desc_eq (ref (exact $super))
        (struct.new_desc $super
          (local.get $desc)
        )
        (local.get $desc)
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-fail (type $11) (param $desc (ref null (exact $super.desc)))
  ;; CHECK-NEXT:  (local $1 (ref (exact $super.desc)))
  ;; CHECK-NEXT:  (local $2 (ref (exact $super.desc)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block (result nullref)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block (result nullref)
  ;; CHECK-NEXT:      (local.set $2
  ;; CHECK-NEXT:       (struct.new_default $super.desc)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (local.set $1
  ;; CHECK-NEXT:       (local.get $2)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (ref.null none)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (if (result nullref)
  ;; CHECK-NEXT:     (ref.eq
  ;; CHECK-NEXT:      (local.get $desc)
  ;; CHECK-NEXT:      (local.get $1)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (then
  ;; CHECK-NEXT:      (ref.null none)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (else
  ;; CHECK-NEXT:      (unreachable)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $cast-desc-eq-fail (param $desc (ref null (exact $super.desc)))
    (drop
      (ref.cast_desc_eq (ref (exact $super))
        (struct.new_desc $super
          (struct.new $super.desc)
        )
        (local.get $desc)
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-fail-reverse (type $11) (param $desc (ref null (exact $super.desc)))
  ;; CHECK-NEXT:  (local $1 (ref (exact $super.desc)))
  ;; CHECK-NEXT:  (local $2 (ref (exact $super.desc)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block (result nullref)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block (result nullref)
  ;; CHECK-NEXT:      (local.set $2
  ;; CHECK-NEXT:       (ref.as_non_null
  ;; CHECK-NEXT:        (local.get $desc)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (local.set $1
  ;; CHECK-NEXT:       (local.get $2)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (ref.null none)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (if (result nullref)
  ;; CHECK-NEXT:     (ref.eq
  ;; CHECK-NEXT:      (block (result nullref)
  ;; CHECK-NEXT:       (ref.null none)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (local.get $1)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (then
  ;; CHECK-NEXT:      (ref.null none)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (else
  ;; CHECK-NEXT:      (unreachable)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $cast-desc-eq-fail-reverse (param $desc (ref null (exact $super.desc)))
    ;; Same as above, but change where the parameter is used.
    (drop
      (ref.cast_desc_eq (ref (exact $super))
        (struct.new_desc $super
          (local.get $desc)
        )
        (struct.new $super.desc)
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-fail-param (type $12) (param $ref (ref null (exact $super)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (local.get $ref)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block (result nullref)
  ;; CHECK-NEXT:      (ref.null none)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $cast-desc-eq-fail-param (param $ref (ref null (exact $super)))
    ;; Now cast the parameter. We know it can't have the locally allocated
    ;; descriptor, so the cast fails.
    (drop
      (ref.cast_desc_eq (ref (exact $super))
        (local.get $ref)
        (struct.new $super.desc)
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-fail-param-effect (type $12) (param $ref (ref null (exact $super)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block (result (ref null (exact $super)))
  ;; CHECK-NEXT:      (call $effect)
  ;; CHECK-NEXT:      (local.get $ref)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block (result nullref)
  ;; CHECK-NEXT:      (call $effect)
  ;; CHECK-NEXT:      (block (result nullref)
  ;; CHECK-NEXT:       (ref.null none)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $cast-desc-eq-fail-param-effect (param $ref (ref null (exact $super)))
    ;; Same, but with effects we cannot drop.
    (drop
      (ref.cast_desc_eq (ref (exact $super))
        (block (result (ref null (exact $super)))
          (call $effect)
          (local.get $ref)
        )
        (block (result (ref (exact $super.desc)))
          (call $effect)
          (struct.new $super.desc)
        )
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-fail-param-nullable (type $12) (param $ref (ref null (exact $super)))
  ;; CHECK-NEXT:  (local $1 (ref null (exact $super)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block (result nullref)
  ;; CHECK-NEXT:    (local.set $1
  ;; CHECK-NEXT:     (local.get $ref)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block (result nullref)
  ;; CHECK-NEXT:      (ref.null none)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (ref.cast nullref
  ;; CHECK-NEXT:     (local.get $1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $cast-desc-eq-fail-param-nullable (param $ref (ref null (exact $super)))
    ;; Now the cast admits nulls.
    (drop
      (ref.cast_desc_eq (ref null (exact $super))
        (local.get $ref)
        (struct.new $super.desc)
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-fail-param-nullable-effect (type $12) (param $ref (ref null (exact $super)))
  ;; CHECK-NEXT:  (local $1 (ref null (exact $super)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block (result nullref)
  ;; CHECK-NEXT:    (local.set $1
  ;; CHECK-NEXT:     (block (result (ref null (exact $super)))
  ;; CHECK-NEXT:      (call $effect)
  ;; CHECK-NEXT:      (local.get $ref)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block (result nullref)
  ;; CHECK-NEXT:      (call $effect)
  ;; CHECK-NEXT:      (block (result nullref)
  ;; CHECK-NEXT:       (ref.null none)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (ref.cast nullref
  ;; CHECK-NEXT:     (local.get $1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $cast-desc-eq-fail-param-nullable-effect (param $ref (ref null (exact $super)))
    ;; Now the cast admits nulls and there are effects we cannot remove.
    (drop
      (ref.cast_desc_eq (ref null (exact $super))
        (block (result (ref null (exact $super)))
          (call $effect)
          (local.get $ref)
        )
        (block (result (ref (exact $super.desc)))
          (call $effect)
          (struct.new $super.desc)
        )
      )
    )
  )

  ;; CHECK:      (func $cast-no-desc (type $11) (param $desc (ref null (exact $super.desc)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block (result nullref)
  ;; CHECK-NEXT:      (ref.null none)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (local.get $desc)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $cast-no-desc (param $desc (ref null (exact $super.desc)))
    ;; The allocation does not have a descriptor, so we know the cast must fail.
    (drop
      (ref.cast_desc_eq (ref (exact $super))
        (struct.new $no-desc)
        (local.get $desc)
      )
    )
  )

  ;; CHECK:      (func $cast-no-desc-effect (type $11) (param $desc (ref null (exact $super.desc)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block (result nullref)
  ;; CHECK-NEXT:      (call $effect)
  ;; CHECK-NEXT:      (block (result nullref)
  ;; CHECK-NEXT:       (ref.null none)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block (result (ref null (exact $super.desc)))
  ;; CHECK-NEXT:      (call $effect)
  ;; CHECK-NEXT:      (local.get $desc)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $cast-no-desc-effect (param $desc (ref null (exact $super.desc)))
    ;; Same, but with effects we cannot drop.
    (drop
      (ref.cast_desc_eq (ref (exact $super))
        (block (result (ref (exact $no-desc)))
          (call $effect)
          (struct.new $no-desc)
        )
        (block (result (ref null (exact $super.desc)))
          (call $effect)
          (local.get $desc)
        )
      )
    )
  )

  ;; CHECK:      (func $cast-no-desc-nullable (type $11) (param $desc (ref null (exact $super.desc)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block (result nullref)
  ;; CHECK-NEXT:      (ref.null none)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (local.get $desc)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $cast-no-desc-nullable (param $desc (ref null (exact $super.desc)))
    ;; The allocation does not have a descriptor, so we know the cast must fail.
    ;; Although the cast admits nulls, we know we don't have a null here, so we
    ;; don't need to preserve a null cast.
    (drop
      (ref.cast_desc_eq (ref null (exact $super))
        (struct.new $no-desc)
        (local.get $desc)
      )
    )
  )

  ;; CHECK:      (func $cast-no-desc-nullable-effect (type $11) (param $desc (ref null (exact $super.desc)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block (result nullref)
  ;; CHECK-NEXT:      (call $effect)
  ;; CHECK-NEXT:      (block (result nullref)
  ;; CHECK-NEXT:       (ref.null none)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block (result (ref null (exact $super.desc)))
  ;; CHECK-NEXT:      (call $effect)
  ;; CHECK-NEXT:      (local.get $desc)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $cast-no-desc-nullable-effect (param $desc (ref null (exact $super.desc)))
    ;; Same, but with effects we cannot drop.
    (drop
      (ref.cast_desc_eq (ref null (exact $super))
        (block (result (ref (exact $no-desc)))
          (call $effect)
          (struct.new $no-desc)
        )
        (block (result (ref null (exact $super.desc)))
          (call $effect)
          (local.get $desc)
        )
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-and-ref (type $14) (param $desc (ref null (exact $chain-descriptor)))
  ;; CHECK-NEXT:  (local $middle (ref null (exact $chain-middle)))
  ;; CHECK-NEXT:  (local $2 (ref (exact $chain-descriptor)))
  ;; CHECK-NEXT:  (local $3 (ref (exact $chain-descriptor)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block (result nullref)
  ;; CHECK-NEXT:    (local.set $3
  ;; CHECK-NEXT:     (ref.as_non_null
  ;; CHECK-NEXT:      (local.get $desc)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.set $2
  ;; CHECK-NEXT:     (local.get $3)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (ref.null none)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (ref.null none)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $cast-desc-eq-and-ref (param $desc (ref null (exact $chain-descriptor)))
    ;; The same allocation flows into both the descriptor and the reference. The
    ;; cast must fail because a value cannot be its own descriptor. We make sure
    ;; the descriptor itself has a descriptor so it is not handled by the same
    ;; logic as the previous test.
    (local $middle (ref null (exact $chain-middle)))
    (local.set $middle
      (struct.new_desc $chain-middle
        (local.get $desc)
      )
    )
    (drop
      (ref.cast_desc_eq (ref (exact $chain-described))
        (local.get $middle)
        (local.get $middle)
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-and-ref-nullable (type $14) (param $desc (ref null (exact $chain-descriptor)))
  ;; CHECK-NEXT:  (local $middle (ref null (exact $chain-middle)))
  ;; CHECK-NEXT:  (local $2 (ref (exact $chain-descriptor)))
  ;; CHECK-NEXT:  (local $3 (ref (exact $chain-descriptor)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block (result nullref)
  ;; CHECK-NEXT:    (local.set $3
  ;; CHECK-NEXT:     (ref.as_non_null
  ;; CHECK-NEXT:      (local.get $desc)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.set $2
  ;; CHECK-NEXT:     (local.get $3)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (ref.null none)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (ref.null none)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $cast-desc-eq-and-ref-nullable (param $desc (ref null (exact $chain-descriptor)))
    ;; Same, but now the cast allows nulls. It should still trap.
    (local $middle (ref null (exact $chain-middle)))
    (local.set $middle
      (struct.new_desc $chain-middle
        (local.get $desc)
      )
    )
    (drop
      (ref.cast_desc_eq (ref null (exact $chain-described))
        (local.get $middle)
        (local.get $middle)
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-and-ref-tee (type $10)
  ;; CHECK-NEXT:  (local $desc (ref null (exact $super.desc)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block (result nullref)
  ;; CHECK-NEXT:      (ref.null none)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (ref.null none)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $cast-desc-eq-and-ref-tee
    ;; The same allocation flows into both the descriptor and the reference
    ;; again, but now it uses a tee. The allocation does not have a descriptor.
    (local $desc (ref null (exact $super.desc)))
    (drop
      (ref.cast_desc_eq (ref (exact $super))
        (local.tee $desc
          (struct.new $super.desc)
        )
        (local.get $desc)
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-and-ref-tee-nullable (type $10)
  ;; CHECK-NEXT:  (local $desc (ref null (exact $super.desc)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block (result nullref)
  ;; CHECK-NEXT:      (ref.null none)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (ref.null none)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $cast-desc-eq-and-ref-tee-nullable
    ;; Same, but the cast allows nulls. It should still trap.
    (local $desc (ref null (exact $super.desc)))
    (drop
      (ref.cast_desc_eq (ref null (exact $super))
        (local.tee $desc
          (struct.new $super.desc)
        )
        (local.get $desc)
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-stale-parent (type $15) (result (ref (exact $super)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block (result nullref)
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block (result (ref null $super.desc))
  ;; CHECK-NEXT:    (call $effect)
  ;; CHECK-NEXT:    (block (result nullref)
  ;; CHECK-NEXT:     (ref.null none)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  (func $cast-desc-eq-stale-parent (result (ref (exact $super)))
    (ref.cast_desc_eq (ref (exact $super))
      ;; We will optimize this allocation first, causing the parent
      ;; ref.cast_desc_eq to be optimized out. The parent map will no longer be up
      ;; to date when we optimize the second allocation, but we should sill be
      ;; able to optimize successfully without crashing.
      (struct.new_default $no-desc)
      (block (result (ref (exact $super.desc)))
        (call $effect)
        (struct.new_default $super.desc)
      )
    )
  )

  ;; CHECK:      (func $cast-desc-eq-stale-parent-escape (type $16) (result (ref (exact $super.desc)))
  ;; CHECK-NEXT:  (local $desc (ref null (exact $super.desc)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block (result nullref)
  ;; CHECK-NEXT:      (ref.null none)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block (result nullref)
  ;; CHECK-NEXT:      (ref.null none)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (ref.as_non_null
  ;; CHECK-NEXT:   (local.get $desc)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $cast-desc-eq-stale-parent-escape (result (ref (exact $super.desc)))
    (local $desc (ref (exact $super.desc)))
    (drop
      (ref.cast_desc_eq (ref (exact $super))
        ;; Same as above, but now the second alloocation escapes. We should still
        ;; optimize the first allocation and the cast, and we should still not
        ;; crash.
        (struct.new_default $no-desc)
        (local.tee $desc
          (struct.new_default $super.desc)
        )
      )
    )
    (local.get $desc)
  )
)

(module
  (rec
    ;; CHECK:      (rec
    ;; CHECK-NEXT:  (type $struct (sub (descriptor $desc) (struct)))
    (type $struct (sub (descriptor $desc) (struct)))
    ;; CHECK:       (type $desc (describes $struct) (struct))
    (type $desc (describes $struct) (struct))
  )

  ;; CHECK:      (type $2 (func (result (ref (exact $desc)))))

  ;; CHECK:      (type $3 (func (param (ref null (exact $desc))) (result (ref (exact $desc)))))

  ;; CHECK:      (func $null (type $2) (result (ref (exact $desc)))
  ;; CHECK-NEXT:  (local $0 (ref none))
  ;; CHECK-NEXT:  (local $1 (ref none))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block (result nullref)
  ;; CHECK-NEXT:    (local.set $1
  ;; CHECK-NEXT:     (ref.as_non_null
  ;; CHECK-NEXT:      (ref.null none)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.set $0
  ;; CHECK-NEXT:     (local.get $1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.get $0)
  ;; CHECK-NEXT: )
  (func $null (result (ref (exact $desc)))
    ;; Read a null descriptor from a struct.new we can convert to locals. We do
    ;; not end up with a (ref (exact $desc)) here, since this will trap, so we
    ;; emit an unreachable.
    (ref.get_desc $struct
      (struct.new_default_desc $struct
        (ref.null none)
      )
    )
  )

  ;; CHECK:      (func $nullable-param (type $3) (param $desc (ref null (exact $desc))) (result (ref (exact $desc)))
  ;; CHECK-NEXT:  (local $1 (ref (exact $desc)))
  ;; CHECK-NEXT:  (local $2 (ref (exact $desc)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block (result nullref)
  ;; CHECK-NEXT:    (local.set $2
  ;; CHECK-NEXT:     (ref.as_non_null
  ;; CHECK-NEXT:      (local.get $desc)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.set $1
  ;; CHECK-NEXT:     (local.get $2)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.get $1)
  ;; CHECK-NEXT: )
  (func $nullable-param (param $desc (ref null (exact $desc))) (result (ref (exact $desc)))
    ;; Read a null descriptor from a nullable param.
    (ref.get_desc $struct
      (struct.new_default_desc $struct
        (local.get $desc)
      )
    )
  )

  ;; CHECK:      (func $nullable-local (type $2) (result (ref (exact $desc)))
  ;; CHECK-NEXT:  (local $desc (ref null (exact $desc)))
  ;; CHECK-NEXT:  (local $1 (ref (exact $desc)))
  ;; CHECK-NEXT:  (local $2 (ref (exact $desc)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block (result nullref)
  ;; CHECK-NEXT:    (local.set $2
  ;; CHECK-NEXT:     (ref.as_non_null
  ;; CHECK-NEXT:      (local.get $desc)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.set $1
  ;; CHECK-NEXT:     (local.get $2)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.get $1)
  ;; CHECK-NEXT: )
  (func $nullable-local (result (ref (exact $desc)))
    (local $desc (ref null (exact $desc)))
    ;; Read a null descriptor from a nullable local.
    (ref.get_desc $struct
      (struct.new_default_desc $struct
        (local.get $desc)
      )
    )
  )
)

;; A definitely-failing descriptor cast. We have two pairs of descriptor/
;; describee, and create an $A2 that we try to cast to the unrelated $A.
(module
  (rec
    ;; CHECK:      (rec
    ;; CHECK-NEXT:  (type $A (descriptor $B) (struct))
    (type $A (descriptor $B) (struct))
    ;; CHECK:       (type $B (describes $A) (struct))
    (type $B (describes $A) (struct))

    ;; CHECK:       (type $A2 (descriptor $B2) (struct))
    (type $A2 (descriptor $B2) (struct))
    ;; CHECK:       (type $B2 (describes $A2) (struct))
    (type $B2 (describes $A2) (struct))
  )

  ;; CHECK:      (type $4 (func (result (ref $A))))

  ;; CHECK:      (func $A (type $4) (result (ref $A))
  ;; CHECK-NEXT:  (local $0 (ref (exact $B2)))
  ;; CHECK-NEXT:  (local $1 (ref (exact $B2)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block (result nullref)
  ;; CHECK-NEXT:    (local.set $1
  ;; CHECK-NEXT:     (struct.new_default $B2)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.set $0
  ;; CHECK-NEXT:     (local.get $1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block (result nullref)
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  (func $A (result (ref $A))
    (ref.cast_desc_eq (ref $A)
      (struct.new_default_desc $A2
        (struct.new_default $B2)
      )
      (struct.new_default $B)
    )
  )
)

(module
  (rec
    (type $A (descriptor $B) (struct))
    (type $B (sub (describes $A) (struct)))
  )
  ;; CHECK:      (type $0 (func))

  ;; CHECK:      (func $test (type $0)
  ;; CHECK-NEXT:  (local $0 (ref none))
  ;; CHECK-NEXT:  (local $1 (ref none))
  ;; CHECK-NEXT:  (block $block
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (br_on_null $block
  ;; CHECK-NEXT:     (block (result (ref none))
  ;; CHECK-NEXT:      (drop
  ;; CHECK-NEXT:       (block (result nullref)
  ;; CHECK-NEXT:        (local.set $1
  ;; CHECK-NEXT:         (ref.as_non_null
  ;; CHECK-NEXT:          (ref.null none)
  ;; CHECK-NEXT:         )
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:        (local.set $0
  ;; CHECK-NEXT:         (local.get $1)
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:        (ref.null none)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (local.get $0)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $test
    ;; After removing the ref.get_desc, the null descriptor falls through, and
    ;; we must update the br_on_null's type, or internal validation errors.
    (block $block
      (drop
        (br_on_null $block
          (ref.get_desc $A
            (struct.new_default_desc $A
              (ref.null none)
            )
          )
        )
      )
      (unreachable)
    )
  )
)

(module
  (rec
    ;; CHECK:      (rec
    ;; CHECK-NEXT:  (type $A (descriptor $B) (struct (field v128)))
    (type $A (descriptor $B) (struct (field v128)))
    ;; CHECK:       (type $B (describes $A) (struct))
    (type $B (describes $A) (struct))
  )

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

  ;; CHECK:      (func $test (type $2)
  ;; CHECK-NEXT:  (local $B (ref null $B))
  ;; CHECK-NEXT:  (local $v v128)
  ;; CHECK-NEXT:  (local $2 v128)
  ;; CHECK-NEXT:  (local $3 (ref none))
  ;; CHECK-NEXT:  (local $4 (ref none))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block (result nullref)
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.tee $v
  ;; CHECK-NEXT:   (block ;; (replaces unreachable StructGet we can't emit)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block
  ;; CHECK-NEXT:      (drop
  ;; CHECK-NEXT:       (block (result nullref)
  ;; CHECK-NEXT:        (local.set $4
  ;; CHECK-NEXT:         (ref.as_non_null
  ;; CHECK-NEXT:          (ref.null none)
  ;; CHECK-NEXT:         )
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:        (local.set $2
  ;; CHECK-NEXT:         (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:        (local.set $3
  ;; CHECK-NEXT:         (local.get $4)
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:        (ref.null none)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (drop
  ;; CHECK-NEXT:       (ref.null none)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (unreachable)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $test
    (local $B (ref null $B))
    (local $v v128)

    ;; We can optimize a few times here. As we do so, the local.set becomes
    ;; unreachable, as its descriptor is null. Later work will replace the
    ;; nested struct.get there, which was unreachable, with a local.get of a
    ;; v128, a concrete type, causing an error as now the local.set is
    ;; unreachable but the child is not. To avoid this problem, we should not
    ;; modify unreachable code.

    (drop
      (ref.as_non_null
        (local.tee $B
          (struct.new_default $B)
        )
      )
    )
    (local.set $v
      (struct.get $A 0
        (ref.cast_desc_eq (ref $A)
          (struct.new_default_desc $A
            (ref.as_non_null
              (ref.null none)
            )
          )
          (ref.as_non_null
            (local.get $B)
          )
        )
      )
    )
  )
)

;; A chain of descriptors, where initial optimizations influence later ones.
(module
  (rec
    ;; CHECK:      (rec
    ;; CHECK-NEXT:  (type $A (shared (descriptor $B) (struct)))
    (type $A (shared (descriptor $B) (struct)))
    ;; CHECK:       (type $B (sub (shared (describes $A) (descriptor $C) (struct))))
    (type $B (sub (shared (describes $A) (descriptor $C) (struct))))
    ;; CHECK:       (type $C (sub (shared (describes $B) (struct))))
    (type $C (sub (shared (describes $B) (struct))))
  )

  ;; CHECK:      (type $3 (func (result (ref (shared any)))))

  ;; CHECK:      (func $test (type $3) (result (ref (shared any)))
  ;; CHECK-NEXT:  (local $temp (ref $C))
  ;; CHECK-NEXT:  (local $1 (ref (shared none)))
  ;; CHECK-NEXT:  (local $2 (ref (shared none)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block (result (ref null (shared none)))
  ;; CHECK-NEXT:    (ref.null (shared none))
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (block
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (block
  ;; CHECK-NEXT:     (drop
  ;; CHECK-NEXT:      (block (result (ref null (shared none)))
  ;; CHECK-NEXT:       (local.set $2
  ;; CHECK-NEXT:        (ref.as_non_null
  ;; CHECK-NEXT:         (ref.null (shared none))
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:       (local.set $1
  ;; CHECK-NEXT:        (local.get $2)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:       (ref.null (shared none))
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (drop
  ;; CHECK-NEXT:      (ref.null (shared none))
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (unreachable)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (block (result (ref null (shared none)))
  ;; CHECK-NEXT:     (ref.null (shared none))
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $test (result (ref (shared any)))
    (local $temp (ref $C))
    (local.set $temp
      ;; We optimize this first, making the |local.get| below unreachable, and
      ;; making that inner ref.cast_desc_eq unreachable, which leads to the
      ;; |struct.new_default $B| being dropped, and in particular having a new
      ;; parent (the drop). We should not get confused and error internally.
      (struct.new_default $C)
    )
    (ref.cast_desc_eq (ref $B)
      (ref.cast_desc_eq (ref $B)
        (struct.new_default_desc $B
          (ref.null (shared none))
        )
        (local.get $temp)
      )
      (struct.new_default $C)
    )
  )
)

(module
  (rec
   ;; CHECK:      (rec
   ;; CHECK-NEXT:  (type $struct (sub (descriptor $desc) (struct)))
   (type $struct (sub (descriptor $desc) (struct)))
   ;; CHECK:       (type $desc (describes $struct) (struct))
   (type $desc (sub final (describes $struct) (struct)))
  )

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

  ;; CHECK:      (func $test (type $2) (result i32)
  ;; CHECK-NEXT:  (local $desc (ref $desc))
  ;; CHECK-NEXT:  (local $1 (ref (exact $desc)))
  ;; CHECK-NEXT:  (local $2 (ref (exact $desc)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block (result nullref)
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (ref.is_null
  ;; CHECK-NEXT:   (block
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block (result nullref)
  ;; CHECK-NEXT:      (local.set $2
  ;; CHECK-NEXT:       (struct.new_default $desc)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (local.set $1
  ;; CHECK-NEXT:       (local.get $2)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (ref.null none)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (ref.null none)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $test (result i32)
    (local $desc (ref $desc))
    (local.set $desc
      (struct.new_default $desc)
    )
    ;; After we optimize the struct.new above, the local.get below will get
    ;; removed, and we will see that the ref.cast_desc_eq traps (the input
    ;; descriptor differs from the one we test, the allocation we just
    ;; removed). When optimizing that, we should not emit invalid IR for the
    ;; ref.is_null: It has an i32 result normally, but in unreachable code it
    ;; must remain unreachable.
    (ref.is_null
      (ref.cast_desc_eq (ref $struct)
        (struct.new_default_desc $struct
          (struct.new_default $desc)
        )
        (local.get $desc)
      )
    )
  )
)

(module
  (rec
    ;; CHECK:      (rec
    ;; CHECK-NEXT:  (type $struct (descriptor $desc) (struct))
    (type $struct (descriptor $desc) (struct))
    ;; CHECK:       (type $desc (sub (describes $struct) (struct (field funcref))))
    (type $desc (sub (describes $struct) (struct (field funcref))))
  )

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

  ;; CHECK:      (func $test (type $2)
  ;; CHECK-NEXT:  (local $desc (ref $desc))
  ;; CHECK-NEXT:  (local $func funcref)
  ;; CHECK-NEXT:  (local $2 funcref)
  ;; CHECK-NEXT:  (local $3 (ref (exact $desc)))
  ;; CHECK-NEXT:  (local $4 (ref (exact $desc)))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block (result nullref)
  ;; CHECK-NEXT:    (local.set $2
  ;; CHECK-NEXT:     (ref.null nofunc)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.tee $func
  ;; CHECK-NEXT:   (block ;; (replaces unreachable StructGet we can't emit)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block ;; (replaces unreachable RefGetDesc we can't emit)
  ;; CHECK-NEXT:      (drop
  ;; CHECK-NEXT:       (block
  ;; CHECK-NEXT:        (drop
  ;; CHECK-NEXT:         (block (result nullref)
  ;; CHECK-NEXT:          (local.set $4
  ;; CHECK-NEXT:           (struct.new_default $desc)
  ;; CHECK-NEXT:          )
  ;; CHECK-NEXT:          (local.set $3
  ;; CHECK-NEXT:           (local.get $4)
  ;; CHECK-NEXT:          )
  ;; CHECK-NEXT:          (ref.null none)
  ;; CHECK-NEXT:         )
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:        (drop
  ;; CHECK-NEXT:         (ref.null none)
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:        (unreachable)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (unreachable)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $test
    (local $desc (ref $desc))
    (local $func funcref)

    (local.set $desc
      (struct.new_default $desc)
    )

    (local.set $func
      (struct.get $desc 0
        ;; This ref.get_desc will become unreachable (as the desc does not
        ;; match, after expanding locals). We should not generate invalid code
        ;; from that point - it is unreachable, and we can leave it as is.
        (ref.get_desc $struct
          (ref.cast_desc_eq (ref $struct)
            (struct.new_default_desc $struct
              (struct.new_default $desc)
            )
            (local.get $desc)
          )
        )
      )
    )
  )
)