// |jit-test| skip-if: !wasmGcEnabled()

// Globals have identity now
{
  const { g, same } = wasmEvalText(`(module
    (type (struct))
    (global (export "g") eqref (struct.new 0))
    (func $same (export "same") (param eqref) (result i32)
      (ref.eq (local.get 0) (global.get 0))
    )
    (func $sanity
      (if (call $same (global.get 0)) (then return))
      unreachable
    )
    (start $sanity)
  )`).exports;

  assertEq(same(g.value), 1, "global had different identity when exported");
}

// Subtypes with func refs
{
  wasmEvalText(`(module
    (type $s1 (struct))
    (type $t1 (sub (func (param (ref $s1)))))
    (type $t2 (sub $t1 (func (param (ref null $s1)))))
    (func $a (type $t1))
    (func $b (type $t2))

    (global (ref $t1) ref.func $a)
    (global (ref null $t1) ref.func $a)
    (global (ref func) ref.func $a)
    (global (ref null func) ref.func $a)

    (global (ref $t2) ref.func $b)
    (global (ref null $t2) ref.func $b)
    (global (ref $t1) ref.func $b)
    (global (ref null $t1) ref.func $b)
    (global (ref func) ref.func $b)
    (global (ref null func) ref.func $b)
  )`);

  assertErrorMessage(() => wasmEvalText(`(module
    (type $s1 (struct))
    (type $t1 (func (param (ref $s1))))
    (type $t2 (func (param (ref null $s1)))) ;; not a subtype of t1
    (func $a (type $t2))
    (global (ref $t1) ref.func $a)
  )`), WebAssembly.CompileError, /type mismatch/);
}

// Subtypes with struct refs
{
  wasmEvalText(`(module
    (type $t1 (sub (struct)))
    (type $t2 (sub $t1 (struct (field i32))))

    (global (ref $t1) struct.new_default $t1)
    (global (ref null $t1) struct.new_default $t1)
    (global (ref struct) struct.new_default $t1)
    (global (ref null struct) struct.new_default $t1)
    (global (ref eq) struct.new_default $t1)
    (global (ref null eq) struct.new_default $t1)
    (global (ref any) struct.new_default $t1)
    (global (ref null any) struct.new_default $t1)

    (global (ref $t2) struct.new_default $t2)
    (global (ref null $t2) struct.new_default $t2)
    (global (ref $t1) struct.new_default $t2)
    (global (ref null $t1) struct.new_default $t2)
    (global (ref struct) struct.new_default $t2)
    (global (ref null struct) struct.new_default $t2)
    (global (ref eq) struct.new_default $t2)
    (global (ref null eq) struct.new_default $t2)
    (global (ref any) struct.new_default $t2)
    (global (ref null any) struct.new_default $t2)
  )`);

  assertErrorMessage(() => wasmEvalText(`(module
    (type $t1 (struct))
    (type $t2 (struct (field i32))) ;; not a subtype of t1
    (global (ref $t1) struct.new_default $t2)
  )`), WebAssembly.CompileError, /type mismatch/);
}

// Subtypes with array refs
{
  wasmEvalText(`(module
    (type $s (struct))
    (type $t1 (sub (array (ref null $s))))
    (type $t2 (sub $t1 (array (ref $s))))

    (global (ref $t1) array.new_fixed $t1 0)
    (global (ref null $t1) array.new_fixed $t1 0)
    (global (ref array) array.new_fixed $t1 0)
    (global (ref null array) array.new_fixed $t1 0)
    (global (ref eq) array.new_fixed $t1 0)
    (global (ref null eq) array.new_fixed $t1 0)
    (global (ref any) array.new_fixed $t1 0)
    (global (ref null any) array.new_fixed $t1 0)

    (global (ref $t2) array.new_fixed $t2 0)
    (global (ref null $t2) array.new_fixed $t2 0)
    (global (ref $t1) array.new_fixed $t2 0)
    (global (ref null $t1) array.new_fixed $t2 0)
    (global (ref array) array.new_fixed $t2 0)
    (global (ref null array) array.new_fixed $t2 0)
    (global (ref eq) array.new_fixed $t2 0)
    (global (ref null eq) array.new_fixed $t2 0)
    (global (ref any) array.new_fixed $t2 0)
    (global (ref null any) array.new_fixed $t2 0)
  )`);

  assertErrorMessage(() => wasmEvalText(`(module
    (type $s (struct))
    (type $t1 (array (ref null $s)))
    (type $t2 (array (ref $s))) ;; not a subtype of t1
    (global (ref $t1) array.new_fixed $t2 0)
  )`), WebAssembly.CompileError, /type mismatch/);
}

// Subtypes should be respected on imports and exports
{
  const { struct, mut_struct, eq, mut_eq, any, mut_any } = wasmEvalText(`(module
    (type (struct))
    (global (export "struct") structref (struct.new 0))
    (global (export "mut_struct") (mut structref) (struct.new 0))
    (global (export "eq") eqref (struct.new 0))
    (global (export "mut_eq") (mut eqref) (struct.new 0))
    (global (export "any") anyref (struct.new 0))
    (global (export "mut_any") (mut anyref) (struct.new 0))
  )`).exports;

  function importGlobalIntoType(g, t) {
    wasmEvalText(`(module
      (global (import "test" "g") ${t})
    )`, { "test": { "g": g } });
  }

  importGlobalIntoType(struct, `structref`);
  importGlobalIntoType(struct, `eqref`);
  importGlobalIntoType(struct, `anyref`);

  importGlobalIntoType(mut_struct, `(mut structref)`);
  assertErrorMessage(() => importGlobalIntoType(mut_struct, `(mut eqref)`), WebAssembly.LinkError, /global type mismatch/);
  assertErrorMessage(() => importGlobalIntoType(mut_struct, `(mut anyref)`), WebAssembly.LinkError, /global type mismatch/);

  assertErrorMessage(() => importGlobalIntoType(eq, `structref`), WebAssembly.LinkError, /global type mismatch/);
  importGlobalIntoType(eq, `eqref`);
  importGlobalIntoType(eq, `anyref`);

  assertErrorMessage(() => importGlobalIntoType(mut_eq, `(mut structref)`), WebAssembly.LinkError, /global type mismatch/);
  importGlobalIntoType(mut_eq, `(mut eqref)`);
  assertErrorMessage(() => importGlobalIntoType(mut_eq, `(mut anyref)`), WebAssembly.LinkError, /global type mismatch/);

  assertErrorMessage(() => importGlobalIntoType(any, `structref`), WebAssembly.LinkError, /global type mismatch/);
  assertErrorMessage(() => importGlobalIntoType(any, `eqref`), WebAssembly.LinkError, /global type mismatch/);
  importGlobalIntoType(any, `anyref`);

  assertErrorMessage(() => importGlobalIntoType(mut_any, `(mut structref)`), WebAssembly.LinkError, /global type mismatch/);
  assertErrorMessage(() => importGlobalIntoType(mut_any, `(mut eqref)`), WebAssembly.LinkError, /global type mismatch/);
  importGlobalIntoType(mut_any, `(mut anyref)`);
}

// Importing globals with ref types
{
  const { struct, array, func } = wasmEvalText(`(module
    (type (struct))
    (type (array i32))
    (func $f)
    (global (export "struct") structref (struct.new 0))
    (global (export "array") arrayref (array.new_fixed 1 0))
    (global (export "func") funcref (ref.func $f))
  )`).exports;

  function importValueIntoType(v, t) {
    wasmEvalText(`(module
      (global (import "test" "v") ${t})
    )`, { "test": { "v": v } });
  }

  assertErrorMessage(() => importValueIntoType(struct.value, `(mut structref)`), WebAssembly.LinkError, /global mutability mismatch/);

  importValueIntoType(null, `structref`);
  assertErrorMessage(() => importValueIntoType(null, `(ref struct)`), TypeError, /cannot pass null/);
  assertErrorMessage(() => importValueIntoType(0, `structref`), TypeError, /can only pass/);
  importValueIntoType(struct.value, `structref`);
  assertErrorMessage(() => importValueIntoType(array.value, `structref`), TypeError, /can only pass/);

  importValueIntoType(null, `i31ref`);
  assertErrorMessage(() => importValueIntoType(null, `(ref i31)`), TypeError, /cannot pass null/);
  importValueIntoType(0, `i31ref`);
  assertErrorMessage(() => importValueIntoType(0.1, `i31ref`), TypeError, /can only pass/);
  assertErrorMessage(() => importValueIntoType("test", `i31ref`), TypeError, /can only pass/);
  assertErrorMessage(() => importValueIntoType(struct.value, `i31ref`), TypeError, /can only pass/);

  importValueIntoType(null, `eqref`);
  assertErrorMessage(() => importValueIntoType(null, `(ref eq)`), TypeError, /cannot pass null/);
  assertErrorMessage(() => importValueIntoType(undefined, `(ref eq)`), TypeError, /can only pass/);
  importValueIntoType(0, `eqref`);
  assertErrorMessage(() => importValueIntoType(0.1, `eqref`), TypeError, /can only pass/);
  assertErrorMessage(() => importValueIntoType((x)=>x, `eqref`), TypeError, /can only pass/);
  assertErrorMessage(() => importValueIntoType("test", `eqref`), TypeError, /can only pass/);
  importValueIntoType(struct.value, `eqref`);
  assertErrorMessage(() => importValueIntoType(func.value, `eqref`), TypeError, /can only pass/);

  importValueIntoType(null, `anyref`);
  assertErrorMessage(() => importValueIntoType(null, `(ref any)`), TypeError, /cannot pass null/);
  importValueIntoType(undefined, `(ref any)`);
  importValueIntoType(0, `anyref`);
  importValueIntoType(0.1, `anyref`);
  importValueIntoType((x)=>x, `anyref`)
  importValueIntoType("test", `anyref`);
  importValueIntoType(struct.value, `anyref`);
  importValueIntoType(func.value, `anyref`);

  importValueIntoType(null, `externref`);
  assertErrorMessage(() => importValueIntoType(null, `(ref extern)`), TypeError, /cannot pass null/);
  importValueIntoType(undefined, `(ref extern)`);
  importValueIntoType(0, `externref`);
  importValueIntoType(0.1, `externref`);
  importValueIntoType((x)=>x, `externref`)
  importValueIntoType("test", `externref`);
  importValueIntoType(struct.value, `externref`);
  importValueIntoType(func.value, `externref`);

  importValueIntoType(null, `funcref`);
  assertErrorMessage(() => importValueIntoType(null, `(ref func)`), TypeError, /cannot pass null/);
  assertErrorMessage(() => importValueIntoType(0, `funcref`), TypeError, /can only pass/);
  assertErrorMessage(() => importValueIntoType((x)=>x, `funcref`), TypeError, /can only pass/);
  importValueIntoType(func.value, `funcref`)
  importValueIntoType(func.value, `(ref func)`)
}