Always remove undefined from the type arguments at tuples' optional elements

Author: Andarist

Diff for: src/compiler/checker.ts

@@ -12862,7 +12862,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             indexInfos = source.declaredIndexInfos;
         }
         else {
-            mapper = createTypeMapper(typeParameters, typeArguments);
+            mapper = createTypeMapper(
+                typeParameters,
+                isTupleType(type) ? map(typeArguments, (t, i) => addOptionality(t, /*isProperty*/ true, !!(type.target.elementFlags[i] & ElementFlags.Optional))) : typeArguments
+            );
             members = createInstantiatedSymbolTable(source.declaredProperties, mapper, /*mappingThisOnly*/ typeParameters.length === 1);
             callSignatures = instantiateSignatures(source.declaredCallSignatures, mapper);
             constructSignatures = instantiateSignatures(source.declaredConstructSignatures, mapper);
@@ -15563,7 +15566,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             const typeArguments = !node ? emptyArray :
                 node.kind === SyntaxKind.TypeReference ? concatenate(type.target.outerTypeParameters, getEffectiveTypeArguments(node, type.target.localTypeParameters!)) :
                 node.kind === SyntaxKind.ArrayType ? [getTypeFromTypeNode(node.elementType)] :
-                map(node.elements, element => removeMissingType(getTypeFromTypeNode(element), element.kind === SyntaxKind.OptionalType));
+                map(node.elements, element => getTypeFromTypeNode(element.kind === SyntaxKind.OptionalType ? (element as OptionalTypeNode).type : element));
             if (popTypeResolution()) {
                 type.resolvedTypeArguments = type.mapper ? instantiateTypes(typeArguments, type.mapper) : typeArguments;
             }
@@ -22723,11 +22726,13 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                             }
                         }
 
+                        // TODO: recheck if `addOptionality` shouldn't get called here as well
                         const sourceType = removeMissingType(sourceTypeArguments[sourcePosition], !!(sourceFlags & targetFlags & ElementFlags.Optional));
                         const targetType = targetTypeArguments[targetPosition];
+                        const isTargetOptional = !!(targetFlags & ElementFlags.Optional);
 
                         const targetCheckType = sourceFlags & ElementFlags.Variadic && targetFlags & ElementFlags.Rest ? createArrayType(targetType) :
-                            removeMissingType(targetType, !!(targetFlags & ElementFlags.Optional));
+                            removeMissingType(addOptionality(targetType, /*isProperty*/ true, isTargetOptional), isTargetOptional);
                         const related = isRelatedTo(sourceType, targetCheckType, RecursionFlags.Both, reportErrors, /*headMessage*/ undefined, intersectionState);
                         if (!related) {
                             if (reportErrors && (targetArity > 1 || sourceArity > 1)) {

Diff for: tests/baselines/reference/destructuringControlFlow.types

@@ -162,7 +162,7 @@ function f4() {
 // Repro from #31770
 
 type KeyValue = [string, string?];
->KeyValue : [string, (string | undefined)?]
+>KeyValue : [string, string?]
 
 let [key, value]: KeyValue = ["foo"];
 >key : string

Diff for: tests/baselines/reference/forOfOptionalTupleMember(exactoptionalpropertytypes=false,target=es5).types

@@ -12,7 +12,7 @@ type Item = {
 };
 
 type Foo = [Item?];
->Foo : [(Item | undefined)?]
+>Foo : [Item?]
 
 declare const foo: Foo;
 >foo : Foo

Diff for: tests/baselines/reference/forOfOptionalTupleMember(exactoptionalpropertytypes=false,target=esnext).types

@@ -12,7 +12,7 @@ type Item = {
 };
 
 type Foo = [Item?];
->Foo : [(Item | undefined)?]
+>Foo : [Item?]
 
 declare const foo: Foo;
 >foo : Foo

Diff for: tests/baselines/reference/forOfOptionalTupleMember(exactoptionalpropertytypes=true,target=es5).errors.txt

@@ -0,0 +1,20 @@
+forOfOptionalTupleMember.ts(12,3): error TS18048: 'item' is possibly 'undefined'.
+
+
+==== forOfOptionalTupleMember.ts (1 errors) ====
+    // repro from https://github.com/microsoft/TypeScript/issues/54302
+    
+    type Item = {
+      value: string;
+    };
+    
+    type Foo = [Item?];
+    
+    declare const foo: Foo;
+    
+    for (let item of foo) {
+      item.value;
+      ~~~~
+!!! error TS18048: 'item' is possibly 'undefined'.
+    }
+    

Diff for: tests/baselines/reference/forOfOptionalTupleMember(exactoptionalpropertytypes=true,target=es5).types

@@ -18,12 +18,12 @@ declare const foo: Foo;
 >foo : Foo
 
 for (let item of foo) {
->item : Item
+>item : Item | undefined
 >foo : Foo
 
   item.value;
 >item.value : string
->item : Item
+>item : Item | undefined
 >value : string
 }
 

Diff for: tests/baselines/reference/forOfOptionalTupleMember(exactoptionalpropertytypes=true,target=esnext).errors.txt

@@ -0,0 +1,20 @@
+forOfOptionalTupleMember.ts(12,3): error TS18048: 'item' is possibly 'undefined'.
+
+
+==== forOfOptionalTupleMember.ts (1 errors) ====
+    // repro from https://github.com/microsoft/TypeScript/issues/54302
+    
+    type Item = {
+      value: string;
+    };
+    
+    type Foo = [Item?];
+    
+    declare const foo: Foo;
+    
+    for (let item of foo) {
+      item.value;
+      ~~~~
+!!! error TS18048: 'item' is possibly 'undefined'.
+    }
+    

Diff for: tests/baselines/reference/forOfOptionalTupleMember(exactoptionalpropertytypes=true,target=esnext).types

@@ -18,12 +18,12 @@ declare const foo: Foo;
 >foo : Foo
 
 for (let item of foo) {
->item : Item
+>item : Item | undefined
 >foo : Foo
 
   item.value;
 >item.value : string
->item : Item
+>item : Item | undefined
 >value : string
 }
 

Diff for: tests/baselines/reference/optionalTupleElements1.types

@@ -5,13 +5,13 @@ type T1 = [number, string, boolean];
 >T1 : [number, string, boolean]
 
 type T2 = [number, string, boolean?];
->T2 : [number, string, (boolean | undefined)?]
+>T2 : [number, string, boolean?]
 
 type T3 = [number, string?, boolean?];
->T3 : [number, (string | undefined)?, (boolean | undefined)?]
+>T3 : [number, string?, boolean?]
 
 type T4 = [number?, string?, boolean?];
->T4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
+>T4 : [number?, string?, boolean?]
 
 type L1 = T1["length"];
 >L1 : 3
@@ -26,7 +26,7 @@ type L4 = T4["length"];
 >L4 : 0 | 3 | 2 | 1
 
 type T5 = [number, string?, boolean];  // Error
->T5 : [number, (string | undefined)?, boolean]
+>T5 : [number, string?, boolean]
 
 function f1(t1: T1, t2: T2, t3: T3, t4: T4) {
 >f1 : (t1: T1, t2: T2, t3: T3, t4: T4) => void

Diff for: tests/baselines/reference/restTupleElements1.types

@@ -2,13 +2,13 @@
 
 === restTupleElements1.ts ===
 type T00 = [string?];
->T00 : [(string | undefined)?]
+>T00 : [string?]
 
 type T01 = [string, string?];
->T01 : [string, (string | undefined)?]
+>T01 : [string, string?]
 
 type T02 = [string?, string];  // Error
->T02 : [(string | undefined)?, string]
+>T02 : [string?, string]
 
 type T03 = [...string[]];
 >T03 : string[]

Diff for: tests/baselines/reference/variadicTuples2.types

@@ -16,10 +16,10 @@ type V10 = [number, ...string[], ...boolean[]];  // Error
 >V10 : [number, ...string[], ...boolean[]]
 
 type V11 = [number, ...string[], boolean?];  // Error
->V11 : [number, ...string[], (boolean | undefined)?]
+>V11 : [number, ...string[], boolean?]
 
 type V12 = [number, string?, boolean];  // Error
->V12 : [number, (string | undefined)?, boolean]
+>V12 : [number, string?, boolean]
 
 // Normalization