feat: properly parse and resolve tuples

NOTICE

@@ -51,7 +51,7 @@ under the licensing terms detailed in LICENSE:
 * Adrien Zinger <zinger.ad@gmail.com>
 * Ruixiang Chen <xiang19890319@gmail.com>
 * Daniel Salvadori <danaugrs@gmail.com>
-* Jairus Tanaka <jairus.v.tanaka@outlook.com>
+* Jairus Tanaka <me@jairus.dev>
 * CountBleck <Mr.YouKnowWhoIAm@protonmail.com>
 * Abdul Rauf <abdulraufmujahid@gmail.com>
 * Bach Le <bach@bullno1.com>

src/ast.ts

@@ -50,6 +50,7 @@ export const enum NodeKind {
   // types
   NamedType,
   FunctionType,
+  TupleType,
   TypeName,
   TypeParameter,
   Parameter,
@@ -161,6 +162,15 @@ export abstract class Node {
     return new FunctionTypeNode(parameters, returnType, explicitThisType, isNullable, range);
   }
 
+  static createTupleType(
+    elements: TypeNode[],
+    elementNames: (IdentifierExpression | null)[] | null,
+    isNullable: bool,
+    range: Range
+  ): TupleTypeNode {
+    return new TupleTypeNode(elements, elementNames, isNullable, range);
+  }
+
   static createOmittedType(
     range: Range
   ): NamedTypeNode {
@@ -862,6 +872,12 @@ export abstract class TypeNode extends Node {
       if (functionTypeNode.returnType.hasGenericComponent(typeParameterNodes)) return true;
       let explicitThisType = functionTypeNode.explicitThisType;
       if (explicitThisType && explicitThisType.hasGenericComponent(typeParameterNodes)) return true;
+    } else if (this.kind == NodeKind.TupleType) {
+      let tupleTypeNode = <TupleTypeNode>changetype<TypeNode>(this);
+      let elements = tupleTypeNode.elements;
+      for (let i = 0, k = elements.length; i < k; ++i) {
+        if (elements[i].hasGenericComponent(typeParameterNodes)) return true;
+      }
     } else {
       assert(false);
     }
@@ -928,6 +944,22 @@ export class FunctionTypeNode extends TypeNode {
   }
 }
 
+/** Represents a tuple type. */
+export class TupleTypeNode extends TypeNode {
+  constructor(
+    /** Tuple elements. */
+    public elements: TypeNode[],
+    /** Tuple element names, if any. */
+    public elementNames: (IdentifierExpression | null)[] | null,
+    /** Whether nullable or not. */
+    isNullable: bool,
+    /** Source range. */
+    range: Range
+  ) {
+    super(NodeKind.TupleType, isNullable, range);
+  }
+}
+
 /** Represents a type parameter. */
 export class TypeParameterNode extends Node {
   constructor(

src/extra/ast.ts

@@ -15,6 +15,7 @@ import {
   TypeNode,
   NamedTypeNode,
   FunctionTypeNode,
+  TupleTypeNode,
   TypeName,
   TypeParameterNode,
 
@@ -134,6 +135,10 @@ export class ASTBuilder {
         this.visitFunctionTypeNode(<FunctionTypeNode>node);
         break;
       }
+      case NodeKind.TupleType: {
+        this.visitTupleTypeNode(<TupleTypeNode>node);
+        break;
+      }
       case NodeKind.TypeParameter: {
         this.visitTypeParameter(<TypeParameterNode>node);
         break;
@@ -387,6 +392,10 @@ export class ASTBuilder {
         this.visitFunctionTypeNode(<FunctionTypeNode>node);
         break;
       }
+      case NodeKind.TupleType: {
+        this.visitTupleTypeNode(<TupleTypeNode>node);
+        break;
+      }
       default: assert(false);
     }
   }
@@ -450,6 +459,33 @@ export class ASTBuilder {
     if (isNullable) sb.push(") | null");
   }
 
+  visitTupleTypeNode(node: TupleTypeNode): void {
+    let sb = this.sb;
+    sb.push("[");
+    let elements = node.elements;
+    let elementNames = node.elementNames;
+    let numElements = elements.length;
+    if (numElements) {
+      let name = elementNames ? elementNames[0] : null;
+      if (name) {
+        this.visitIdentifierExpression(name);
+        sb.push(": ");
+      }
+      this.visitTypeNode(elements[0]);
+      for (let i = 1; i < numElements; ++i) {
+        sb.push(", ");
+        name = elementNames ? elementNames[i] : null;
+        if (name) {
+          this.visitIdentifierExpression(name);
+          sb.push(": ");
+        }
+        this.visitTypeNode(elements[i]);
+      }
+    }
+    sb.push("]");
+    if (node.isNullable) sb.push(" | null");
+  }
+
   visitTypeParameter(node: TypeParameterNode): void {
     this.visitIdentifierExpression(node.name);
     let extendsType = node.extendsType;

src/parser.ts

@@ -9,6 +9,7 @@
 
 import {
   CommonFlags,
+  Feature,
   LIBRARY_PREFIX,
   PATH_DELIMITER
 } from "./common";
@@ -42,6 +43,7 @@ import {
   TypeName,
   NamedTypeNode,
   FunctionTypeNode,
+  TupleTypeNode,
   ArrowKind,
 
   Expression,
@@ -90,6 +92,7 @@ import {
 
   mangleInternalPath
 } from "./ast";
+import { Options } from "./compiler";
 
 /** Represents a dependee. */
 class Dependee {
@@ -118,7 +121,8 @@ export class Parser extends DiagnosticEmitter {
   sources: Source[];
   /** Current overridden module name. */
   currentModuleName: string | null = null;
-
+  /** Temporary variable so I can disable parsing tuples if multi-variable is disabled */
+  options: Options | null = null;
   /** Constructs a new parser. */
   constructor(
     diagnostics: DiagnosticMessage[] | null = null,
@@ -509,8 +513,19 @@ export class Parser extends DiagnosticEmitter {
 
     let type: TypeNode;
 
+    // 'readonly' Type
+    if (token == Token.Readonly) {
+      let innerType = this.parseType(tn, acceptParenthesized, suppressErrors);
+      if (!innerType) return null;
+      type = Node.createNamedType(
+        Node.createSimpleTypeName("Readonly", tn.range(startPos, tn.pos)),
+        [ innerType ],
+        false,
+        tn.range(startPos, tn.pos)
+      );
+
     // '(' ...
-    if (token == Token.OpenParen) {
+    } else if (token == Token.OpenParen) {
 
       // '(' FunctionSignature ')'
       let isInnerParenthesized = tn.skip(Token.OpenParen);
@@ -563,6 +578,42 @@ export class Parser extends DiagnosticEmitter {
         return null;
       }
 
+    // '[' Type (',' Type)* ']'
+    } else if (this.options && this.options!.hasFeature(Feature.MultiValue) && token == Token.OpenBracket) {
+      let elements: TypeNode[] = [];
+      let elementNames: (IdentifierExpression | null)[] = [];
+      let hasElementNames = false;
+      if (!tn.skip(Token.CloseBracket)) {
+        do {
+          let elementName: IdentifierExpression | null = null;
+          let state = tn.mark();
+          if (tn.skip(Token.Identifier)) {
+            let name = tn.readIdentifier();
+            let nameRange = tn.range();
+            if (tn.skip(Token.Colon)) {
+              elementName = Node.createIdentifierExpression(name, nameRange);
+              hasElementNames = true;
+            } else {
+              tn.reset(state);
+            }
+          }
+          let element = this.parseType(tn, true, suppressErrors);
+          if (!element) return null;
+          elements.push(element);
+          elementNames.push(elementName);
+        } while (tn.skip(Token.Comma));
+        if (!tn.skip(Token.CloseBracket)) {
+          if (!suppressErrors) {
+            this.error(
+              DiagnosticCode._0_expected,
+              tn.range(tn.pos), "]"
+            );
+          }
+          return null;
+        }
+      }
+      type = Node.createTupleType(elements, hasElementNames ? elementNames : null, false, tn.range(startPos, tn.pos));
+
     // 'void'
     } else if (token == Token.Void) {
       type = Node.createNamedType(
@@ -4581,6 +4632,13 @@ function isCircularTypeAlias(name: string, type: TypeNode): bool {
       }
       break;
     }
+    case NodeKind.TupleType: {
+      let elements = (<TupleTypeNode>type).elements;
+      for (let i = 0, k = elements.length; i < k; i++) {
+        if (isCircularTypeAlias(name, elements[i])) return true;
+      }
+      break;
+    }
     default: assert(false);
   }
   return false;

src/program.ts

@@ -442,6 +442,9 @@ export class Program extends DiagnosticEmitter {
     let nativeFile = new File(this, Source.native);
     this.nativeFile = nativeFile;
     this.filesByName.set(nativeFile.internalName, nativeFile);
+
+    // temporary fix
+    this.parser.options = this.options;
   }
 
   /** Module instance. */

src/resolver.ts

@@ -45,6 +45,7 @@ import {
 
 import {
   FunctionTypeNode,
+  TupleTypeNode,
   ParameterKind,
   TypeNode,
   NodeKind,
@@ -171,6 +172,10 @@ export class Resolver extends DiagnosticEmitter {
         resolved = this.resolveFunctionType(<FunctionTypeNode>node, flow, ctxElement, ctxTypes, reportMode);
         break;
       }
+      case NodeKind.TupleType: {
+        resolved = this.resolveTupleType(<TupleTypeNode>node, flow, ctxElement, ctxTypes, reportMode);
+        break;
+      }
       default: assert(false);
     }
     node.currentlyResolving = false;
@@ -452,6 +457,32 @@ export class Resolver extends DiagnosticEmitter {
     return node.isNullable ? signature.type.asNullable() : signature.type;
   }
 
+  /** Resolves a {@link TupleTypeNode}. */
+  private resolveTupleType(
+    /** The type to resolve. */
+    node: TupleTypeNode,
+    /** The flow */
+    flow: Flow | null,
+    /** Contextual element. */
+    ctxElement: Element,
+    /** Contextual types, i.e. `T`. */
+    ctxTypes: Map<string,Type> | null = null,
+    /** How to proceed with eventual diagnostics. */
+    reportMode: ReportMode = ReportMode.Report
+  ): Type | null {
+    let elements = node.elements;
+    for (let i = 0, k = elements.length; i < k; ++i) {
+      if (!this.resolveType(elements[i], flow, ctxElement, ctxTypes, reportMode)) return null;
+    }
+    if (reportMode == ReportMode.Report) {
+      this.error(
+        DiagnosticCode.Not_implemented_0,
+        node.range, "Tuple types"
+      );
+    }
+    return null;
+  }
+
   private resolveBuiltinNotNullableType(
     /** The type to resolve. */
     node: NamedTypeNode,

tests/compiler/tuple-circular.json

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

tests/compiler/tuple-circular.ts

@@ -0,0 +1 @@
+type Loop = [Loop, i32];

tests/compiler/tuple-disabled.json

@@ -0,0 +1,9 @@
+{
+  "asc_flags": [
+    "--disable", "multi-value"
+  ],
+  "stderr": [
+    "TS1110: Type expected.",
+    "3 parse error(s)"
+  ]
+}

tests/compiler/tuple-disabled.ts

@@ -0,0 +1,3 @@
+export function tupleDisabled(x: [left: i32, right: i32]): void {}
+export type tupleTypeDisabled1 = [i32, i32];
+export type tupleTypeDisabled2 = [];

tests/compiler/tuple-errors.json

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