Revert part of the removeMissingType and add a test for it

Author: Andarist

src/compiler/checker.ts

@@ -19927,10 +19927,11 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         let reportedError = false;
         for (const value of iterator) {
             const { errorNode: prop, innerExpression: next, nameType, errorMessage } = value;
-            const targetPropType = getBestMatchIndexedAccessTypeOrUndefined(source, target, nameType);
+            let targetPropType = getBestMatchIndexedAccessTypeOrUndefined(source, target, nameType);
             if (!targetPropType || targetPropType.flags & TypeFlags.IndexedAccess) continue; // Don't elaborate on indexes on generic variables
-            const sourcePropType = getIndexedAccessTypeOrUndefined(source, nameType);
+            let sourcePropType = getIndexedAccessTypeOrUndefined(source, nameType);
             if (!sourcePropType) continue;
+            const propName = getPropertyNameFromIndex(nameType, /*accessNode*/ undefined);
             if (!checkTypeRelatedTo(sourcePropType, targetPropType, relation, /*errorNode*/ undefined)) {
                 const elaborated = next && elaborateError(next, sourcePropType, targetPropType, relation, /*headMessage*/ undefined, containingMessageChain, errorOutputContainer);
                 reportedError = true;
@@ -19945,6 +19946,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                         resultObj.errors = [diag];
                     }
                     else {
+                        const targetIsOptional = !!(propName && (getPropertyOfType(target, propName) || unknownSymbol).flags & SymbolFlags.Optional);
+                        const sourceIsOptional = !!(propName && (getPropertyOfType(source, propName) || unknownSymbol).flags & SymbolFlags.Optional);
+                        targetPropType = removeMissingType(targetPropType, targetIsOptional);
+                        sourcePropType = removeMissingType(sourcePropType, targetIsOptional && sourceIsOptional);
                         const result = checkTypeRelatedTo(specificSource, targetPropType, relation, prop, errorMessage, containingMessageChain, resultObj);
                         if (result && specificSource !== sourcePropType) {
                             // If for whatever reason the expression type doesn't yield an error, make sure we still issue an error on the sourcePropType

tests/baselines/reference/strictOptionalPropertiesErrors1.errors.txt

@@ -0,0 +1,9 @@
+strictOptionalPropertiesErrors1.ts(2,15): error TS2322: Type 'string' is not assignable to type 'number | boolean'.
+
+
+==== strictOptionalPropertiesErrors1.ts (1 errors) ====
+    function test1(arg: [string, (boolean | number)?]) {}
+    test1(['foo', 'bar']);
+                  ~~~~~
+!!! error TS2322: Type 'string' is not assignable to type 'number | boolean'.
+    

tests/baselines/reference/strictOptionalPropertiesErrors1.symbols

@@ -0,0 +1,10 @@
+//// [tests/cases/compiler/strictOptionalPropertiesErrors1.ts] ////
+
+=== strictOptionalPropertiesErrors1.ts ===
+function test1(arg: [string, (boolean | number)?]) {}
+>test1 : Symbol(test1, Decl(strictOptionalPropertiesErrors1.ts, 0, 0))
+>arg : Symbol(arg, Decl(strictOptionalPropertiesErrors1.ts, 0, 15))
+
+test1(['foo', 'bar']);
+>test1 : Symbol(test1, Decl(strictOptionalPropertiesErrors1.ts, 0, 0))
+

tests/baselines/reference/strictOptionalPropertiesErrors1.types

@@ -0,0 +1,14 @@
+//// [tests/cases/compiler/strictOptionalPropertiesErrors1.ts] ////
+
+=== strictOptionalPropertiesErrors1.ts ===
+function test1(arg: [string, (boolean | number)?]) {}
+>test1 : (arg: [string, (boolean | number)?]) => void
+>arg : [string, (number | boolean)?]
+
+test1(['foo', 'bar']);
+>test1(['foo', 'bar']) : void
+>test1 : (arg: [string, (number | boolean)?]) => void
+>['foo', 'bar'] : [string, string]
+>'foo' : "foo"
+>'bar' : "bar"
+

tests/cases/compiler/strictOptionalPropertiesErrors1.ts

@@ -0,0 +1,6 @@
+// @strict: true
+// @exactOptionalPropertyTypes: true
+// @noEmit: true
+
+function test1(arg: [string, (boolean | number)?]) {}
+test1(['foo', 'bar']);