;; Auxiliary module to import from

(module
  (func (export "func"))
  (func (export "func-i32") (param i32))
  (func (export "func-f32") (param f32))
  (func (export "func->i32") (result i32) (i32.const 22))
  (func (export "func->f32") (result f32) (f32.const 11))
  (func (export "func-i32->i32") (param i32) (result i32) (local.get 0))
  (func (export "func-i64->i64") (param i64) (result i64) (local.get 0))
  (global (export "global-i32") i32 (i32.const 55))
  (global (export "global-f32") f32 (f32.const 44))
  ;;; FIXME: Exporting a mutable global is currently not supported. Make mutable
  ;;; when support is added.
  (global (export "global-mut-i64") i64 (i64.const 66))
  (table (export "table-10-inf") 10 funcref)
  (table (export "table-10-20") 10 20 funcref)
  (memory (export "memory-2-inf") 2)
  ;; Multiple memories are not yet supported
  ;; (memory (export "memory-2-4") 2 4)
)

(register "test")


;; Functions

(module
  (type $func_i32 (func (param i32)))
  (type $func_i64 (func (param i64)))
  (type $func_f32 (func (param f32)))
  (type $func_f64 (func (param f64)))

  (import "spectest" "print_i32" (func (param i32)))
  ;; JavaScript can't handle i64 yet.
  ;; (func (import "spectest" "print_i64") (param i64))
  (import "spectest" "print_i32" (func $print_i32 (param i32)))
  ;; JavaScript can't handle i64 yet.
  ;; (import "spectest" "print_i64" (func $print_i64 (param i64)))
  (import "spectest" "print_f32" (func $print_f32 (param f32)))
  (import "spectest" "print_f64" (func $print_f64 (param f64)))
  (import "spectest" "print_i32_f32" (func $print_i32_f32 (param i32 f32)))
  (import "spectest" "print_f64_f64" (func $print_f64_f64 (param f64 f64)))
  (func $print_i32-2 (import "spectest" "print_i32") (param i32))
  (func $print_f64-2 (import "spectest" "print_f64") (param f64))
  (import "test" "func-i64->i64" (func $i64->i64 (param i64) (result i64)))

  (func (export "p1") (import "spectest" "print_i32") (param i32))
  (func $p (export "p2") (import "spectest" "print_i32") (param i32))
  (func (import "spectest" "print_i32") (param i32))
  (func (export "p5") (import "spectest" "print_i32") (type 0))
  (func (export "p6") (import "spectest" "print_i32") (type 0) (param i32) (result))

  ;; (export "p3" (func $print_i32))
  ;; (export "p4" (func $print_i32))

  (import "spectest" "print_i32" (func (type $forward)))
  (func (import "spectest" "print_i32") (type $forward))
  (type $forward (func (param i32)))

  (table funcref (elem $print_i32 $print_f64))

  (func (export "print32") (param $i i32)
    (local $x f32)
    (local.set $x (f32.convert_i32_s (local.get $i)))
    (call 0 (local.get $i))
    (call $print_i32_f32
      (i32.add (local.get $i) (i32.const 1))
      (f32.const 42)
    )
    (call $print_i32 (local.get $i))
    (call $print_i32-2 (local.get $i))
    (call $print_f32 (local.get $x))
    (call_indirect (type $func_i32) (local.get $i) (i32.const 0))
  )

  (func (export "print64") (param $i i64)
    (local $x f64)
    (local.set $x (f64.convert_i64_s (call $i64->i64 (local.get $i))))
    ;; JavaScript can't handle i64 yet.
    ;; (call 1 (local.get $i))
    (call $print_f64_f64
      (f64.add (local.get $x) (f64.const 1))
      (f64.const 53)
    )
    ;; JavaScript can't handle i64 yet.
    ;; (call $print_i64 (local.get $i))
    (call $print_f64 (local.get $x))
    (call $print_f64-2 (local.get $x))
    (call_indirect (type $func_f64) (local.get $x) (i32.const 1))
  )
)

(assert_return (invoke "print32" (i32.const 13)))
(assert_return (invoke "print64" (i64.const 24)))

(assert_invalid
  (module
    (type (func (result i32)))
    (import "test" "func" (func (type 1)))
  )
  "unknown type"
)

;; Export sharing name with import
(module
  (import "spectest" "print_i32" (func $imported_print (param i32)))
  (func (export "print_i32") (param $i i32)
    (call $imported_print (local.get $i))
  )
)

(assert_return (invoke "print_i32" (i32.const 13)))

;; Export sharing name with import
(module
  (import "spectest" "print_i32" (func $imported_print (param i32)))
  (func (export "print_i32") (param $i i32) (param $j i32) (result i32)
    (i32.add (local.get $i) (local.get $j))
  )
)

(assert_return (invoke "print_i32" (i32.const 5) (i32.const 11)) (i32.const 16))

(module (import "test" "func" (func)))
(module (import "test" "func-i32" (func (param i32))))
(module (import "test" "func-f32" (func (param f32))))
(module (import "test" "func->i32" (func (result i32))))
(module (import "test" "func->f32" (func (result f32))))
(module (import "test" "func-i32->i32" (func (param i32) (result i32))))
(module (import "test" "func-i64->i64" (func (param i64) (result i64))))

;; (assert_unlinkable
;;   (module (import "test" "unknown" (func)))
;;   "unknown import"
;; )
;; (assert_unlinkable
;;   (module (import "spectest" "unknown" (func)))
;;   "unknown import"
;; )

;; (assert_unlinkable
;;   (module (import "test" "func" (func (param i32))))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "func" (func (result i32))))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "func" (func (param i32) (result i32))))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "func-i32" (func)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "func-i32" (func (result i32))))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "func-i32" (func (param f32))))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "func-i32" (func (param i64))))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "func-i32" (func (param i32) (result i32))))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "func->i32" (func)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "func->i32" (func (param i32))))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "func->i32" (func (result f32))))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "func->i32" (func (result i64))))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "func->i32" (func (param i32) (result i32))))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "func-i32->i32" (func)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "func-i32->i32" (func (param i32))))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "func-i32->i32" (func (result i32))))
;;   "incompatible import type"
;; )

;; (assert_unlinkable
;;   (module (import "test" "global-i32" (func (result i32))))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "table-10-inf" (func)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "memory-2-inf" (func)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "spectest" "global_i32" (func)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "spectest" "table" (func)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "spectest" "memory" (func)))
;;   "incompatible import type"
;; )


;; Globals

(module
  (import "spectest" "global_i32" (global i32))
  (global (import "spectest" "global_i32") i32)

  (import "spectest" "global_i32" (global $x i32))
  (global $y (import "spectest" "global_i32") i32)

  ;; JavaScript can't handle i64 yet.
  ;; (import "spectest" "global_i64" (global i64))
  (import "spectest" "global_f32" (global f32))
  (import "spectest" "global_f64" (global f64))

  (func (export "get-0") (result i32) (global.get 0))
  (func (export "get-1") (result i32) (global.get 1))
  (func (export "get-x") (result i32) (global.get $x))
  (func (export "get-y") (result i32) (global.get $y))
)

(assert_return (invoke "get-0") (i32.const 666))
(assert_return (invoke "get-1") (i32.const 666))
(assert_return (invoke "get-x") (i32.const 666))
(assert_return (invoke "get-y") (i32.const 666))

(module (import "test" "global-i32" (global i32)))
(module (import "test" "global-f32" (global f32)))
(module (import "test" "global-mut-i64" (global (mut i64))))

;; (assert_unlinkable
;;   (module (import "test" "unknown" (global i32)))
;;   "unknown import"
;; )
;; (assert_unlinkable
;;   (module (import "spectest" "unknown" (global i32)))
;;   "unknown import"
;; )

;; (assert_unlinkable
;;   (module (import "test" "global-i32" (global i64)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "global-i32" (global f32)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "global-i32" (global f64)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "global-i32" (global (mut i32))))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "global-f32" (global i32)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "global-f32" (global i64)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "global-f32" (global f64)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "global-f32" (global (mut f32))))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "global-mut-i64" (global (mut i32))))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "global-mut-i64" (global (mut f32))))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "global-mut-i64" (global (mut f64))))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "global-mut-i64" (global i64)))
;;   "incompatible import type"
;; )

;; (assert_unlinkable
;;   (module (import "test" "func" (global i32)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "table-10-inf" (global i32)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "memory-2-inf" (global i32)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "spectest" "print_i32" (global i32)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "spectest" "table" (global i32)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "spectest" "memory" (global i32)))
;;   "incompatible import type"
;; )


;; Tables

(module
  (type (func (result i32)))
  (import "spectest" "table" (table $tab 10 20 funcref))
  (elem (table $tab) (i32.const 1) func $f $g)

  (func (export "call") (param i32) (result i32)
    (call_indirect $tab (type 0) (local.get 0))
  )
  (func $f (result i32) (i32.const 11))
  (func $g (result i32) (i32.const 22))
)

(assert_trap (invoke "call" (i32.const 0)) "uninitialized element")
(assert_return (invoke "call" (i32.const 1)) (i32.const 11))
(assert_return (invoke "call" (i32.const 2)) (i32.const 22))
(assert_trap (invoke "call" (i32.const 3)) "uninitialized element")
(assert_trap (invoke "call" (i32.const 100)) "undefined element")


(module
  (type (func (result i32)))
  (table $tab (import "spectest" "table") 10 20 funcref)
  (elem (table $tab) (i32.const 1) func $f $g)

  (func (export "call") (param i32) (result i32)
    (call_indirect $tab (type 0) (local.get 0))
  )
  (func $f (result i32) (i32.const 11))
  (func $g (result i32) (i32.const 22))
)

(assert_trap (invoke "call" (i32.const 0)) "uninitialized element")
(assert_return (invoke "call" (i32.const 1)) (i32.const 11))
(assert_return (invoke "call" (i32.const 2)) (i32.const 22))
(assert_trap (invoke "call" (i32.const 3)) "uninitialized element")
(assert_trap (invoke "call" (i32.const 100)) "undefined element")


(module
  (import "spectest" "table" (table 0 funcref))
  (import "spectest" "table" (table 0 funcref))
  (table 10 funcref)
  (table 10 funcref)
)

(module (import "test" "table-10-inf" (table 10 funcref)))
(module (import "test" "table-10-inf" (table 5 funcref)))
(module (import "test" "table-10-inf" (table 0 funcref)))
(module (import "test" "table-10-20" (table 10 funcref)))
(module (import "test" "table-10-20" (table 5 funcref)))
(module (import "test" "table-10-20" (table 0 funcref)))
(module (import "test" "table-10-20" (table 10 20 funcref)))
(module (import "test" "table-10-20" (table 5 20 funcref)))
(module (import "test" "table-10-20" (table 0 20 funcref)))
(module (import "test" "table-10-20" (table 10 25 funcref)))
(module (import "test" "table-10-20" (table 5 25 funcref)))
(module (import "test" "table-10-20" (table 0 25 funcref)))
(module (import "spectest" "table" (table 10 funcref)))
(module (import "spectest" "table" (table 5 funcref)))
(module (import "spectest" "table" (table 0 funcref)))
(module (import "spectest" "table" (table 10 20 funcref)))
(module (import "spectest" "table" (table 5 20 funcref)))
(module (import "spectest" "table" (table 0 20 funcref)))
(module (import "spectest" "table" (table 10 25 funcref)))
(module (import "spectest" "table" (table 5 25 funcref)))

;; (assert_unlinkable
;;   (module (import "test" "unknown" (table 10 funcref)))
;;   "unknown import"
;; )
;; (assert_unlinkable
;;   (module (import "spectest" "unknown" (table 10 funcref)))
;;   "unknown import"
;; )

;; (assert_unlinkable
;;   (module (import "test" "table-10-inf" (table 12 funcref)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "table-10-inf" (table 10 20 funcref)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "table-10-20" (table 12 20 funcref)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "table-10-20" (table 10 18 funcref)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "spectest" "table" (table 12 funcref)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "spectest" "table" (table 10 15 funcref)))
;;   "incompatible import type"
;; )

;; (assert_unlinkable
;;   (module (import "test" "func" (table 10 funcref)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "global-i32" (table 10 funcref)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "memory-2-inf" (table 10 funcref)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "spectest" "print_i32" (table 10 funcref)))
;;   "incompatible import type"
;; )


;; Memories

(module
  (import "spectest" "memory" (memory 1 2))
  (data (memory 0) (i32.const 10) "\10")

  (func (export "load") (param i32) (result i32) (i32.load (local.get 0)))
)

(assert_return (invoke "load" (i32.const 0)) (i32.const 0))
(assert_return (invoke "load" (i32.const 10)) (i32.const 16))
(assert_return (invoke "load" (i32.const 8)) (i32.const 0x100000))
(assert_trap (invoke "load" (i32.const 1000000)) "out of bounds memory access")

(module
  (memory (import "spectest" "memory") 1 2)
  (data (memory 0) (i32.const 10) "\10")

  (func (export "load") (param i32) (result i32) (i32.load (local.get 0)))
)
(assert_return (invoke "load" (i32.const 0)) (i32.const 0))
(assert_return (invoke "load" (i32.const 10)) (i32.const 16))
(assert_return (invoke "load" (i32.const 8)) (i32.const 0x100000))
(assert_trap (invoke "load" (i32.const 1000000)) "out of bounds memory access")

(module (import "test" "memory-2-inf" (memory 2)))
(module (import "test" "memory-2-inf" (memory 1)))
(module (import "test" "memory-2-inf" (memory 0)))
(module (import "spectest" "memory" (memory 1)))
(module (import "spectest" "memory" (memory 0)))
(module (import "spectest" "memory" (memory 1 2)))
(module (import "spectest" "memory" (memory 0 2)))
(module (import "spectest" "memory" (memory 1 3)))
(module (import "spectest" "memory" (memory 0 3)))

;; (assert_unlinkable
;;   (module (import "test" "unknown" (memory 1)))
;;   "unknown import"
;; )
;; (assert_unlinkable
;;   (module (import "spectest" "unknown" (memory 1)))
;;   "unknown import"
;; )

;; (assert_unlinkable
;;   (module (import "test" "memory-2-inf" (memory 3)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "memory-2-inf" (memory 2 3)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "spectest" "memory" (memory 2)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "spectest" "memory" (memory 1 1)))
;;   "incompatible import type"
;; )

;; (assert_unlinkable
;;   (module (import "test" "func-i32" (memory 1)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "global-i32" (memory 1)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "test" "table-10-inf" (memory 1)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "spectest" "print_i32" (memory 1)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "spectest" "global_i32" (memory 1)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "spectest" "table" (memory 1)))
;;   "incompatible import type"
;; )

;; (assert_unlinkable
;;   (module (import "spectest" "memory" (memory 2)))
;;   "incompatible import type"
;; )
;; (assert_unlinkable
;;   (module (import "spectest" "memory" (memory 1 1)))
;;   "incompatible import type"
;; )

(module
  (import "spectest" "memory" (memory 0 3))  ;; actual has max size 2
  (func (export "grow") (param i32) (result i32) (memory.grow (local.get 0)))
)
(assert_return (invoke "grow" (i32.const 0)) (i32.const 1))
(assert_return (invoke "grow" (i32.const 1)) (i32.const 1))
(assert_return (invoke "grow" (i32.const 0)) (i32.const 2))
(assert_return (invoke "grow" (i32.const 1)) (i32.const -1))
(assert_return (invoke "grow" (i32.const 0)) (i32.const 2))

(module $Mgm
  (memory (export "memory") 1) ;; initial size is 1
  (func (export "grow") (result i32) (memory.grow (i32.const 1)))
)
(register "grown-memory" $Mgm)
(assert_return (invoke $Mgm "grow") (i32.const 1)) ;; now size is 2
(module $Mgim1
  ;; imported memory limits should match, because external memory size is 2 now
  (memory (import "grown-memory" "memory") 2)
  (export "memory" (memory 0))
  (func (export "grow") (result i32) (memory.grow (i32.const 1)))
)
(register "grown-imported-memory" $Mgim1)
(assert_return (invoke $Mgim1 "grow") (i32.const 2)) ;; now size is 3
(module $Mgim2
  ;; imported memory limits should match, because external memory size is 3 now
  (import "grown-imported-memory" "memory" (memory 3))
  (func (export "size") (result i32) (memory.size))
)
(assert_return (invoke $Mgim2 "size") (i32.const 3))


;; Syntax errors

(assert_malformed
  (module quote "(func) (import \"\" \"\" (func))")
  "import after function"
)
(assert_malformed
  (module quote "(func) (import \"\" \"\" (global i64))")
  "import after function"
)
(assert_malformed
  (module quote "(func) (import \"\" \"\" (table 0 funcref))")
  "import after function"
)
(assert_malformed
  (module quote "(func) (import \"\" \"\" (memory 0))")
  "import after function"
)

(assert_malformed
  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (func))")
  "import after global"
)
(assert_malformed
  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (global f32))")
  "import after global"
)
(assert_malformed
  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (table 0 funcref))")
  "import after global"
)
(assert_malformed
  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (memory 0))")
  "import after global"
)

(assert_malformed
  (module quote "(table 0 funcref) (import \"\" \"\" (func))")
  "import after table"
)
(assert_malformed
  (module quote "(table 0 funcref) (import \"\" \"\" (global i32))")
  "import after table"
)
(assert_malformed
  (module quote "(table 0 funcref) (import \"\" \"\" (table 0 funcref))")
  "import after table"
)
(assert_malformed
  (module quote "(table 0 funcref) (import \"\" \"\" (memory 0))")
  "import after table"
)

(assert_malformed
  (module quote "(memory 0) (import \"\" \"\" (func))")
  "import after memory"
)
(assert_malformed
  (module quote "(memory 0) (import \"\" \"\" (global i32))")
  "import after memory"
)
(assert_malformed
  (module quote "(memory 0) (import \"\" \"\" (table 1 3 funcref))")
  "import after memory"
)
(assert_malformed
  (module quote "(memory 0) (import \"\" \"\" (memory 1 2))")
  "import after memory"
)

;; This module is required to validate, regardless of whether it can be
;; linked. Overloading is not possible in wasm itself, but it is possible
;; in modules from which wasm can import.
(module)
(register "not wasm")
;; (assert_unlinkable
;;   (module
;;     (import "not wasm" "overloaded" (func))
;;     (import "not wasm" "overloaded" (func (param i32)))
;;     (import "not wasm" "overloaded" (func (param i32 i32)))
;;     (import "not wasm" "overloaded" (func (param i64)))
;;     (import "not wasm" "overloaded" (func (param f32)))
;;     (import "not wasm" "overloaded" (func (param f64)))
;;     (import "not wasm" "overloaded" (func (result i32)))
;;     (import "not wasm" "overloaded" (func (result i64)))
;;     (import "not wasm" "overloaded" (func (result f32)))
;;     (import "not wasm" "overloaded" (func (result f64)))
;;     (import "not wasm" "overloaded" (global i32))
;;     (import "not wasm" "overloaded" (global i64))
;;     (import "not wasm" "overloaded" (global f32))
;;     (import "not wasm" "overloaded" (global f64))
;;     (import "not wasm" "overloaded" (table 0 funcref))
;;     (import "not wasm" "overloaded" (memory 0))
;;   )
;;   "unknown import"
;; )