tests: organize a bit better and cover more cases

Author: JairusSW

tests/compiler/tuple-circular.json

@@ -1,4 +1,7 @@
 {
+  "asc_flags": [
+    "--enable", "multi-value"
+  ],
   "stderr": [
     "TS2456: Type alias 'Loop' circularly references itself.",
     "1 parse error(s)"

tests/compiler/tuple-errors.json

@@ -0,0 +1,9 @@
+{
+  "asc_flags": [
+    "--enable", "multi-value"
+  ],
+  "stderr": [
+    "AS100: Not implemented: Tuple types",
+    "18 compile error(s)"
+  ]
+}

tests/compiler/tuple-type-errors.ts tests/compiler/tuple-errors.tstests/compiler/tuple-type-errors.ts renamed to tests/compiler/tuple-errors.ts

@@ -35,3 +35,26 @@ export function TupleReturnUnimplemented6(): [i32[], [i32]] {
 export function TupleReturnUnimplemented7(): [i32, i32] {
   return [0, 1];
 }
+
+type Box<T> = [T, i32];
+
+export function TupleGeneric1(x: Box<i32>): Box<i32> {
+  return x;
+}
+export function TupleGeneric2<T>(x: [i32, T]): [i32, T] {
+  return x;
+}
+
+export function TupleNullable1(x: [i32, i32] | null): [i32, i32] | null {
+  return x;
+}
+export function TupleNullable2(x: [] | null): [] | null {
+  return x;
+}
+
+export function TupleTypeMismatch1(x: [i32, f32]): [f32, i32] {
+  return x;
+}
+export function TupleTypeMismatch2(x: [f64, f32]): [f32, f64] {
+  return x;
+}

tests/compiler/tuple-type-errors.json

@@ -1,5 +1,6 @@
 {
   "asc_flags": [
+    "--enable", "multi-value"
   ],
   "stderr": [
   ]

tests/compiler/tuple-type.json

@@ -6,7 +6,7 @@ import { globSync } from "glob";
 import { diff } from "../util/text.js";
 import { stdoutColors } from "../util/terminal.js";
 import * as optionsUtil from "../util/options.js";
-import { Program, Options, ASTBuilder } from "../dist/assemblyscript.js";
+import { Program, Options, ASTBuilder, Feature } from "../dist/assemblyscript.js";
 
 const dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -54,16 +54,28 @@ if (argv.length) {
 }
 
 let failures = 0;
+const parserTestFeatures = new Map([
+  ["tuple.ts", [Feature.MultiValue]],
+  ["tuple-more.ts", [Feature.MultiValue]],
+  ["tuple-errors.ts", [Feature.MultiValue]]
+]);
 
 for (const filename of tests) {
   if (filename.charAt(0) == "_" || filename.endsWith(".fixture.ts")) continue;
 
   console.log(stdoutColors.white("Testing parser/" + filename));
 
   let failed = false;
-  const program = new Program(new Options());
-  const parser = program.parser;
+  const options = new Options();
   const sourceText = fs.readFileSync(basedir + "/" + filename, { encoding: "utf8" }).replace(/\r?\n/g, "\n");
+  const features = parserTestFeatures.get(filename);
+  if (features) {
+    for (const feature of features) {
+      options.setFeature(feature);
+    }
+  }
+  const program = new Program(options);
+  const parser = program.parser;
   parser.parseFile(sourceText, filename, true);
   const serializedSourceText = ASTBuilder.build(program.sources[0]);
   const actual = serializedSourceText + parser.diagnostics.map(diagnostic => "// " + diagnostic +"\n").join("");

tests/parser.js

@@ -10,7 +10,12 @@ function func2(x: [i32, i32]): [i32, i32] { return x; }
 function func3(x: [i32, [i32, i32]], y: i32): [i32, [i32, i32]] { return x; }
 function func4(x: readonly [i32, string]): [void] { return [void(0)]; }
 function func5(x: readonly [Array<i32>, i32[]]): readonly [i32] { return [x[1].length]; }
+function func6(x: [i32, i32] | null): [i32, i32] | null { return x; }
+function func7(x: readonly [[i32[]], [string]]): readonly [[i32[]], [string]] { return x; }
 
 type type1 = [i32, i32];
 type type2 = [i32, [i32, i32]];
 type type3 = readonly [i32, string];
+type type4 = [i32, i32] | null;
+type type5 = [[i32, i32], [i32, i32]];
+type type6<T> = [Array<T>, T[], T];

tests/parser/tuple.ts

@@ -31,6 +31,15 @@ function func4(x: Readonly<[i32, string]>): [void] {
 function func5(x: Readonly<[Array<i32>, Array<i32>]>): Readonly<[i32]> {
   return [x[1].length];
 }
+function func6(x: [i32, i32] | null): [i32, i32] | null {
+  return x;
+}
+function func7(x: Readonly<[[Array<i32>], [string]]>): Readonly<[[Array<i32>], [string]]> {
+  return x;
+}
 type type1 = [i32, i32];
 type type2 = [i32, [i32, i32]];
 type type3 = Readonly<[i32, string]>;
+type type4 = [i32, i32] | null;
+type type5 = [[i32, i32], [i32, i32]];
+type type6<T> = [Array<T>, Array<T>, T];