/* Copyright 2021 Mozilla Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// ./test/core/gc/array.wast

// ./test/core/gc/array.wast:3
let $0 = instantiate(`(module
  (type (array i8))
  (type (array i16))
  (type (array i32))
  (type (array i64))
  (type (array f32))
  (type (array f64))
  (type (array anyref))
  (type (array (ref struct)))
  (type (array (ref 0)))
  (type (array (ref null 1)))
  (type (array (mut i8)))
  (type (array (mut i16)))
  (type (array (mut i32)))
  (type (array (mut i64)))
  (type (array (mut i32)))
  (type (array (mut i64)))
  (type (array (mut anyref)))
  (type (array (mut (ref struct))))
  (type (array (mut (ref 0))))
  (type (array (mut (ref null i31))))
)`);

// ./test/core/gc/array.wast:27
assert_invalid(
  () => instantiate(`(module
    (type (array (mut (ref null 10))))
  )`),
  `unknown type`,
);

// ./test/core/gc/array.wast:37
let $1 = instantiate(`(module
  (rec
    (type \$s0 (array (ref \$s1)))
    (type \$s1 (array (ref \$s0)))
  )

  (func (param (ref \$forward)))

  (type \$forward (array i32))
)`);

// ./test/core/gc/array.wast:48
assert_invalid(() => instantiate(`(module (type (array (ref 1))))`), `unknown type`);

// ./test/core/gc/array.wast:52
assert_invalid(() => instantiate(`(module (type (array (mut (ref 1)))))`), `unknown type`);

// ./test/core/gc/array.wast:60
let $2 = instantiate(`(module
  (type \$vec (array f32))
  (type \$mvec (array (mut f32)))

  (global (ref \$vec) (array.new \$vec (f32.const 1) (i32.const 3)))
  (global (ref \$vec) (array.new_default \$vec (i32.const 3)))

  (func \$new (export "new") (result (ref \$vec))
    (array.new_default \$vec (i32.const 3))
  )

  (func \$get (param \$i i32) (param \$v (ref \$vec)) (result f32)
    (array.get \$vec (local.get \$v) (local.get \$i))
  )
  (func (export "get") (param \$i i32) (result f32)
    (call \$get (local.get \$i) (call \$new))
  )

  (func \$set_get (param \$i i32) (param \$v (ref \$mvec)) (param \$y f32) (result f32)
    (array.set \$mvec (local.get \$v) (local.get \$i) (local.get \$y))
    (array.get \$mvec (local.get \$v) (local.get \$i))
  )
  (func (export "set_get") (param \$i i32) (param \$y f32) (result f32)
    (call \$set_get (local.get \$i)
      (array.new_default \$mvec (i32.const 3))
      (local.get \$y)
    )
  )

  (func \$len (param \$v (ref array)) (result i32)
    (array.len (local.get \$v))
  )
  (func (export "len") (result i32)
    (call \$len (call \$new))
  )
)`);

// ./test/core/gc/array.wast:97
assert_return(() => invoke($2, `new`, []), [new RefWithType('arrayref')]);

// ./test/core/gc/array.wast:98
assert_return(() => invoke($2, `new`, []), [new RefWithType('eqref')]);

// ./test/core/gc/array.wast:99
assert_return(() => invoke($2, `get`, [0]), [value("f32", 0)]);

// ./test/core/gc/array.wast:100
assert_return(() => invoke($2, `set_get`, [1, value("f32", 7)]), [value("f32", 7)]);

// ./test/core/gc/array.wast:101
assert_return(() => invoke($2, `len`, []), [value("i32", 3)]);

// ./test/core/gc/array.wast:103
assert_trap(() => invoke($2, `get`, [10]), `out of bounds array access`);

// ./test/core/gc/array.wast:104
assert_trap(() => invoke($2, `set_get`, [10, value("f32", 7)]), `out of bounds array access`);

// ./test/core/gc/array.wast:106
let $3 = instantiate(`(module
  (type \$vec (array f32))
  (type \$mvec (array (mut f32)))

  (global (ref \$vec) (array.new_fixed \$vec 2 (f32.const 1) (f32.const 2)))

  (func \$new (export "new") (result (ref \$vec))
    (array.new_fixed \$vec 2 (f32.const 1) (f32.const 2))
  )

  (func \$get (param \$i i32) (param \$v (ref \$vec)) (result f32)
    (array.get \$vec (local.get \$v) (local.get \$i))
  )
  (func (export "get") (param \$i i32) (result f32)
    (call \$get (local.get \$i) (call \$new))
  )

  (func \$set_get (param \$i i32) (param \$v (ref \$mvec)) (param \$y f32) (result f32)
    (array.set \$mvec (local.get \$v) (local.get \$i) (local.get \$y))
    (array.get \$mvec (local.get \$v) (local.get \$i))
  )
  (func (export "set_get") (param \$i i32) (param \$y f32) (result f32)
    (call \$set_get (local.get \$i)
      (array.new_fixed \$mvec 3 (f32.const 1) (f32.const 2) (f32.const 3))
      (local.get \$y)
    )
  )

  (func \$len (param \$v (ref array)) (result i32)
    (array.len (local.get \$v))
  )
  (func (export "len") (result i32)
    (call \$len (call \$new))
  )
)`);

// ./test/core/gc/array.wast:142
assert_return(() => invoke($3, `new`, []), [new RefWithType('arrayref')]);

// ./test/core/gc/array.wast:143
assert_return(() => invoke($3, `new`, []), [new RefWithType('eqref')]);

// ./test/core/gc/array.wast:144
assert_return(() => invoke($3, `get`, [0]), [value("f32", 1)]);

// ./test/core/gc/array.wast:145
assert_return(() => invoke($3, `set_get`, [1, value("f32", 7)]), [value("f32", 7)]);

// ./test/core/gc/array.wast:146
assert_return(() => invoke($3, `len`, []), [value("i32", 2)]);

// ./test/core/gc/array.wast:148
assert_trap(() => invoke($3, `get`, [10]), `out of bounds array access`);

// ./test/core/gc/array.wast:149
assert_trap(() => invoke($3, `set_get`, [10, value("f32", 7)]), `out of bounds array access`);

// ./test/core/gc/array.wast:151
let $4 = instantiate(`(module
  (type \$vec (array i8))
  (type \$mvec (array (mut i8)))

  (data \$d "\\00\\01\\02\\ff\\04")

  (func \$new (export "new") (result (ref \$vec))
    (array.new_data \$vec \$d (i32.const 1) (i32.const 3))
  )

  (func \$new-overflow (export "new-overflow") (result (ref \$vec))
    (array.new_data \$vec \$d (i32.const 0x8000_0000) (i32.const 0x8000_0000))
  )

  (func \$get_u (param \$i i32) (param \$v (ref \$vec)) (result i32)
    (array.get_u \$vec (local.get \$v) (local.get \$i))
  )
  (func (export "get_u") (param \$i i32) (result i32)
    (call \$get_u (local.get \$i) (call \$new))
  )

  (func \$get_s (param \$i i32) (param \$v (ref \$vec)) (result i32)
    (array.get_s \$vec (local.get \$v) (local.get \$i))
  )
  (func (export "get_s") (param \$i i32) (result i32)
    (call \$get_s (local.get \$i) (call \$new))
  )

  (func \$set_get (param \$i i32) (param \$v (ref \$mvec)) (param \$y i32) (result i32)
    (array.set \$mvec (local.get \$v) (local.get \$i) (local.get \$y))
    (array.get_u \$mvec (local.get \$v) (local.get \$i))
  )
  (func (export "set_get") (param \$i i32) (param \$y i32) (result i32)
    (call \$set_get (local.get \$i)
      (array.new_data \$mvec \$d (i32.const 1) (i32.const 3))
      (local.get \$y)
    )
  )

  (func \$len (param \$v (ref array)) (result i32)
    (array.len (local.get \$v))
  )
  (func (export "len") (result i32)
    (call \$len (call \$new))
  )

  (func (export "drop_segs")
    (data.drop \$d)
  )
)`);

// ./test/core/gc/array.wast:202
assert_return(() => invoke($4, `new`, []), [new RefWithType('arrayref')]);

// ./test/core/gc/array.wast:203
assert_return(() => invoke($4, `new`, []), [new RefWithType('eqref')]);

// ./test/core/gc/array.wast:204
assert_return(() => invoke($4, `get_u`, [2]), [value("i32", 255)]);

// ./test/core/gc/array.wast:205
assert_return(() => invoke($4, `get_s`, [2]), [value("i32", -1)]);

// ./test/core/gc/array.wast:206
assert_return(() => invoke($4, `set_get`, [1, 7]), [value("i32", 7)]);

// ./test/core/gc/array.wast:207
assert_return(() => invoke($4, `len`, []), [value("i32", 3)]);

// ./test/core/gc/array.wast:209
assert_trap(() => invoke($4, `new-overflow`, []), `out of bounds memory access`);

// ./test/core/gc/array.wast:210
assert_trap(() => invoke($4, `get_u`, [10]), `out of bounds array access`);

// ./test/core/gc/array.wast:211
assert_trap(() => invoke($4, `get_s`, [10]), `out of bounds array access`);

// ./test/core/gc/array.wast:212
assert_trap(() => invoke($4, `set_get`, [10, 7]), `out of bounds array access`);

// ./test/core/gc/array.wast:214
assert_return(() => invoke($4, `drop_segs`, []), []);

// ./test/core/gc/array.wast:216
assert_trap(() => invoke($4, `new`, []), `out of bounds memory access`);

// ./test/core/gc/array.wast:217
assert_trap(() => invoke($4, `new-overflow`, []), `out of bounds memory access`);

// ./test/core/gc/array.wast:219
let $5 = instantiate(`(module
  (type \$bvec (array i8))
  (type \$vec (array (ref \$bvec)))
  (type \$mvec (array (mut (ref \$bvec))))
  (type \$nvec (array (ref null \$bvec)))
  (type \$avec (array (mut anyref)))

  (elem \$e (ref \$bvec)
    (array.new \$bvec (i32.const 7) (i32.const 3))
    (array.new_fixed \$bvec 2 (i32.const 1) (i32.const 2))
  )

  (func \$new (export "new") (result (ref \$vec))
    (array.new_elem \$vec \$e (i32.const 0) (i32.const 2))
  )

  (func \$new-overflow (export "new-overflow") (result (ref \$vec))
    (array.new_elem \$vec \$e (i32.const 0x8000_0000) (i32.const 0x8000_0000))
  )

  (func \$sub1 (result (ref \$nvec))
    (array.new_elem \$nvec \$e (i32.const 0) (i32.const 2))
  )
  (func \$sub2 (result (ref \$avec))
    (array.new_elem \$avec \$e (i32.const 0) (i32.const 2))
  )

  (func \$get (param \$i i32) (param \$j i32) (param \$v (ref \$vec)) (result i32)
    (array.get_u \$bvec (array.get \$vec (local.get \$v) (local.get \$i)) (local.get \$j))
  )
  (func (export "get") (param \$i i32) (param \$j i32) (result i32)
    (call \$get (local.get \$i) (local.get \$j) (call \$new))
  )

  (func \$set_get (param \$i i32) (param \$j i32) (param \$v (ref \$mvec)) (param \$y i32) (result i32)
    (array.set \$mvec (local.get \$v) (local.get \$i) (array.get \$mvec (local.get \$v) (local.get \$y)))
    (array.get_u \$bvec (array.get \$mvec (local.get \$v) (local.get \$i)) (local.get \$j))
  )
  (func (export "set_get") (param \$i i32) (param \$j i32) (param \$y i32) (result i32)
    (call \$set_get (local.get \$i) (local.get \$j)
      (array.new_elem \$mvec \$e (i32.const 0) (i32.const 2))
      (local.get \$y)
    )
  )

  (func \$len (param \$v (ref array)) (result i32)
    (array.len (local.get \$v))
  )
  (func (export "len") (result i32)
    (call \$len (call \$new))
  )

  (func (export "drop_segs")
    (elem.drop \$e)
  )
)`);

// ./test/core/gc/array.wast:276
assert_return(() => invoke($5, `new`, []), [new RefWithType('arrayref')]);

// ./test/core/gc/array.wast:277
assert_return(() => invoke($5, `new`, []), [new RefWithType('eqref')]);

// ./test/core/gc/array.wast:278
assert_return(() => invoke($5, `get`, [0, 0]), [value("i32", 7)]);

// ./test/core/gc/array.wast:279
assert_return(() => invoke($5, `get`, [1, 0]), [value("i32", 1)]);

// ./test/core/gc/array.wast:280
assert_return(() => invoke($5, `set_get`, [0, 1, 1]), [value("i32", 2)]);

// ./test/core/gc/array.wast:281
assert_return(() => invoke($5, `len`, []), [value("i32", 2)]);

// ./test/core/gc/array.wast:283
assert_trap(() => invoke($5, `new-overflow`, []), `out of bounds table access`);

// ./test/core/gc/array.wast:284
assert_trap(() => invoke($5, `get`, [10, 0]), `out of bounds array access`);

// ./test/core/gc/array.wast:285
assert_trap(() => invoke($5, `set_get`, [10, 0, 0]), `out of bounds array access`);

// ./test/core/gc/array.wast:287
assert_return(() => invoke($5, `drop_segs`, []), []);

// ./test/core/gc/array.wast:289
assert_trap(() => invoke($5, `new`, []), `out of bounds table access`);

// ./test/core/gc/array.wast:290
assert_trap(() => invoke($5, `new-overflow`, []), `out of bounds table access`);

// ./test/core/gc/array.wast:292
assert_invalid(
  () => instantiate(`(module
    (type \$a (array i64))
    (func (export "array.set-immutable") (param \$a (ref \$a))
      (array.set \$a (local.get \$a) (i32.const 0) (i64.const 1))
    )
  )`),
  `immutable array`,
);

// ./test/core/gc/array.wast:302
assert_invalid(
  () => instantiate(`(module
    (type \$bvec (array i8))

    (data \$d "\\00\\01\\02\\03\\04")

    (global (ref \$bvec)
      (array.new_data \$bvec \$d (i32.const 1) (i32.const 3))
    )
  )`),
  `constant expression required`,
);

// ./test/core/gc/array.wast:315
assert_invalid(
  () => instantiate(`(module
    (type \$bvec (array i8))
    (type \$vvec (array (ref \$bvec)))

    (elem \$e (ref \$bvec) (ref.null \$bvec))

    (global (ref \$vvec)
      (array.new_elem \$vvec \$e (i32.const 0) (i32.const 1))
    )
  )`),
  `constant expression required`,
);

// ./test/core/gc/array.wast:332
let $6 = instantiate(`(module
  (type \$t (array (mut i32)))
  (func (export "array.get-null")
    (local (ref null \$t)) (drop (array.get \$t (local.get 0) (i32.const 0)))
  )
  (func (export "array.set-null")
    (local (ref null \$t)) (array.set \$t (local.get 0) (i32.const 0) (i32.const 0))
  )
)`);

// ./test/core/gc/array.wast:342
assert_trap(() => invoke($6, `array.get-null`, []), `null array reference`);

// ./test/core/gc/array.wast:343
assert_trap(() => invoke($6, `array.set-null`, []), `null array reference`);