feat: add support for named tuple types like [x: f64, y: f64]

Author: JairusSW

src/ast.ts

@@ -164,10 +164,11 @@ export abstract class Node {
 
   static createTupleType(
     elements: TypeNode[],
+    elementNames: (IdentifierExpression | null)[] | null,
     isNullable: bool,
     range: Range
   ): TupleTypeNode {
-    return new TupleTypeNode(elements, isNullable, range);
+    return new TupleTypeNode(elements, elementNames, isNullable, range);
   }
 
   static createOmittedType(
@@ -948,6 +949,8 @@ 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. */

src/extra/ast.ts

@@ -463,11 +463,22 @@ export class ASTBuilder {
     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]);
       }
     }

src/parser.ts

@@ -578,11 +578,26 @@ export class Parser extends DiagnosticEmitter {
     // '[' Type (',' Type)* ']'
     } else if (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) {
@@ -594,7 +609,7 @@ export class Parser extends DiagnosticEmitter {
           return null;
         }
       }
-      type = Node.createTupleType(elements, false, tn.range(startPos, tn.pos));
+      type = Node.createTupleType(elements, hasElementNames ? elementNames : null, false, tn.range(startPos, tn.pos));
 
     // 'void'
     } else if (token == Token.Void) {

src/program.ts

@@ -390,9 +390,9 @@ export namespace OperatorKind {
       case Token.GreaterThan_GreaterThan_Equals: return OperatorKind.BitwiseShr;
       case Token.GreaterThan_GreaterThan_GreaterThan:
       case Token.GreaterThan_GreaterThan_GreaterThan_Equals: return OperatorKind.BitwiseShrU;
-      case Token.Equals_Equals: 
+      case Token.Equals_Equals:
       case Token.Equals_Equals_Equals: return OperatorKind.Eq;
-      case Token.Exclamation_Equals: 
+      case Token.Exclamation_Equals:
       case Token.Exclamation_Equals_Equals: return OperatorKind.Ne;
       case Token.GreaterThan: return OperatorKind.Gt;
       case Token.GreaterThan_Equals: return OperatorKind.Ge;
@@ -436,7 +436,7 @@ export class Program extends DiagnosticEmitter {
     diagnostics: DiagnosticMessage[] | null = null
   ) {
     super(diagnostics);
-    this.module = Module.create(options.stackSize > 0, options.sizeTypeRef);    
+    this.module = Module.create(options.stackSize > 0, options.sizeTypeRef);
     this.parser = new Parser(this.diagnostics, this.sources);
     this.resolver = new Resolver(this);
     let nativeFile = new File(this, Source.native);