Adding support for tuple types (e.g. [number, string])

src/compiler/core.ts

@@ -19,8 +19,7 @@ module ts {
 
     export function contains<T>(array: T[], value: T): boolean {
         if (array) {
-            var len = array.length;
-            for (var i = 0; i < len; i++) {
+            for (var i = 0, len = array.length; i < len; i++) {
                 if (array[i] === value) {
                     return true;
                 }
@@ -31,8 +30,7 @@ module ts {
 
     export function indexOf<T>(array: T[], value: T): number {
         if (array) {
-            var len = array.length;
-            for (var i = 0; i < len; i++) {
+            for (var i = 0, len = array.length; i < len; i++) {
                 if (array[i] === value) {
                     return i;
                 }
@@ -42,9 +40,8 @@ module ts {
     }
 
     export function filter<T>(array: T[], f: (x: T) => boolean): T[] {
-        var result: T[];
         if (array) {
-            result = [];
+            var result: T[] = [];
             for (var i = 0, len = array.length; i < len; i++) {
                 var item = array[i];
                 if (f(item)) {
@@ -56,11 +53,9 @@ module ts {
     }
 
     export function map<T, U>(array: T[], f: (x: T) => U): U[] {
-        var result: U[];
         if (array) {
-            result = [];
-            var len = array.length;
-            for (var i = 0; i < len; i++) {
+            var result: U[] = [];
+            for (var i = 0, len = array.length; i < len; i++) {
                 result.push(f(array[i]));
             }
         }
@@ -73,6 +68,17 @@ module ts {
         return array1.concat(array2);
     }
 
+    export function uniqueElements<T>(array: T[]): T[] {
+        if (array) {
+            var result: T[] = [];
+            for (var i = 0, len = array.length; i < len; i++) {
+                var item = array[i];
+                if (!contains(result, item)) result.push(item);
+            }
+        }
+        return result;
+    }
+
     export function sum(array: any[], prop: string): number {
         var result = 0;
         for (var i = 0; i < array.length; i++) {

src/compiler/diagnosticInformationMap.generated.ts

@@ -84,6 +84,7 @@ module ts {
         An_object_literal_cannot_have_property_and_accessor_with_the_same_name: { code: 1119, category: DiagnosticCategory.Error, key: "An object literal cannot have property and accessor with the same name." },
         An_export_assignment_cannot_have_modifiers: { code: 1120, category: DiagnosticCategory.Error, key: "An export assignment cannot have modifiers." },
         Octal_literals_are_not_allowed_in_strict_mode: { code: 1121, category: DiagnosticCategory.Error, key: "Octal literals are not allowed in strict mode." },
+        A_tuple_type_element_list_cannot_be_empty: { code: 1122, category: DiagnosticCategory.Error, key: "A tuple type element list cannot be empty." },
         Variable_declaration_list_cannot_be_empty: { code: 1123, category: DiagnosticCategory.Error, key: "Variable declaration list cannot be empty." },
         Digit_expected: { code: 1124, category: DiagnosticCategory.Error, key: "Digit expected." },
         Hexadecimal_digit_expected: { code: 1125, category: DiagnosticCategory.Error, key: "Hexadecimal digit expected." },

src/compiler/diagnosticMessages.json

@@ -327,6 +327,10 @@
         "category": "Error",
         "code": 1121
     },
+    "A tuple type element list cannot be empty.": {
+        "category": "Error",
+        "code": 1122
+    },
     "Variable declaration list cannot be empty.": {
         "category": "Error",
         "code": 1123

src/compiler/parser.ts

@@ -228,6 +228,8 @@ module ts {
                 return children((<TypeLiteralNode>node).members);
             case SyntaxKind.ArrayType:
                 return child((<ArrayTypeNode>node).elementType);
+            case SyntaxKind.TupleType:
+                return children((<TupleTypeNode>node).elementTypes);
             case SyntaxKind.ArrayLiteral:
                 return children((<ArrayLiteral>node).elements);
             case SyntaxKind.ObjectLiteral:
@@ -520,6 +522,7 @@ module ts {
         Parameters,              // Parameters in parameter list
         TypeParameters,          // Type parameters in type parameter list
         TypeArguments,           // Type arguments in type argument list
+        TupleElementTypes,       // Element types in tuple element type list
         Count                    // Number of parsing contexts
     }
 
@@ -547,6 +550,7 @@ module ts {
             case ParsingContext.Parameters:             return Diagnostics.Parameter_declaration_expected;
             case ParsingContext.TypeParameters:         return Diagnostics.Type_parameter_declaration_expected;
             case ParsingContext.TypeArguments:          return Diagnostics.Type_argument_expected;
+            case ParsingContext.TupleElementTypes:      return Diagnostics.Type_expected;
         }
     };
 
@@ -1015,6 +1019,7 @@ module ts {
                 case ParsingContext.Parameters:
                     return isParameter();
                 case ParsingContext.TypeArguments:
+                case ParsingContext.TupleElementTypes:
                     return isType();
             }
 
@@ -1050,6 +1055,7 @@ module ts {
                     // Tokens other than ')' are here for better error recovery
                     return token === SyntaxKind.CloseParenToken || token === SyntaxKind.SemicolonToken;
                 case ParsingContext.ArrayLiteralMembers:
+                case ParsingContext.TupleElementTypes:
                     return token === SyntaxKind.CloseBracketToken;
                 case ParsingContext.Parameters:
                     // Tokens other than ')' and ']' (the latter for index signatures) are here for better error recovery
@@ -1570,6 +1576,17 @@ module ts {
             return finishNode(node);
         }
 
+        function parseTupleType(): TupleTypeNode {
+            var node = <TupleTypeNode>createNode(SyntaxKind.TupleType);
+            var startTokenPos = scanner.getTokenPos();
+            var startErrorCount = file.syntacticErrors.length;
+            node.elementTypes = parseBracketedList(ParsingContext.TupleElementTypes, parseType, SyntaxKind.OpenBracketToken, SyntaxKind.CloseBracketToken);
+            if (!node.elementTypes.length && file.syntacticErrors.length === startErrorCount) {
+                grammarErrorAtPos(startTokenPos, scanner.getStartPos() - startTokenPos, Diagnostics.A_tuple_type_element_list_cannot_be_empty);
+            }
+            return finishNode(node);
+        }
+
         function parseFunctionType(signatureKind: SyntaxKind): TypeLiteralNode {
             var node = <TypeLiteralNode>createNode(SyntaxKind.TypeLiteral);
             var member = <SignatureDeclaration>createNode(signatureKind);
@@ -1600,6 +1617,8 @@ module ts {
                     return parseTypeQuery();
                 case SyntaxKind.OpenBraceToken:
                     return parseTypeLiteral();
+                case SyntaxKind.OpenBracketToken:
+                    return parseTupleType();
                 case SyntaxKind.OpenParenToken:
                 case SyntaxKind.LessThanToken:
                     return parseFunctionType(SyntaxKind.CallSignature);
@@ -1623,6 +1642,7 @@ module ts {
                 case SyntaxKind.VoidKeyword:
                 case SyntaxKind.TypeOfKeyword:
                 case SyntaxKind.OpenBraceToken:
+                case SyntaxKind.OpenBracketToken:
                 case SyntaxKind.LessThanToken:
                 case SyntaxKind.NewKeyword:
                     return true;

src/compiler/types.ts

@@ -149,6 +149,7 @@ module ts {
         TypeQuery,
         TypeLiteral,
         ArrayType,
+        TupleType,
         // Expression
         ArrayLiteral,
         ObjectLiteral,
@@ -219,7 +220,7 @@ module ts {
         FirstFutureReservedWord = ImplementsKeyword,
         LastFutureReservedWord = YieldKeyword,
         FirstTypeNode = TypeReference,
-        LastTypeNode = ArrayType,
+        LastTypeNode = TupleType,
         FirstPunctuation = OpenBraceToken,
         LastPunctuation = CaretEqualsToken
     }
@@ -320,6 +321,10 @@ module ts {
         elementType: TypeNode;
     }
 
+    export interface TupleTypeNode extends TypeNode {
+        elementTypes: NodeArray<TypeNode>;
+    }
+
     export interface StringLiteralTypeNode extends TypeNode {
         text: string;
     }
@@ -803,13 +808,14 @@ module ts {
         Class              = 0x00000400,  // Class
         Interface          = 0x00000800,  // Interface
         Reference          = 0x00001000,  // Generic type reference
-        Anonymous          = 0x00002000,  // Anonymous
-        FromSignature      = 0x00004000,  // Created for signature assignment check
+        Tuple              = 0x00002000,  // Tuple
+        Anonymous          = 0x00004000,  // Anonymous
+        FromSignature      = 0x00008000,  // Created for signature assignment check
 
         Intrinsic = Any | String | Number | Boolean | Void | Undefined | Null,
         StringLike = String | StringLiteral,
         NumberLike = Number | Enum,
-        ObjectType = Class | Interface | Reference | Anonymous
+        ObjectType = Class | Interface | Reference | Tuple | Anonymous
     }
 
     // Properties common to all types
@@ -862,6 +868,11 @@ module ts {
         openReferenceChecks: Map<boolean>;    // Open type reference check cache
     }
 
+    export interface TupleType extends ObjectType {
+        elementTypes: Type[];          // Element types
+        baseArrayType: TypeReference;  // Array<T> where T is best common type of element types
+    }
+
     // Resolved object type
     export interface ResolvedObjectType extends ObjectType {
         members: SymbolTable;              // Properties by name

tests/baselines/reference/tupleTypes.errors.txt

@@ -0,0 +1,87 @@
+==== tests/cases/compiler/tupleTypes.ts (9 errors) ====
+    var v1: [];  // Error
+            ~~
+!!! A tuple type element list cannot be empty.
+    var v2: [number];
+    var v3: [number, string];
+    var v4: [number, [string, string]];
+
+    var t: [number, string];
+    var t0 = t[0];   // number
+    var t0: number;
+    var t1 = t[1];   // string
+    var t1: string;
+    var t2 = t[2];   // {}
+    var t2: {};
+
+    t = [];               // Error
+    ~
+!!! Type '{}[]' is not assignable to type '[number, string]':
+!!!   Property '0' is missing in type '{}[]'.
+    t = [1];              // Error
+    ~
+!!! Type '[number]' is not assignable to type '[number, string]':
+!!!   Property '1' is missing in type '[number]'.
+    t = [1, "hello"];     // Ok
+    t = ["hello", 1];     // Error
+    ~
+!!! Type '[string, number]' is not assignable to type '[number, string]':
+!!!   Types of property '0' are incompatible:
+!!!     Type 'string' is not assignable to type 'number'.
+    t = [1, "hello", 2];  // Ok
+
+    var tf: [string, (x: string) => number] = ["hello", x => x.length];
+
+    declare function ff<T, U>(a: T, b: [T, (x: T) => U]): U;
+    var ff1 = ff("hello", ["foo", x => x.length]);
+    var ff1: number;
+
+    function tuple2<T0, T1>(item0: T0, item1: T1): [T0, T1]{
+        return [item0, item1];
+    }
+
+    var tt = tuple2(1, "string");
+    var tt0 = tt[0];
+    var tt0: number;
+    var tt1 = tt[1];
+    var tt1: string;
+    var tt2 = tt[2];
+    var tt2: {};
+
+    tt = tuple2(1, undefined);
+    tt = [1, undefined];
+    tt = [undefined, undefined];
+    tt = [];  // Error
+    ~~
+!!! Type '{}[]' is not assignable to type '[number, string]'.
+
+    var a: number[];
+    var a1: [number, string];
+    var a2: [number, number];
+    var a3: [number, {}];
+    a = a1;   // Error
+    ~
+!!! Type '[number, string]' is not assignable to type 'number[]':
+!!!   Types of property 'pop' are incompatible:
+!!!     Type '() => {}' is not assignable to type '() => number':
+!!!       Type '{}' is not assignable to type 'number'.
+    a = a2;
+    a = a3;   // Error
+    ~
+!!! Type '[number, {}]' is not assignable to type 'number[]':
+!!!   Types of property 'pop' are incompatible:
+!!!     Type '() => {}' is not assignable to type '() => number':
+!!!       Type '{}' is not assignable to type 'number'.
+    a1 = a2;  // Error
+    ~~
+!!! Type '[number, number]' is not assignable to type '[number, string]':
+!!!   Types of property '1' are incompatible:
+!!!     Type 'number' is not assignable to type 'string'.
+    a1 = a3;  // Error
+    ~~
+!!! Type '[number, {}]' is not assignable to type '[number, string]':
+!!!   Types of property '1' are incompatible:
+!!!     Type '{}' is not assignable to type 'string'.
+    a3 = a1;
+    a3 = a2;
+

tests/baselines/reference/typeName1.errors.txt

@@ -1,4 +1,4 @@
-==== tests/cases/compiler/typeName1.ts (16 errors) ====
+==== tests/cases/compiler/typeName1.ts (17 errors) ====
     interface I {
         k;
     }
@@ -55,6 +55,8 @@
         ~~~
 !!! Type 'number' is not assignable to type '{ z: I; x: boolean; y: (s: string) => boolean; w: { (): boolean; [x: string]: { x: any; y: any; }; [x: number]: { x: any; y: any; }; z: I; }; }[][]':
 !!!   Property 'length' is missing in type 'Number'.
+                                                     ~~~~
+!!! Property 'z' of type 'I' is not assignable to string index type '{ x: any; y: any; }'.
     var x13:{ new(): number; new(n:number):number; x: string; w: {y: number;}; (): {}; } = 3;
         ~~~
 !!! Type 'number' is not assignable to type '{ (): {}; new (): number; new (n: number): number; x: string; w: { y: number; }; }':

tests/cases/compiler/tupleTypes.ts

@@ -0,0 +1,53 @@
+var v1: [];  // Error
+var v2: [number];
+var v3: [number, string];
+var v4: [number, [string, string]];
+
+var t: [number, string];
+var t0 = t[0];   // number
+var t0: number;
+var t1 = t[1];   // string
+var t1: string;
+var t2 = t[2];   // {}
+var t2: {};
+
+t = [];               // Error
+t = [1];              // Error
+t = [1, "hello"];     // Ok
+t = ["hello", 1];     // Error
+t = [1, "hello", 2];  // Ok
+
+var tf: [string, (x: string) => number] = ["hello", x => x.length];
+
+declare function ff<T, U>(a: T, b: [T, (x: T) => U]): U;
+var ff1 = ff("hello", ["foo", x => x.length]);
+var ff1: number;
+
+function tuple2<T0, T1>(item0: T0, item1: T1): [T0, T1]{
+    return [item0, item1];
+}
+
+var tt = tuple2(1, "string");
+var tt0 = tt[0];
+var tt0: number;
+var tt1 = tt[1];
+var tt1: string;
+var tt2 = tt[2];
+var tt2: {};
+
+tt = tuple2(1, undefined);
+tt = [1, undefined];
+tt = [undefined, undefined];
+tt = [];  // Error
+
+var a: number[];
+var a1: [number, string];
+var a2: [number, number];
+var a3: [number, {}];
+a = a1;   // Error
+a = a2;
+a = a3;   // Error
+a1 = a2;  // Error
+a1 = a3;  // Error
+a3 = a1;
+a3 = a2;