check index access for fixed length tuple

Author: Kingwl

src/compiler/checker.ts

@@ -18293,6 +18293,13 @@ namespace ts {
                 error(indexExpression, Diagnostics.A_const_enum_member_can_only_be_accessed_using_a_string_literal);
                 return errorType;
             }
+            if (isTupleType(objectType) && !objectType.target.hasRestElement && isNumericLiteral(indexExpression)) {
+                const index = +indexExpression.text;
+                const maximumIndex = length(objectType.target.typeParameters);
+                if (index >= maximumIndex) {
+                    error(indexExpression, Diagnostics.Indexed_access_0_is_out_of_range_of_tuple_the_maximum_of_index_is_1, index, maximumIndex);
+                }
+            }
 
             return checkIndexedAccessIndexType(getIndexedAccessType(objectType, indexType, node), node);
         }

src/compiler/diagnosticMessages.json

@@ -2437,6 +2437,10 @@
         "category": "Error",
         "code": 2732
     },
+    "Indexed access '{0}' is out of range of tuple, the maximum of index is '{1}'.": {
+        "category": "Error",
+        "code": 2733
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",

tests/baselines/reference/tupleLengthCheck.errors.txt

@@ -0,0 +1,21 @@
+tests/cases/conformance/types/tuple/tupleLengthCheck.ts(5,14): error TS2733: Indexed access '2' is out of range of tuple, the maximum of index is '2'.
+tests/cases/conformance/types/tuple/tupleLengthCheck.ts(6,14): error TS2733: Indexed access '1000' is out of range of tuple, the maximum of index is '2'.
+
+
+==== tests/cases/conformance/types/tuple/tupleLengthCheck.ts (2 errors) ====
+    declare const a: [number, string]
+    declare const rest: [number, string, ...boolean[]]
+    
+    const a1 = a[1]
+    const a2 = a[2]
+                 ~
+!!! error TS2733: Indexed access '2' is out of range of tuple, the maximum of index is '2'.
+    const a3 = a[1000]
+                 ~~~~
+!!! error TS2733: Indexed access '1000' is out of range of tuple, the maximum of index is '2'.
+    
+    const a4 = rest[1]
+    const a5 = rest[2]
+    const a6 = rest[3]
+    const a7 = rest[1000]
+    

tests/baselines/reference/tupleLengthCheck.js

@@ -0,0 +1,22 @@
+//// [tupleLengthCheck.ts]
+declare const a: [number, string]
+declare const rest: [number, string, ...boolean[]]
+
+const a1 = a[1]
+const a2 = a[2]
+const a3 = a[1000]
+
+const a4 = rest[1]
+const a5 = rest[2]
+const a6 = rest[3]
+const a7 = rest[1000]
+
+
+//// [tupleLengthCheck.js]
+var a1 = a[1];
+var a2 = a[2];
+var a3 = a[1000];
+var a4 = rest[1];
+var a5 = rest[2];
+var a6 = rest[3];
+var a7 = rest[1000];

tests/baselines/reference/tupleLengthCheck.symbols

@@ -0,0 +1,37 @@
+=== tests/cases/conformance/types/tuple/tupleLengthCheck.ts ===
+declare const a: [number, string]
+>a : Symbol(a, Decl(tupleLengthCheck.ts, 0, 13))
+
+declare const rest: [number, string, ...boolean[]]
+>rest : Symbol(rest, Decl(tupleLengthCheck.ts, 1, 13))
+
+const a1 = a[1]
+>a1 : Symbol(a1, Decl(tupleLengthCheck.ts, 3, 5))
+>a : Symbol(a, Decl(tupleLengthCheck.ts, 0, 13))
+>1 : Symbol(1)
+
+const a2 = a[2]
+>a2 : Symbol(a2, Decl(tupleLengthCheck.ts, 4, 5))
+>a : Symbol(a, Decl(tupleLengthCheck.ts, 0, 13))
+
+const a3 = a[1000]
+>a3 : Symbol(a3, Decl(tupleLengthCheck.ts, 5, 5))
+>a : Symbol(a, Decl(tupleLengthCheck.ts, 0, 13))
+
+const a4 = rest[1]
+>a4 : Symbol(a4, Decl(tupleLengthCheck.ts, 7, 5))
+>rest : Symbol(rest, Decl(tupleLengthCheck.ts, 1, 13))
+>1 : Symbol(1)
+
+const a5 = rest[2]
+>a5 : Symbol(a5, Decl(tupleLengthCheck.ts, 8, 5))
+>rest : Symbol(rest, Decl(tupleLengthCheck.ts, 1, 13))
+
+const a6 = rest[3]
+>a6 : Symbol(a6, Decl(tupleLengthCheck.ts, 9, 5))
+>rest : Symbol(rest, Decl(tupleLengthCheck.ts, 1, 13))
+
+const a7 = rest[1000]
+>a7 : Symbol(a7, Decl(tupleLengthCheck.ts, 10, 5))
+>rest : Symbol(rest, Decl(tupleLengthCheck.ts, 1, 13))
+

tests/baselines/reference/tupleLengthCheck.types

@@ -0,0 +1,49 @@
+=== tests/cases/conformance/types/tuple/tupleLengthCheck.ts ===
+declare const a: [number, string]
+>a : [number, string]
+
+declare const rest: [number, string, ...boolean[]]
+>rest : [number, string, ...boolean[]]
+
+const a1 = a[1]
+>a1 : string
+>a[1] : string
+>a : [number, string]
+>1 : 1
+
+const a2 = a[2]
+>a2 : string | number
+>a[2] : string | number
+>a : [number, string]
+>2 : 2
+
+const a3 = a[1000]
+>a3 : string | number
+>a[1000] : string | number
+>a : [number, string]
+>1000 : 1000
+
+const a4 = rest[1]
+>a4 : string
+>rest[1] : string
+>rest : [number, string, ...boolean[]]
+>1 : 1
+
+const a5 = rest[2]
+>a5 : boolean
+>rest[2] : boolean
+>rest : [number, string, ...boolean[]]
+>2 : 2
+
+const a6 = rest[3]
+>a6 : boolean
+>rest[3] : boolean
+>rest : [number, string, ...boolean[]]
+>3 : 3
+
+const a7 = rest[1000]
+>a7 : boolean
+>rest[1000] : boolean
+>rest : [number, string, ...boolean[]]
+>1000 : 1000
+

tests/cases/conformance/types/tuple/tupleLengthCheck.ts

@@ -0,0 +1,11 @@
+declare const a: [number, string]
+declare const rest: [number, string, ...boolean[]]
+
+const a1 = a[1]
+const a2 = a[2]
+const a3 = a[1000]
+
+const a4 = rest[1]
+const a5 = rest[2]
+const a6 = rest[3]
+const a7 = rest[1000]