;; This file tests validation only, without GC types and subtyping.


;;;;
;;;; WasmFX types
;;;;

(module
  (type $ft1 (func))
  (type $ct1 (cont $ft1))

  (type $ft2 (func (param i32) (result i32)))
  (type $ct2 (cont $ft2))

  (func $test
    (param $p1 (ref cont))
    (param $p2 (ref nocont))
    (param $p3 (ref $ct1))

    (local $x1 (ref cont))
    (local $x2 (ref nocont))
    (local $x3 (ref $ct1))
    (local $x4 (ref $ct2))
    (local $x5 (ref null $ct1))

    ;; nocont <: cont
    (local.set $x1 (local.get $p2))

    ;; nocont <: $ct1
    (local.set $x3 (local.get $p2))

    ;; $ct1 <: $cont
    (local.set $x3 (local.get $p3))

    ;; (ref $ct1) <: (ref null $cont)
    (local.set $x5 (local.get $p3))
   )
)

(assert_invalid
  (module
    (type $ft1 (func))
    (type $ct1 (cont $ft1))

    (type $ft2 (func (param i32) (result i32)))
    (type $ct2 (cont $ft2))

    (func $test
      (param $p1 (ref cont))
      (param $p2 (ref nocont))
      (param $p3 (ref $ct1))

      (local $x1 (ref cont))
      (local $x2 (ref nocont))
      (local $x3 (ref $ct1))
      (local $x4 (ref $ct2))
      (local $x5 (ref null $ct1))

      ;; cont </: nocont
      (local.set $p2 (local.get $p1))
     )
  )
  "type mismatch"
)

(assert_invalid
  (module
    (type $ft1 (func))
    (type $ct1 (cont $ft1))

    (type $ft2 (func (param i32) (result i32)))
    (type $ct2 (cont $ft2))

    (func $test
      (param $p1 (ref cont))
      (param $p2 (ref nocont))
      (param $p3 (ref $ct1))

      (local $x1 (ref cont))
      (local $x2 (ref nocont))
      (local $x3 (ref $ct1))
      (local $x4 (ref $ct2))
      (local $x5 (ref null $ct1))

      ;; $ct1 </: nocont
      (local.set $p2 (local.get $p3))
     )
  )
  "type mismatch"
)

(assert_invalid
  (module
    (type $ft1 (func))
    (type $ct1 (cont $ft1))

    (type $ft2 (func (param i32) (result i32)))
    (type $ct2 (cont $ft2))

    (func $test
      (param $p1 (ref cont))
      (param $p2 (ref nocont))
      (param $p3 (ref $ct1))

      (local $x1 (ref cont))
      (local $x2 (ref nocont))
      (local $x3 (ref $ct1))
      (local $x4 (ref $ct2))
      (local $x5 (ref null $ct1))

      ;; $cont </: $ct1
      (local.set $p3 (local.get $p1))
     )
  )
  "type mismatch"
)

(assert_invalid
  (module
    (type $ft1 (func))
    (type $ct1 (cont $ft1))

    (type $ft2 (func (param i32) (result i32)))
    (type $ct2 (cont $ft2))

    (func $test
      (param $p1 (ref cont))
      (param $p2 (ref nocont))
      (param $p3 (ref $ct1))
      (param $p4 (ref $ct2))
      (param $p5 (ref null $ct1))


      (local $x1 (ref cont))
      (local $x2 (ref nocont))
      (local $x3 (ref $ct1))
      (local $x4 (ref $ct2))
      (local $x5 (ref null $ct1))

      ;; (ref null $ct1) </: (ref $cont)
      (local.set $x3 (local.get $p5))
     )
  )
  "type mismatch"
)

(assert_invalid
  (module
    (type $ft1 (func))
    (type $ct1 (cont $ft1))

    (type $ft2 (func (param i32) (result i32)))
    (type $ct2 (cont $ft2))

    (func $test
      (param $p1 (ref cont))
      (param $p2 (ref nocont))
      (param $p3 (ref $ct1))
      (param $p4 (ref $ct2))
      (param $p5 (ref null $ct1))


      (local $x1 (ref cont))
      (local $x2 (ref nocont))
      (local $x3 (ref $ct1))
      (local $x4 (ref $ct2))
      (local $x5 (ref null $ct1))

      ;; (ref $ct1) </: (ref $ct2)
      (local.set $p4 (local.get $p3))
     )
  )
  "type mismatch"
)

;;;;
;;;; cont_bind instructions
;;;;

(module
  (type $ft0 (func (result i32)))
  (type $ct0 (cont $ft0))

  (type $ft1 (func (param i32) (result i32)))
  (type $ct1 (cont $ft1))

  (type $ft2 (func (param i64 i32) (result i32)))
  (type $ct2 (cont $ft2))


  (func $test1
    (param $p_ct1 (ref null $ct1))
    (result (ref $ct0))

    ;; cont.bind takes nullable ref, returns non-nullable one
    (i32.const 123)
    (local.get $p_ct1)
    (cont.bind $ct1 $ct0)
  )

  (func $test2
    (param $p_ct2 (ref $ct2))
    (result (ref $ct1))

    ;; cont.bind does not have to apply continuation fully
    (i64.const 123)
    (local.get $p_ct2)
    (cont.bind $ct2 $ct1)
  )

  (func $test3
    (param $p_ct1 (ref $ct1))
    (result (ref $ct1))

    ;; cont.bind can take same type twice, not actually apply anything
    (local.get $p_ct1)
    (cont.bind $ct1 $ct1)
  )


 )

(assert_invalid

  (module
    (type $ft0 (func (result i32)))
    (type $ct0 (cont $ft0))

    (func $error
      (param $p_ft0 (ref $ft0))
      ;; error: non-continuation type on cont.bind
      (local.get $p_ft0)
      (cont.bind $ft0 $ft0)
      (drop)
    )
  )
  "non-continuation type"
)

  ;; cont.new type mismatch: passing a continuation reference to cont.new instead of function reference
  ;; This is actually just checking type-matching, not cont.new specific:
  ;; (ref null $ct1) is not a subtype of (ref null $ft1)

(assert_invalid

  (module
    (type $ft0 (func (result i32)))
    (type $ct0 (cont $ft0))

    (type $ft1 (func (param i32) (result i32)))
    (type $ct1 (cont $ft1))

    (func $error
      (param $p_ct1 (ref $ct1))
      ;; cont.bind type mismatch: passing wrong kind of continuation.
      ;; This is actually just checking type-matching, not cont.bind specific.
      (local.get $p_ct1)
      (cont.bind $ct0 $ct0)
      (drop)
    )
  )
  "type mismatch"
)

(assert_invalid

  (module
    (type $ft0 (func (result i32)))
    (type $ct0 (cont $ft0))

    (type $ft1 (func (param i32) (result i32)))
    (type $ct1 (cont $ft1))

    (type $ft2 (func (param i64 i32) (result i32)))
    (type $ct2 (cont $ft2))


    (type $ft1_alt (func (param i64) (result i32)))
    (type $ct1_alt (cont $ft1_alt))

    (func $error
      (param $p_ct2 (ref $ct2))
      ;; error: two continuation types not agreeing on arg types
      (i64.const 123)
      (local.get $p_ct2)
      (cont.bind $ct2 $ct1_alt)
      (drop)
    )
  )
  "type mismatch"
)

(assert_invalid

  (module
    (type $ft0 (func (result i32)))
    (type $ct0 (cont $ft0))

    (type $ft1 (func (param i32) (result i32)))
    (type $ct1 (cont $ft1))

    (type $ft2 (func (param i64 i32) (result i32)))
    (type $ct2 (cont $ft2))


    (type $ft1_alt (func (param i32) (result i64)))
    (type $ct1_alt (cont $ft1_alt))

    (func $error
      (param $p_ct2 (ref $ct2))
      ;; error: two continuation types not agreeing on return types
      (i64.const 123)
      (local.get $p_ct2)
      (cont.bind $ct2 $ct1_alt)
      (drop)
    )
  )
  "type mismatch"
)

(assert_invalid

  (module
    (type $ft0 (func (result i32)))
    (type $ct0 (cont $ft0))

    (type $ft1 (func (param i32) (result i32)))
    (type $ct1 (cont $ft1))

    (func $error
      (param $p_ct0 (ref $ct0))
      ;; error: trying to go from 0 to 1 args
      (local.get $p_ct0)
      (cont.bind $ct0 $ct1)
      (drop)
    )
  )
  "type mismatch"
)

(assert_invalid

  (module
    (type $ft0 (func (result i32)))
    (type $ct0 (cont $ft0))

    (type $ft1 (func (param i32) (result i32)))
    (type $ct1 (cont $ft1))


    (func $error
      (param $p_ct1 (ref $ct1))
      ;; error: Insufficient arguments::
      ;; This is really testing the general application of arguments to instructions,
      ;; but trying to trick parsers of the folded form
      (cont.bind $ct1 $ct0 (local.get $p_ct1))
      (drop)
    )
  )
  "type mismatch"
)

(assert_invalid

  (module
    (type $ft0 (func (result i32)))
    (type $ct0 (cont $ft0))

    (type $ft1 (func (param i32) (result i32)))
    (type $ct1 (cont $ft1))

    (func $error
      (param $p_ct1 (ref $ct1))
      ;; error: Too many arguments::
      ;; This is really testing the general application of arguments to instructions,
      ;; but trying to trick parsers of the folded form
      (cont.bind $ct1 $ct0 (i32.const 123) (i32.const 123) (local.get $p_ct1))
      (drop)
    )
  )
  "type mismatch"
)

;;;;
;;;; cont_new instructions
;;;;

(module
  (type $ft1 (func (param i32) (result i32)))
  (type $ct1 (cont $ft1))

  (type $ft2 (func (param i32 i32) (result i32)))
  (type $ct2 (cont $ft2))

  (func $f1 (export "f1") (param i32) (result i32)
    (i32.const 123)
  )

  (func $drop_ct1 (param $c (ref $ct1)))

  ;; simple smoke test
  (func $test_good1 (param $x (ref $ft1)) (result (ref $ct1))
    (local.get $x)
    (cont.new $ct1)
  )

  ;; cont.new takes a nullable function
  (func $test_good2 (param $x (ref null $ft1)) (result (ref $ct1))
    (local.get $x)
    (cont.new $ct1)
  )


)

(assert_invalid
  (module
    (type $ft1 (func (param i32) (result i32)))
    (type $ct1 (cont $ft1))

    (func $bad (param $x (ref null $ct1)) (result (ref $ct1))
      (local.get $x)
      (cont.new $ct1)
    )
  )
  ;; cont.new type mismatch: passing a continuation reference to cont.new instead of function reference
  ;; This is actually just checking type-matching, not cont.new specific:
  ;; (ref null $ct1) is not a subtype of (ref null $ft1)
  "type mismatch"
)

(assert_invalid
  (module
    (type $ft1 (func (param i32) (result i32)))
    (type $ct1 (cont $ft1))

    (type $ft2 (func (param i32 i32) (result i32)))
    (type $ct2 (cont $ft2))

    (func $drop_ct1 (param $c (ref $ct1)))

    (func $bad (param $x (ref null $ft2)) (result (ref $ct1))
      (local.get $x)
      (cont.new $ct1)
    )
  )
  ;; cont.new type mismatch: passing function of wrong type to cont.new
  ;; This is actually just checking type-matching, not cont.new specific:
  ;; (ref null $ft2) is not a subtype of (ref null $ft1)
  "type mismatch"
)

(assert_invalid
  (module
    (type $ft1 (func (param i32) (result i32)))
    (type $ct1 (cont $ft1))

    (func $bad (param $x (ref null $ct1))
      (local.get $x)
      (cont.new $ft1)
      (drop)
    )
  )
  ;; non-continuation type on cont.new
  "non-continuation type 0"
)

;;;;
;;;; resume instructions
;;;;


(module
  (type $ft0 (func))
  (type $ct0 (cont $ft0))

  (type $ft1 (func (param f32) (result f64)))
  (type $ct1 (cont $ft1))

  (type $ft2 (func (param i64) (result f64)))
  (type $ct2 (cont $ft2))

  (type $ft3 (func (param i32) (result f64)))
  (type $ct3 (cont $ft3))

  (tag $t0)
  (tag $t1)
  (tag $t2 (param i32) (result i64))
  (tag $t3 (param i64) (result i32))

  ;; Multiple tags, all types handled correctly
  (func $test0 (param $x (ref $ct1)) (result f64)
    (block $handler0 (result i32 (ref $ct2))
      (block $handler1 (result i64 (ref $ct3))
        (f32.const 1.23)
        (local.get $x)
        (resume $ct1 (on $t2 $handler0) (on $t3 $handler1))
        (return)
      )
      (unreachable)
    )
    (unreachable)
  )

  ;; Same as $test0, but we provide two handlers for the same tag
  (func $test1 (param $x (ref $ct1)) (result f64)
    (block $handler0 (result i32 (ref $ct2))
      (block $handler1 (result i32 (ref $ct2))
        (f32.const 1.23)
        (local.get $x)
        (resume $ct1 (on $t2 $handler0) (on $t2 $handler1))
        (return)
      )
      (unreachable)
    )
    (unreachable)
  )

  ;; resume takes a nullable reference
  (func $test2 (param $x (ref null $ct0))
    (local.get $x)
    (resume $ct0)
  )

  ;; handler blocks take the continuation as nullable ref
  (func $test3 (param $x (ref $ct0))
    (block $handler (result (ref null $ct0))
      (local.get $x)
      (resume $ct0 (on $t0 $handler))
      (return)
    )
    (unreachable)
  )

  ;; Nothing wrong with using the same handler block for multiple tags
  (func $test4 (param $x (ref $ct0))
    (block $handler (result (ref null $ct0))
      (local.get $x)
      (resume $ct0 (on $t0 $handler) (on $t1 $handler))
      (return)
    )
    (unreachable)
  )

  ;; handler block can have params
  (func $test5 (param $x (ref $ct0))
    (local.get $x)
    (block $handler (param (ref $ct0)) (result (ref $ct0))
      (resume $ct0 (on $t0 $handler))
      (return)
    )
    (unreachable)
  )
)

;; tag does not exist
(assert_invalid
  (module
    (type $ft0 (func))
    (type $ct0 (cont $ft0))
    ;;(tag $t0)
    (func $error (param $x (ref $ct0))
      (block $handler (result (ref null $ct0))
        (local.get $x)
        (resume $ct0 (on 0 $handler))
        (return)
      )
      (unreachable)
    )

  )
  "unknown tag"
)

;; non-continuation type on resume
(assert_invalid
  (module
    (type $ft0 (func))
    (type $ct0 (cont $ft0))
    (func $error (param $x (ref $ct0))
      (local.get $x)
      (resume $ft0)
    )

  )
  "non-continuation type"
)

;; non-continuation type on handler
(assert_invalid
  (module
    (type $ft0 (func))
    (type $ct0 (cont $ft0))
    (tag $t0)
    (func $test1 (param $x (ref $ct0))
      (block $handler (result (ref $ft0))
        (local.get $x)
        (resume $ct0 (on $t0 $handler))
        (return)
      )
      (unreachable)
    )

  )
  "non-continuation type"
)

(assert_invalid
  (module
    (type $ft (func (param i32)))
    (type $ct (cont $ft))

    (func $error
      (param $p (ref $ct))
      ;; error: Too many arguments::
      ;; This is really testing the general application of arguments to instructions,
      ;; but trying to trick parsers of the folded form
      (resume $ct (i32.const 123) (i32.const 123) (local.get $p))
    )
  )
  "type mismatch"
)

(assert_invalid
  (module
    (type $ft (func (param i32)))
    (type $ct (cont $ft))

    (func $error
      (param $p (ref $ct))
      ;; error: Too few arguments::
      ;; This is really testing the general application of arguments to instructions,
      ;; but trying to trick parsers of the folded form
      (resume $ct (local.get $p))
    )
  )
  "type mismatch"
)

(assert_invalid
  (module
    (type $ft0 (func (param i32)))
    (type $ct0 (cont $ft0))

    (type $ft1 (func (param i64)))
    (type $ct1 (cont $ft1))

    (func $error
      (param $p (ref $ct1))
      ;; error: Mismatch between annotation on resume and actual argument
      ;; This is really testing the general application of arguments to instructions.
      (resume $ct0 (i32.const 123) (local.get $p))
    )
  )
  "type mismatch"
)

(assert_invalid
  (module
    (type $ft0 (func))
    (type $ct0 (cont $ft0))

    (tag $t (param i32))

    (func $error
      (param $p (ref $ct0))
      (block $handler (result (ref $ct0))
        ;; error: handler block has insufficient number of results
        (local.get $p)
        (resume $ct0 (on $t $handler))
        (return)
      )
      (unreachable)
    )
  )
  "type mismatch"
)

(assert_invalid
  (module
    (type $ft0 (func))
    (type $ct0 (cont $ft0))

    (tag $t (param i32))

    (func $error
      (param $p (ref $ct0))
      (block $handler (result i32 i32 (ref $ct0))
        ;; error: handler block has too many results
        (local.get $p)
        (resume $ct0 (on $t $handler))
        (return)
      )
      (unreachable)
    )
  )
  "type mismatch"
)

(assert_invalid
  (module
    (type $ft0 (func))
    (type $ct0 (cont $ft0))

    (tag $t (param i32))

    (func $error
      (param $p (ref $ct0))
      (block $handler (result i64 (ref $ct0))
        ;; error: type mismatch in non-continuation handler result type
        (local.get $p)
        (resume $ct0 (on $t $handler))
        (return)
      )
      (unreachable)
    )
  )
  "type mismatch"
)

(assert_invalid
  (module
    (type $ft0 (func))
    (type $ct0 (cont $ft0))

    (type $ft1 (func (param i32)))
    (type $ct1 (cont $ft1))

    (tag $t (param i32))

    (func $error
      (param $p (ref $ct0))
      (block $handler (result i32 (ref $ct1))
        ;; error: type mismatch in continuation handler result type
        (local.get $p)
        (resume $ct0 (on $t $handler))
        (return)
      )
      (unreachable)
    )
  )
  "type mismatch"
)

;;;;
;;;; suspend instructions
;;;;

(module
  (tag $t (param i64 i32) (result i32 i64))

  (func $test (result i32 i64)
    (i64.const 123)
    (i32.const 123)
    (suspend $t)
  )
)


(assert_invalid
  (module
    (tag $t (param i64 i32) (result i32 i64))

    (func $test (result i32 i64)
      ;; error: Insufficient arguments::
      ;; This is really testing the general application of arguments to instructions,
      ;; but trying to trick parsers of the folded form

      (suspend $t (i64.const 123))
    )
  )
  "type mismatch"
)

(assert_invalid
  (module
    (tag $t (param i32) (result i32 i64))

    (func $test (result i32 i64)
      ;; error: Too many arguments:
      ;; This is really testing the general application of arguments to instructions,
      ;; but trying to trick parsers of the folded form

      (suspend $t (i64.const 123) (i32.const 123))
    )
  )
  "type mismatch"
)

(assert_invalid
  (module
    (func $test
      ;; error: Tag does not exist
      (suspend 0)
    )
  )
  "unknown tag"
)


;; Illegal casts

(assert_invalid
  (module
    (func (drop (ref.test contref (unreachable))))
  )
  "invalid cast"
)
(assert_invalid
  (module
    (func (drop (ref.test nullcontref (unreachable))))
  )
  "invalid cast"
)
(assert_invalid
  (module
    (type $f (func))
    (type $c (cont $f))
    (func (drop (ref.test (ref $c) (unreachable))))
  )
  "invalid cast"
)

(assert_invalid
  (module
    (func (drop (ref.cast contref (unreachable))))
  )
  "invalid cast"
)
(assert_invalid
  (module
    (func (drop (ref.cast nullcontref (unreachable))))
  )
  "invalid cast"
)
(assert_invalid
  (module
    (type $f (func))
    (type $c (cont $f))
    (func (drop (ref.cast (ref $c) (unreachable))))
  )
  "invalid cast"
)

(assert_invalid
  (module
    (func
      (block (result contref) (br_on_cast 0 contref contref (unreachable)))
      (drop)
    )
  )
  "invalid cast"
)
(assert_invalid
  (module
    (func
      (block (result contref) (br_on_cast 0 nullcontref nullcontref (unreachable)))
      (drop)
    )
  )
  "invalid cast"
)
(assert_invalid
  (module
    (type $f (func))
    (type $c (cont $f))
    (func
      (block (result contref) (br_on_cast 0 (ref $c) (ref $c) (unreachable)))
      (drop)
    )
  )
  "invalid cast"
)

(assert_invalid
  (module
    (func
      (block (result contref) (br_on_cast_fail 0 contref contref (unreachable)))
      (drop)
    )
  )
  "invalid cast"
)
(assert_invalid
  (module
    (func
      (block (result contref) (br_on_cast_fail 0 nullcontref nullcontref (unreachable)))
      (drop)
    )
  )
  "invalid cast"
)
(assert_invalid
  (module
    (type $f (func))
    (type $c (cont $f))
    (func
      (block (result contref) (br_on_cast_fail 0 (ref $c) (ref $c) (unreachable)))
      (drop)
    )
  )
  "invalid cast"
)