add strictTuples flag giving tuples known length

Author: KiaraGrouwstra

src/compiler/checker.ts

@@ -64,6 +64,7 @@ namespace ts {
         const noUnusedIdentifiers = !!compilerOptions.noUnusedLocals || !!compilerOptions.noUnusedParameters;
         const allowSyntheticDefaultImports = typeof compilerOptions.allowSyntheticDefaultImports !== "undefined" ? compilerOptions.allowSyntheticDefaultImports : modulekind === ModuleKind.System;
         const strictNullChecks = compilerOptions.strictNullChecks === undefined ? compilerOptions.strict : compilerOptions.strictNullChecks;
+        const strictTuples = compilerOptions.strictTuples === undefined ? compilerOptions.strict : compilerOptions.strictTuples;
         const noImplicitAny = compilerOptions.noImplicitAny === undefined ? compilerOptions.strict : compilerOptions.noImplicitAny;
         const noImplicitThis = compilerOptions.noImplicitThis === undefined ? compilerOptions.strict : compilerOptions.noImplicitThis;
 
@@ -7161,6 +7162,12 @@ namespace ts {
                 property.type = typeParameter;
                 properties.push(property);
             }
+            if (strictTuples) {
+                const lengthSymbol = createSymbol(SymbolFlags.Property, "length" as __String);
+                lengthSymbol.type = getLiteralType(arity);
+                lengthSymbol.checkFlags = CheckFlags.Readonly;
+                properties.push(lengthSymbol);
+            }
             const type = <GenericType & InterfaceTypeWithDeclaredMembers>createObjectType(ObjectFlags.Tuple | ObjectFlags.Reference);
             type.typeParameters = typeParameters;
             type.outerTypeParameters = undefined;

src/compiler/commandLineParser.ts

@@ -269,6 +269,13 @@ namespace ts {
             category: Diagnostics.Strict_Type_Checking_Options,
             description: Diagnostics.Enable_strict_null_checks
         },
+        {
+            name: "strictTuples",
+            type: "boolean",
+            showInSimplifiedHelpView: true,
+            category: Diagnostics.Strict_Type_Checking_Options,
+            description: Diagnostics.Enable_strict_tuple_checks
+        },
         {
             name: "noImplicitThis",
             type: "boolean",

src/compiler/diagnosticMessages.json

@@ -3302,6 +3302,10 @@
         "category": "Message",
         "code": 6185
     },
+    "Enable strict tuple checks.": {
+        "category": "Message",
+        "code": 6187
+    },
     "Variable '{0}' implicitly has an '{1}' type.": {
         "category": "Error",
         "code": 7005

src/compiler/types.ts

@@ -3622,6 +3622,7 @@ namespace ts {
         sourceRoot?: string;
         strict?: boolean;
         strictNullChecks?: boolean;  // Always combine with strict property
+        strictTuples?: boolean;
         /* @internal */ stripInternal?: boolean;
         suppressExcessPropertyErrors?: boolean;
         suppressImplicitAnyIndexErrors?: boolean;

src/harness/unittests/configurationExtension.ts

@@ -16,6 +16,12 @@ namespace ts {
                 strictNullChecks: false
             }
         },
+        "/dev/tsconfig.strictTuples.json": {
+            extends: "./tsconfig",
+            compilerOptions: {
+                strictTuples: false
+            }
+        },
         "/dev/configs/base.json": {
             compilerOptions: {
                 allowJs: true,

src/harness/unittests/transpile.ts

@@ -413,6 +413,10 @@ var x = 0;`, {
             options: { compilerOptions: { strictNullChecks: true }, fileName: "input.js", reportDiagnostics: true }
         });
 
+        transpilesCorrectly("Supports setting 'strictTuples'", "x;", {
+            options: { compilerOptions: { strictTuples: true }, fileName: "input.js", reportDiagnostics: true }
+        });
+
         transpilesCorrectly("Supports setting 'stripInternal'", "x;", {
             options: { compilerOptions: { stripInternal: true }, fileName: "input.js", reportDiagnostics: true }
         });

src/server/protocol.ts

@@ -2448,6 +2448,7 @@ namespace ts.server.protocol {
         sourceRoot?: string;
         strict?: boolean;
         strictNullChecks?: boolean;
+        strictTuples?: boolean;
         suppressExcessPropertyErrors?: boolean;
         suppressImplicitAnyIndexErrors?: boolean;
         target?: ScriptTarget | ts.ScriptTarget;

tests/baselines/reference/genericTypeAliases.js

@@ -40,12 +40,12 @@ type Strange<T> = string;  // Type parameter not used
 var s: Strange<number>;
 s = "hello";
 
-interface Tuple<A, B> {
+interface AB<A, B> {
     a: A;
     b: B;
 }
 
-type Pair<T> = Tuple<T, T>;
+type Pair<T> = AB<T, T>;
 
 interface TaggedPair<T> extends Pair<T> {
     tag: string;

tests/baselines/reference/genericTypeAliases.symbols

@@ -124,29 +124,29 @@ var s: Strange<number>;
 s = "hello";
 >s : Symbol(s, Decl(genericTypeAliases.ts, 38, 3))
 
-interface Tuple<A, B> {
->Tuple : Symbol(Tuple, Decl(genericTypeAliases.ts, 39, 12))
->A : Symbol(A, Decl(genericTypeAliases.ts, 41, 16))
->B : Symbol(B, Decl(genericTypeAliases.ts, 41, 18))
+interface AB<A, B> {
+>AB : Symbol(AB, Decl(genericTypeAliases.ts, 39, 12))
+>A : Symbol(A, Decl(genericTypeAliases.ts, 41, 13))
+>B : Symbol(B, Decl(genericTypeAliases.ts, 41, 15))
 
     a: A;
->a : Symbol(Tuple.a, Decl(genericTypeAliases.ts, 41, 23))
->A : Symbol(A, Decl(genericTypeAliases.ts, 41, 16))
+>a : Symbol(AB.a, Decl(genericTypeAliases.ts, 41, 20))
+>A : Symbol(A, Decl(genericTypeAliases.ts, 41, 13))
 
     b: B;
->b : Symbol(Tuple.b, Decl(genericTypeAliases.ts, 42, 9))
->B : Symbol(B, Decl(genericTypeAliases.ts, 41, 18))
+>b : Symbol(AB.b, Decl(genericTypeAliases.ts, 42, 9))
+>B : Symbol(B, Decl(genericTypeAliases.ts, 41, 15))
 }
 
-type Pair<T> = Tuple<T, T>;
+type Pair<T> = AB<T, T>;
 >Pair : Symbol(Pair, Decl(genericTypeAliases.ts, 44, 1))
 >T : Symbol(T, Decl(genericTypeAliases.ts, 46, 10))
->Tuple : Symbol(Tuple, Decl(genericTypeAliases.ts, 39, 12))
+>AB : Symbol(AB, Decl(genericTypeAliases.ts, 39, 12))
 >T : Symbol(T, Decl(genericTypeAliases.ts, 46, 10))
 >T : Symbol(T, Decl(genericTypeAliases.ts, 46, 10))
 
 interface TaggedPair<T> extends Pair<T> {
->TaggedPair : Symbol(TaggedPair, Decl(genericTypeAliases.ts, 46, 27))
+>TaggedPair : Symbol(TaggedPair, Decl(genericTypeAliases.ts, 46, 24))
 >T : Symbol(T, Decl(genericTypeAliases.ts, 48, 21))
 >Pair : Symbol(Pair, Decl(genericTypeAliases.ts, 44, 1))
 >T : Symbol(T, Decl(genericTypeAliases.ts, 48, 21))
@@ -157,17 +157,17 @@ interface TaggedPair<T> extends Pair<T> {
 
 var p: TaggedPair<number>;
 >p : Symbol(p, Decl(genericTypeAliases.ts, 52, 3))
->TaggedPair : Symbol(TaggedPair, Decl(genericTypeAliases.ts, 46, 27))
+>TaggedPair : Symbol(TaggedPair, Decl(genericTypeAliases.ts, 46, 24))
 
 p.a = 1;
->p.a : Symbol(Tuple.a, Decl(genericTypeAliases.ts, 41, 23))
+>p.a : Symbol(AB.a, Decl(genericTypeAliases.ts, 41, 20))
 >p : Symbol(p, Decl(genericTypeAliases.ts, 52, 3))
->a : Symbol(Tuple.a, Decl(genericTypeAliases.ts, 41, 23))
+>a : Symbol(AB.a, Decl(genericTypeAliases.ts, 41, 20))
 
 p.b = 2;
->p.b : Symbol(Tuple.b, Decl(genericTypeAliases.ts, 42, 9))
+>p.b : Symbol(AB.b, Decl(genericTypeAliases.ts, 42, 9))
 >p : Symbol(p, Decl(genericTypeAliases.ts, 52, 3))
->b : Symbol(Tuple.b, Decl(genericTypeAliases.ts, 42, 9))
+>b : Symbol(AB.b, Decl(genericTypeAliases.ts, 42, 9))
 
 p.tag = "test";
 >p.tag : Symbol(TaggedPair.tag, Decl(genericTypeAliases.ts, 48, 41))

tests/baselines/reference/genericTypeAliases.types

@@ -158,8 +158,8 @@ s = "hello";
 >s : string
 >"hello" : "hello"
 
-interface Tuple<A, B> {
->Tuple : Tuple<A, B>
+interface AB<A, B> {
+>AB : AB<A, B>
 >A : A
 >B : B
 
@@ -172,17 +172,17 @@ interface Tuple<A, B> {
 >B : B
 }
 
-type Pair<T> = Tuple<T, T>;
->Pair : Tuple<T, T>
+type Pair<T> = AB<T, T>;
+>Pair : AB<T, T>
 >T : T
->Tuple : Tuple<A, B>
+>AB : AB<A, B>
 >T : T
 >T : T
 
 interface TaggedPair<T> extends Pair<T> {
 >TaggedPair : TaggedPair<T>
 >T : T
->Pair : Tuple<T, T>
+>Pair : AB<T, T>
 >T : T
 
     tag: string;