diff --git a/Gulpfile.js b/Gulpfile.js
index 51127f9822d..1f930e3b019 100644
--- a/Gulpfile.js
+++ b/Gulpfile.js
@@ -333,6 +333,8 @@ task("run-eslint-rules-tests").description = "Runs the eslint rule tests";
 
 const lintFoldStart = async () => { if (fold.isTravis()) console.log(fold.start("lint")); };
 const lintFoldEnd = async () => { if (fold.isTravis()) console.log(fold.end("lint")); };
+
+/** @type { (folder: string) => { (): Promise<any>; displayName?: string } } */
 const eslint = (folder) => async () => {
     const ESLINTRC_CI = ".eslintrc.ci.json";
     const isCIEnv = cmdLineOptions.ci || process.env.CI === "true";
diff --git a/scripts/processDiagnosticMessages.ts b/scripts/processDiagnosticMessages.ts
index 4bdf3ca0178..7577707340a 100644
--- a/scripts/processDiagnosticMessages.ts
+++ b/scripts/processDiagnosticMessages.ts
@@ -6,6 +6,7 @@ interface DiagnosticDetails {
     code: number;
     reportsUnnecessary?: {};
     isEarly?: boolean;
+    elidedInCompatabilityPyramid?: boolean;
 }
 
 type InputDiagnosticMessageTable = Map<string, DiagnosticDetails>;
@@ -63,14 +64,15 @@ function buildInfoFileOutput(messageTable: InputDiagnosticMessageTable, inputFil
         "// generated from '" + inputFilePathRel + "' by '" + thisFilePathRel.replace(/\\/g, "/") + "'\r\n" +
         "/* @internal */\r\n" +
         "namespace ts {\r\n" +
-        "    function diag(code: number, category: DiagnosticCategory, key: string, message: string, reportsUnnecessary?: {}): DiagnosticMessage {\r\n" +
-        "        return { code, category, key, message, reportsUnnecessary };\r\n" +
+        "    function diag(code: number, category: DiagnosticCategory, key: string, message: string, reportsUnnecessary?: {}, elidedInCompatabilityPyramid?: boolean): DiagnosticMessage {\r\n" +
+        "        return { code, category, key, message, reportsUnnecessary, elidedInCompatabilityPyramid };\r\n" +
         "    }\r\n" +
         "    export const Diagnostics = {\r\n";
-    messageTable.forEach(({ code, category, reportsUnnecessary }, name) => {
+    messageTable.forEach(({ code, category, reportsUnnecessary, elidedInCompatabilityPyramid }, name) => {
         const propName = convertPropertyName(name);
         const argReportsUnnecessary = reportsUnnecessary ? `, /*reportsUnnecessary*/ ${reportsUnnecessary}` : "";
-        result += `        ${propName}: diag(${code}, DiagnosticCategory.${category}, "${createKey(propName, code)}", ${JSON.stringify(name)}${argReportsUnnecessary}),\r\n`;
+        const argElidedInCompatabilityPyramid = elidedInCompatabilityPyramid ? `${!reportsUnnecessary ? ", /*reportsUnnecessary*/ undefined" : ""}, /*elidedInCompatabilityPyramid*/ ${elidedInCompatabilityPyramid}` : "";
+        result += `        ${propName}: diag(${code}, DiagnosticCategory.${category}, "${createKey(propName, code)}", ${JSON.stringify(name)}${argReportsUnnecessary}${argElidedInCompatabilityPyramid}),\r\n`;
     });
 
     result += "    };\r\n}";
diff --git a/scripts/types/ambient.d.ts b/scripts/types/ambient.d.ts
index 9ea70adee50..d48de7c05d7 100644
--- a/scripts/types/ambient.d.ts
+++ b/scripts/types/ambient.d.ts
@@ -76,10 +76,15 @@ declare module "undertaker" {
     interface TaskFunctionParams {
         flags?: Record<string, string>;
     }
+    interface TaskFunctionWrapped {
+        description: string
+        flags: { [name: string]: string }
+    }
 }
 
 declare module "gulp-sourcemaps" {
     interface WriteOptions {
         destPath?: string;
     }
-}
\ No newline at end of file
+
+}
diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
index 705ec3b75f4..1d6627987e1 100644
--- a/src/compiler/binder.ts
+++ b/src/compiler/binder.ts
@@ -564,7 +564,7 @@ namespace ts {
                 if (!isIIFE) {
                     currentFlow = { flags: FlowFlags.Start };
                     if (containerFlags & (ContainerFlags.IsFunctionExpression | ContainerFlags.IsObjectLiteralOrClassExpressionMethod)) {
-                        currentFlow.container = <FunctionExpression | ArrowFunction | MethodDeclaration>node;
+                        currentFlow.node = <FunctionExpression | ArrowFunction | MethodDeclaration>node;
                     }
                 }
                 // We create a return control flow graph for IIFEs and constructors. For constructors
@@ -581,6 +581,7 @@ namespace ts {
                 if (!(currentFlow.flags & FlowFlags.Unreachable) && containerFlags & ContainerFlags.IsFunctionLike && nodeIsPresent((<FunctionLikeDeclaration>node).body)) {
                     node.flags |= NodeFlags.HasImplicitReturn;
                     if (hasExplicitReturn) node.flags |= NodeFlags.HasExplicitReturn;
+                    (<FunctionLikeDeclaration>node).endFlowNode = currentFlow;
                 }
                 if (node.kind === SyntaxKind.SourceFile) {
                     node.flags |= emitFlags;
@@ -671,6 +672,9 @@ namespace ts {
                 bindJSDoc(node);
                 return;
             }
+            if (node.kind >= SyntaxKind.FirstStatement && node.kind <= SyntaxKind.LastStatement && !options.allowUnreachableCode) {
+                node.flowNode = currentFlow;
+            }
             switch (node.kind) {
                 case SyntaxKind.WhileStatement:
                     bindWhileStatement(<WhileStatement>node);
@@ -708,6 +712,9 @@ namespace ts {
                 case SyntaxKind.CaseClause:
                     bindCaseClause(<CaseClause>node);
                     break;
+                case SyntaxKind.ExpressionStatement:
+                    bindExpressionStatement(<ExpressionStatement>node);
+                    break;
                 case SyntaxKind.LabeledStatement:
                     bindLabeledStatement(<LabeledStatement>node);
                     break;
@@ -845,17 +852,11 @@ namespace ts {
         }
 
         function createBranchLabel(): FlowLabel {
-            return {
-                flags: FlowFlags.BranchLabel,
-                antecedents: undefined
-            };
+            return { flags: FlowFlags.BranchLabel, antecedents: undefined };
         }
 
         function createLoopLabel(): FlowLabel {
-            return {
-                flags: FlowFlags.LoopLabel,
-                antecedents: undefined
-            };
+            return { flags: FlowFlags.LoopLabel, antecedents: undefined };
         }
 
         function setFlowNodeReferenced(flow: FlowNode) {
@@ -885,7 +886,7 @@ namespace ts {
                 return antecedent;
             }
             setFlowNodeReferenced(antecedent);
-            return flowNodeCreated({ flags, expression, antecedent });
+            return flowNodeCreated({ flags, antecedent, node: expression });
         }
 
         function createFlowSwitchClause(antecedent: FlowNode, switchStatement: SwitchStatement, clauseStart: number, clauseEnd: number): FlowNode {
@@ -893,7 +894,7 @@ namespace ts {
                 return antecedent;
             }
             setFlowNodeReferenced(antecedent);
-            return flowNodeCreated({ flags: FlowFlags.SwitchClause, switchStatement, clauseStart, clauseEnd, antecedent });
+            return flowNodeCreated({ flags: FlowFlags.SwitchClause, antecedent, switchStatement, clauseStart, clauseEnd });
         }
 
         function createFlowAssignment(antecedent: FlowNode, node: Expression | VariableDeclaration | BindingElement): FlowNode {
@@ -901,10 +902,14 @@ namespace ts {
             return flowNodeCreated({ flags: FlowFlags.Assignment, antecedent, node });
         }
 
+        function createFlowCall(antecedent: FlowNode, node: CallExpression): FlowNode {
+            setFlowNodeReferenced(antecedent);
+            return flowNodeCreated({ flags: FlowFlags.Call, antecedent, node });
+        }
+
         function createFlowArrayMutation(antecedent: FlowNode, node: CallExpression | BinaryExpression): FlowNode {
             setFlowNodeReferenced(antecedent);
-            const res: FlowArrayMutation = flowNodeCreated({ flags: FlowFlags.ArrayMutation, antecedent, node });
-            return res;
+            return flowNodeCreated({ flags: FlowFlags.ArrayMutation, antecedent, node });
         }
 
         function finishFlowLabel(flow: FlowLabel): FlowNode {
@@ -1030,12 +1035,12 @@ namespace ts {
         function bindForInOrForOfStatement(node: ForInOrOfStatement): void {
             const preLoopLabel = createLoopLabel();
             const postLoopLabel = createBranchLabel();
+            bind(node.expression);
             addAntecedent(preLoopLabel, currentFlow);
             currentFlow = preLoopLabel;
             if (node.kind === SyntaxKind.ForOfStatement) {
                 bind(node.awaitModifier);
             }
-            bind(node.expression);
             addAntecedent(postLoopLabel, currentFlow);
             bind(node.initializer);
             if (node.initializer.kind !== SyntaxKind.VariableDeclarationList) {
@@ -1222,7 +1227,8 @@ namespace ts {
             addAntecedent(postSwitchLabel, currentFlow);
             const hasDefault = forEach(node.caseBlock.clauses, c => c.kind === SyntaxKind.DefaultClause);
             // We mark a switch statement as possibly exhaustive if it has no default clause and if all
-            // case clauses have unreachable end points (e.g. they all return).
+            // case clauses have unreachable end points (e.g. they all return). Note, we no longer need
+            // this property in control flow analysis, it's there only for backwards compatibility.
             node.possiblyExhaustive = !hasDefault && !postSwitchLabel.antecedents;
             if (!hasDefault) {
                 addAntecedent(postSwitchLabel, createFlowSwitchClause(preSwitchCaseFlow, node, 0, 0));
@@ -1281,6 +1287,24 @@ namespace ts {
             activeLabels!.pop();
         }
 
+        function isDottedName(node: Expression): boolean {
+            return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ThisKeyword ||
+                node.kind === SyntaxKind.PropertyAccessExpression && isDottedName((<PropertyAccessExpression>node).expression) ||
+                node.kind === SyntaxKind.ParenthesizedExpression && isDottedName((<ParenthesizedExpression>node).expression);
+        }
+
+        function bindExpressionStatement(node: ExpressionStatement): void {
+            bind(node.expression);
+            // A top level call expression with a dotted function name and at least one argument
+            // is potentially an assertion and is therefore included in the control flow.
+            if (node.expression.kind === SyntaxKind.CallExpression) {
+                const call = <CallExpression>node.expression;
+                if (isDottedName(call.expression)) {
+                    currentFlow = createFlowCall(currentFlow, call);
+                }
+            }
+        }
+
         function bindLabeledStatement(node: LabeledStatement): void {
             const preStatementLabel = createLoopLabel();
             const postStatementLabel = createBranchLabel();
diff --git a/src/compiler/builder.ts b/src/compiler/builder.ts
index 36521a14eae..7451eb678b4 100644
--- a/src/compiler/builder.ts
+++ b/src/compiler/builder.ts
@@ -425,7 +425,7 @@ namespace ts {
                 const options = program.getCompilerOptions();
                 forEach(program.getSourceFiles(), f =>
                     program.isSourceFileDefaultLibrary(f) &&
-                    !skipTypeChecking(f, options) &&
+                    !skipTypeChecking(f, options, program) &&
                     removeSemanticDiagnosticsOf(state, f.path)
                 );
             }
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 28e20febdcd..59b75691a03 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -177,6 +177,7 @@ namespace ts {
     const enum ContextFlags {
         None = 0,
         Signature = 1 << 0,  // Obtaining contextual signature
+        NoConstraints = 1 << 1,  // Don't obtain type variable constraints
     }
 
     const enum AccessFlags {
@@ -522,6 +523,9 @@ namespace ts {
             },
             getApparentType,
             getUnionType,
+            isTypeAssignableTo: (source, target) => {
+                return isTypeAssignableTo(source, target);
+            },
             createAnonymousType,
             createSignature,
             createSymbol,
@@ -568,7 +572,7 @@ namespace ts {
                 return node && getTypeArgumentConstraint(node);
             },
             getSuggestionDiagnostics: (file, ct) => {
-                if (skipTypeChecking(file, compilerOptions)) {
+                if (skipTypeChecking(file, compilerOptions, host)) {
                     return emptyArray;
                 }
 
@@ -671,6 +675,7 @@ namespace ts {
         const silentNeverType = createIntrinsicType(TypeFlags.Never, "never");
         const nonInferrableType = createIntrinsicType(TypeFlags.Never, "never", ObjectFlags.NonInferrableType);
         const implicitNeverType = createIntrinsicType(TypeFlags.Never, "never");
+        const unreachableNeverType = createIntrinsicType(TypeFlags.Never, "never");
         const nonPrimitiveType = createIntrinsicType(TypeFlags.NonPrimitive, "object");
         const stringNumberSymbolType = getUnionType([stringType, numberType, esSymbolType]);
         const keyofConstraintType = keyofStringsOnly ? stringType : stringNumberSymbolType;
@@ -701,7 +706,7 @@ namespace ts {
         markerSubType.constraint = markerSuperType;
         const markerOtherType = createTypeParameter();
 
-        const noTypePredicate = createIdentifierTypePredicate("<<unresolved>>", 0, anyType);
+        const noTypePredicate = createTypePredicate(TypePredicateKind.Identifier, "<<unresolved>>", 0, anyType);
 
         const anySignature = createSignature(undefined, undefined, undefined, emptyArray, anyType, /*resolvedTypePredicate*/ undefined, 0, /*hasRestParameter*/ false, /*hasLiteralTypes*/ false);
         const unknownSignature = createSignature(undefined, undefined, undefined, emptyArray, errorType, /*resolvedTypePredicate*/ undefined, 0, /*hasRestParameter*/ false, /*hasLiteralTypes*/ false);
@@ -820,6 +825,8 @@ namespace ts {
         let sharedFlowCount = 0;
         let flowAnalysisDisabled = false;
         let flowInvocationCount = 0;
+        let lastFlowNode: FlowNode | undefined;
+        let lastFlowNodeReachable: boolean;
 
         const emptyStringType = getLiteralType("");
         const zeroType = getLiteralType(0);
@@ -841,6 +848,7 @@ namespace ts {
         const flowLoopTypes: Type[][] = [];
         const sharedFlowNodes: FlowNode[] = [];
         const sharedFlowTypes: FlowType[] = [];
+        const flowNodeReachable: (boolean | undefined)[] = [];
         const potentialThisCollisions: Node[] = [];
         const potentialNewTargetCollisions: Node[] = [];
         const awaitedTypeStack: number[] = [];
@@ -4246,11 +4254,14 @@ namespace ts {
                 let returnTypeNode: TypeNode | undefined;
                 const typePredicate = getTypePredicateOfSignature(signature);
                 if (typePredicate) {
-                    const parameterName = typePredicate.kind === TypePredicateKind.Identifier ?
+                    const assertsModifier = typePredicate.kind === TypePredicateKind.AssertsThis || typePredicate.kind === TypePredicateKind.AssertsIdentifier ?
+                        createToken(SyntaxKind.AssertsKeyword) :
+                        undefined;
+                    const parameterName = typePredicate.kind === TypePredicateKind.Identifier || typePredicate.kind === TypePredicateKind.AssertsIdentifier ?
                         setEmitFlags(createIdentifier(typePredicate.parameterName), EmitFlags.NoAsciiEscaping) :
                         createThisTypeNode();
-                    const typeNode = typeToTypeNodeHelper(typePredicate.type, context);
-                    returnTypeNode = createTypePredicateNode(parameterName, typeNode);
+                    const typeNode = typePredicate.type && typeToTypeNodeHelper(typePredicate.type, context);
+                    returnTypeNode = createTypePredicateNodeWithModifier(assertsModifier, parameterName, typeNode);
                 }
                 else {
                     const returnType = getReturnTypeOfSignature(signature);
@@ -4717,9 +4728,10 @@ namespace ts {
             return writer ? typePredicateToStringWorker(writer).getText() : usingSingleLineStringWriter(typePredicateToStringWorker);
 
             function typePredicateToStringWorker(writer: EmitTextWriter) {
-                const predicate = createTypePredicateNode(
-                    typePredicate.kind === TypePredicateKind.Identifier ? createIdentifier(typePredicate.parameterName) : createThisTypeNode(),
-                    nodeBuilder.typeToTypeNode(typePredicate.type, enclosingDeclaration, toNodeBuilderFlags(flags) | NodeBuilderFlags.IgnoreErrors | NodeBuilderFlags.WriteTypeParametersInQualifiedName)!, // TODO: GH#18217
+                const predicate = createTypePredicateNodeWithModifier(
+                    typePredicate.kind === TypePredicateKind.AssertsThis || typePredicate.kind === TypePredicateKind.AssertsIdentifier ? createToken(SyntaxKind.AssertsKeyword) : undefined,
+                    typePredicate.kind === TypePredicateKind.Identifier || typePredicate.kind === TypePredicateKind.AssertsIdentifier ? createIdentifier(typePredicate.parameterName) : createThisTypeNode(),
+                    typePredicate.type && nodeBuilder.typeToTypeNode(typePredicate.type, enclosingDeclaration, toNodeBuilderFlags(flags) | NodeBuilderFlags.IgnoreErrors | NodeBuilderFlags.WriteTypeParametersInQualifiedName)! // TODO: GH#18217
                 );
                 const printer = createPrinter({ removeComments: true });
                 const sourceFile = enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration);
@@ -5984,7 +5996,9 @@ namespace ts {
 
         function getBaseTypeVariableOfClass(symbol: Symbol) {
             const baseConstructorType = getBaseConstructorTypeOfClass(getDeclaredTypeOfClassOrInterface(symbol));
-            return baseConstructorType.flags & TypeFlags.TypeVariable ? baseConstructorType : undefined;
+            return baseConstructorType.flags & TypeFlags.TypeVariable ? baseConstructorType :
+                baseConstructorType.flags & TypeFlags.Intersection ? find((baseConstructorType as IntersectionType).types, t => !!(t.flags & TypeFlags.TypeVariable)) :
+                undefined;
         }
 
         function getTypeOfFuncClassEnumModule(symbol: Symbol): Type {
@@ -6262,12 +6276,12 @@ namespace ts {
         }
 
         function isConstructorType(type: Type): boolean {
-            if (isValidBaseType(type) && getSignaturesOfType(type, SignatureKind.Construct).length > 0) {
+            if (getSignaturesOfType(type, SignatureKind.Construct).length > 0) {
                 return true;
             }
             if (type.flags & TypeFlags.TypeVariable) {
                 const constraint = getBaseConstraintOfType(type);
-                return !!constraint && isValidBaseType(constraint) && isMixinConstructorType(constraint);
+                return !!constraint && isMixinConstructorType(constraint);
             }
             return false;
         }
@@ -6428,9 +6442,16 @@ namespace ts {
             return true;
         }
 
-        // A valid base type is `any`, any non-generic object type or intersection of non-generic
-        // object types.
+        // A valid base type is `any`, an object type or intersection of object types.
         function isValidBaseType(type: Type): type is BaseType {
+            if (type.flags & TypeFlags.TypeParameter) {
+                const constraint = getBaseConstraintOfType(type);
+                if (constraint) {
+                    return isValidBaseType(constraint);
+                }
+            }
+            // TODO: Given that we allow type parmeters here now, is this `!isGenericMappedType(type)` check really needed?
+            // There's no reason a `T` should be allowed while a `Readonly<T>` should not.
             return !!(type.flags & (TypeFlags.Object | TypeFlags.NonPrimitive | TypeFlags.Any)) && !isGenericMappedType(type) ||
                 !!(type.flags & TypeFlags.Intersection) && every((<IntersectionType>type).types, isValidBaseType);
         }
@@ -7955,10 +7976,10 @@ namespace ts {
             return hasNonCircularBaseConstraint(type) ? getConstraintFromConditionalType(type) : undefined;
         }
 
-        function getUnionConstraintOfIntersection(type: IntersectionType, targetIsUnion: boolean) {
+        function getEffectiveConstraintOfIntersection(types: readonly Type[], targetIsUnion: boolean) {
             let constraints: Type[] | undefined;
             let hasDisjointDomainType = false;
-            for (const t of type.types) {
+            for (const t of types) {
                 if (t.flags & TypeFlags.Instantiable) {
                     // We keep following constraints as long as we have an instantiable type that is known
                     // not to be circular or infinite (hence we stop on index access types).
@@ -7968,6 +7989,9 @@ namespace ts {
                     }
                     if (constraint) {
                         constraints = append(constraints, constraint);
+                        if (targetIsUnion) {
+                            constraints = append(constraints, t);
+                        }
                     }
                 }
                 else if (t.flags & TypeFlags.DisjointDomains) {
@@ -7980,7 +8004,7 @@ namespace ts {
                 if (hasDisjointDomainType) {
                     // We add any types belong to one of the disjoint domains because they might cause the final
                     // intersection operation to reduce the union constraints.
-                    for (const t of type.types) {
+                    for (const t of types) {
                         if (t.flags & TypeFlags.DisjointDomains) {
                             constraints = append(constraints, t);
                         }
@@ -8484,12 +8508,8 @@ namespace ts {
             return isBracketed || !!typeExpression && typeExpression.type.kind === SyntaxKind.JSDocOptionalType;
         }
 
-        function createIdentifierTypePredicate(parameterName: string, parameterIndex: number, type: Type): IdentifierTypePredicate {
-            return { kind: TypePredicateKind.Identifier, parameterName, parameterIndex, type };
-        }
-
-        function createThisTypePredicate(type: Type): ThisTypePredicate {
-            return { kind: TypePredicateKind.This, type };
+        function createTypePredicate(kind: TypePredicateKind, parameterName: string | undefined, parameterIndex: number | undefined, type: Type | undefined): TypePredicate {
+            return { kind, parameterName, parameterIndex, type } as TypePredicate;
         }
 
         /**
@@ -8724,10 +8744,6 @@ namespace ts {
             }
         }
 
-        function signatureHasTypePredicate(signature: Signature): boolean {
-            return getTypePredicateOfSignature(signature) !== undefined;
-        }
-
         function getTypePredicateOfSignature(signature: Signature): TypePredicate | undefined {
             if (!signature.resolvedTypePredicate) {
                 if (signature.target) {
@@ -8755,18 +8771,13 @@ namespace ts {
             return signature.resolvedTypePredicate === noTypePredicate ? undefined : signature.resolvedTypePredicate;
         }
 
-        function createTypePredicateFromTypePredicateNode(node: TypePredicateNode, signature: Signature): IdentifierTypePredicate | ThisTypePredicate {
-            const { parameterName } = node;
-            const type = getTypeFromTypeNode(node.type);
-            if (parameterName.kind === SyntaxKind.Identifier) {
-                return createIdentifierTypePredicate(
-                    parameterName.escapedText as string,
-                    findIndex(signature.parameters, p => p.escapedName === parameterName.escapedText),
-                    type);
-            }
-            else {
-                return createThisTypePredicate(type);
-            }
+        function createTypePredicateFromTypePredicateNode(node: TypePredicateNode, signature: Signature): TypePredicate {
+            const parameterName = node.parameterName;
+            const type = node.type && getTypeFromTypeNode(node.type);
+            return parameterName.kind === SyntaxKind.ThisType ?
+                createTypePredicate(node.assertsModifier ? TypePredicateKind.AssertsThis : TypePredicateKind.This, /*parameterName*/ undefined, /*parameterIndex*/ undefined, type) :
+                createTypePredicate(node.assertsModifier ? TypePredicateKind.AssertsIdentifier : TypePredicateKind.Identifier, parameterName.escapedText as string,
+                    findIndex(signature.parameters, p => p.escapedName === parameterName.escapedText), type);
         }
 
         function getReturnTypeOfSignature(signature: Signature): Type {
@@ -9855,7 +9866,7 @@ namespace ts {
             const types: Type[] = [];
             for (const sig of signatures) {
                 const pred = getTypePredicateOfSignature(sig);
-                if (!pred) {
+                if (!pred || pred.kind === TypePredicateKind.AssertsThis || pred.kind === TypePredicateKind.AssertsIdentifier) {
                     continue;
                 }
 
@@ -9875,15 +9886,11 @@ namespace ts {
                 return undefined;
             }
             const unionType = getUnionType(types);
-            return isIdentifierTypePredicate(first)
-                ? createIdentifierTypePredicate(first.parameterName, first.parameterIndex, unionType)
-                : createThisTypePredicate(unionType);
+            return createTypePredicate(first.kind, first.parameterName, first.parameterIndex, unionType);
         }
 
         function typePredicateKindsMatch(a: TypePredicate, b: TypePredicate): boolean {
-            return isIdentifierTypePredicate(a)
-                ? isIdentifierTypePredicate(b) && a.parameterIndex === b.parameterIndex
-                : !isIdentifierTypePredicate(b);
+            return a.kind === b.kind && a.parameterIndex === b.parameterIndex;
         }
 
         // This function assumes the constituent type list is sorted and deduplicated.
@@ -11183,7 +11190,7 @@ namespace ts {
                 case SyntaxKind.TypeReference:
                     return getTypeFromTypeReference(<TypeReferenceNode>node);
                 case SyntaxKind.TypePredicate:
-                    return booleanType;
+                    return (<TypePredicateNode>node).assertsModifier ? voidType : booleanType;
                 case SyntaxKind.ExpressionWithTypeArguments:
                     return getTypeFromTypeReference(<ExpressionWithTypeArguments>node);
                 case SyntaxKind.TypeQuery:
@@ -11341,21 +11348,8 @@ namespace ts {
             return result;
         }
 
-        function instantiateTypePredicate(predicate: TypePredicate, mapper: TypeMapper): ThisTypePredicate | IdentifierTypePredicate {
-            if (isIdentifierTypePredicate(predicate)) {
-                return {
-                    kind: TypePredicateKind.Identifier,
-                    parameterName: predicate.parameterName,
-                    parameterIndex: predicate.parameterIndex,
-                    type: instantiateType(predicate.type, mapper)
-                };
-            }
-            else {
-                return {
-                    kind: TypePredicateKind.This,
-                    type: instantiateType(predicate.type, mapper)
-                };
-            }
+        function instantiateTypePredicate(predicate: TypePredicate, mapper: TypeMapper): TypePredicate {
+            return createTypePredicate(predicate.kind, predicate.parameterName, predicate.parameterIndex, instantiateType(predicate.type, mapper));
         }
 
         function instantiateSignature(signature: Signature, mapper: TypeMapper, eraseTypeParameters?: boolean): Signature {
@@ -12319,7 +12313,7 @@ namespace ts {
             target: Signature,
             ignoreReturnTypes: boolean): boolean {
             return compareSignaturesRelated(source, target, CallbackCheck.None, ignoreReturnTypes, /*reportErrors*/ false,
-                /*errorReporter*/ undefined, compareTypesAssignable) !== Ternary.False;
+                /*errorReporter*/ undefined, /*errorReporter*/ undefined, compareTypesAssignable) !== Ternary.False;
         }
 
         type ErrorReporter = (message: DiagnosticMessage, arg0?: string, arg1?: string) => void;
@@ -12342,6 +12336,7 @@ namespace ts {
             ignoreReturnTypes: boolean,
             reportErrors: boolean,
             errorReporter: ErrorReporter | undefined,
+            incompatibleErrorReporter: ((source: Type, target: Type) => void) | undefined,
             compareTypes: TypeComparer): Ternary {
             // TODO (drosen): De-duplicate code between related functions.
             if (source === target) {
@@ -12408,11 +12403,11 @@ namespace ts {
                 // with respect to T.
                 const sourceSig = callbackCheck ? undefined : getSingleCallSignature(getNonNullableType(sourceType));
                 const targetSig = callbackCheck ? undefined : getSingleCallSignature(getNonNullableType(targetType));
-                const callbacks = sourceSig && targetSig && !signatureHasTypePredicate(sourceSig) && !signatureHasTypePredicate(targetSig) &&
+                const callbacks = sourceSig && targetSig && !getTypePredicateOfSignature(sourceSig) && !getTypePredicateOfSignature(targetSig) &&
                     (getFalsyFlags(sourceType) & TypeFlags.Nullable) === (getFalsyFlags(targetType) & TypeFlags.Nullable);
                 const related = callbacks ?
                     // TODO: GH#18217 It will work if they're both `undefined`, but not if only one is
-                    compareSignaturesRelated(targetSig!, sourceSig!, strictVariance ? CallbackCheck.Strict : CallbackCheck.Bivariant, /*ignoreReturnTypes*/ false, reportErrors, errorReporter, compareTypes) :
+                    compareSignaturesRelated(targetSig!, sourceSig!, strictVariance ? CallbackCheck.Strict : CallbackCheck.Bivariant, /*ignoreReturnTypes*/ false, reportErrors, errorReporter, incompatibleErrorReporter, compareTypes) :
                     !callbackCheck && !strictVariance && compareTypes(sourceType, targetType, /*reportErrors*/ false) || compareTypes(targetType, sourceType, reportErrors);
                 if (!related) {
                     if (reportErrors) {
@@ -12458,6 +12453,9 @@ namespace ts {
                     // wouldn't be co-variant for T without this rule.
                     result &= callbackCheck === CallbackCheck.Bivariant && compareTypes(targetReturnType, sourceReturnType, /*reportErrors*/ false) ||
                         compareTypes(sourceReturnType, targetReturnType, reportErrors);
+                    if (!result && reportErrors && incompatibleErrorReporter) {
+                        incompatibleErrorReporter(sourceReturnType, targetReturnType);
+                    }
                 }
 
             }
@@ -12479,7 +12477,7 @@ namespace ts {
                 return Ternary.False;
             }
 
-            if (source.kind === TypePredicateKind.Identifier) {
+            if (source.kind === TypePredicateKind.Identifier || source.kind === TypePredicateKind.AssertsIdentifier) {
                 if (source.parameterIndex !== (target as IdentifierTypePredicate).parameterIndex) {
                     if (reportErrors) {
                         errorReporter!(Diagnostics.Parameter_0_is_not_in_the_same_position_as_parameter_1, source.parameterName, (target as IdentifierTypePredicate).parameterName);
@@ -12489,7 +12487,9 @@ namespace ts {
                 }
             }
 
-            const related = compareTypes(source.type, target.type, reportErrors);
+            const related = source.type === target.type ? Ternary.True :
+                source.type && target.type ? compareTypes(source.type, target.type, reportErrors) :
+                Ternary.False;
             if (related === Ternary.False && reportErrors) {
                 errorReporter!(Diagnostics.Type_predicate_0_is_not_assignable_to_1, typePredicateToString(source), typePredicateToString(target));
             }
@@ -12544,12 +12544,12 @@ namespace ts {
                 return true;
             }
             const id = getSymbolId(sourceSymbol) + "," + getSymbolId(targetSymbol);
-            const relation = enumRelation.get(id);
-            if (relation !== undefined && !(relation === RelationComparisonResult.Failed && errorReporter)) {
-                return relation === RelationComparisonResult.Succeeded;
+            const entry = enumRelation.get(id);
+            if (entry !== undefined && !(!(entry & RelationComparisonResult.Reported) && entry & RelationComparisonResult.Failed && errorReporter)) {
+                return !!(entry & RelationComparisonResult.Succeeded);
             }
             if (sourceSymbol.escapedName !== targetSymbol.escapedName || !(sourceSymbol.flags & SymbolFlags.RegularEnum) || !(targetSymbol.flags & SymbolFlags.RegularEnum)) {
-                enumRelation.set(id, RelationComparisonResult.FailedAndReported);
+                enumRelation.set(id, RelationComparisonResult.Failed | RelationComparisonResult.Reported);
                 return false;
             }
             const targetEnumType = getTypeOfSymbol(targetSymbol);
@@ -12560,7 +12560,7 @@ namespace ts {
                         if (errorReporter) {
                             errorReporter(Diagnostics.Property_0_is_missing_in_type_1, symbolName(property),
                                 typeToString(getDeclaredTypeOfSymbol(targetSymbol), /*enclosingDeclaration*/ undefined, TypeFormatFlags.UseFullyQualifiedType));
-                            enumRelation.set(id, RelationComparisonResult.FailedAndReported);
+                            enumRelation.set(id, RelationComparisonResult.Failed | RelationComparisonResult.Reported);
                         }
                         else {
                             enumRelation.set(id, RelationComparisonResult.Failed);
@@ -12625,7 +12625,7 @@ namespace ts {
             if (source.flags & TypeFlags.Object && target.flags & TypeFlags.Object) {
                 const related = relation.get(getRelationKey(source, target, relation));
                 if (related !== undefined) {
-                    return related === RelationComparisonResult.Succeeded;
+                    return !!(related & RelationComparisonResult.Succeeded);
                 }
             }
             if (source.flags & TypeFlags.StructuredOrInstantiable || target.flags & TypeFlags.StructuredOrInstantiable) {
@@ -12667,11 +12667,16 @@ namespace ts {
             let depth = 0;
             let expandingFlags = ExpandingFlags.None;
             let overflow = false;
-            let overrideNextErrorInfo: DiagnosticMessageChain | undefined;
+            let overrideNextErrorInfo = 0; // How many `reportRelationError` calls should be skipped in the elaboration pyramid
+            let lastSkippedInfo: [Type, Type] | undefined;
+            let incompatibleStack: [DiagnosticMessage, (string | number)?, (string | number)?, (string | number)?, (string | number)?][] = [];
 
             Debug.assert(relation !== identityRelation || !errorNode, "no error reporting in identity checking");
 
             const result = isRelatedTo(source, target, /*reportErrors*/ !!errorNode, headMessage);
+            if (incompatibleStack.length) {
+                reportIncompatibleStack();
+            }
             if (overflow) {
                 const diag = error(errorNode, Diagnostics.Excessive_stack_depth_comparing_types_0_and_1, typeToString(source), typeToString(target));
                 if (errorOutputContainer) {
@@ -12716,8 +12721,134 @@ namespace ts {
             }
             return result !== Ternary.False;
 
+            function resetErrorInfo(saved: ReturnType<typeof captureErrorCalculationState>) {
+                errorInfo = saved.errorInfo;
+                lastSkippedInfo = saved.lastSkippedInfo;
+                incompatibleStack = saved.incompatibleStack;
+                overrideNextErrorInfo = saved.overrideNextErrorInfo;
+                relatedInfo = saved.relatedInfo;
+            }
+
+            function captureErrorCalculationState() {
+                return {
+                    errorInfo,
+                    lastSkippedInfo,
+                    incompatibleStack: incompatibleStack.slice(),
+                    overrideNextErrorInfo,
+                    relatedInfo: !relatedInfo ? undefined : relatedInfo.slice() as ([DiagnosticRelatedInformation, ...DiagnosticRelatedInformation[]] | undefined)
+                };
+            }
+
+            function reportIncompatibleError(message: DiagnosticMessage, arg0?: string | number, arg1?: string | number, arg2?: string | number, arg3?: string | number) {
+                overrideNextErrorInfo++; // Suppress the next relation error
+                lastSkippedInfo = undefined; // Reset skipped info cache
+                incompatibleStack.push([message, arg0, arg1, arg2, arg3]);
+            }
+
+            function reportIncompatibleStack() {
+                const stack = incompatibleStack;
+                incompatibleStack = [];
+                const info = lastSkippedInfo;
+                lastSkippedInfo = undefined;
+                if (stack.length === 1) {
+                    reportError(...stack[0]);
+                    if (info) {
+                        // Actually do the last relation error
+                        reportRelationError(/*headMessage*/ undefined, ...info);
+                    }
+                    return;
+                }
+                // The first error will be the innermost, while the last will be the outermost - so by popping off the end,
+                // we can build from left to right
+                let path = "";
+                const secondaryRootErrors: typeof incompatibleStack = [];
+                while (stack.length) {
+                    const [msg, ...args] = stack.pop()!;
+                    switch (msg.code) {
+                        case Diagnostics.Types_of_property_0_are_incompatible.code: {
+                            // Parenthesize a `new` if there is one
+                            if (path.indexOf("new ") === 0) {
+                                path = `(${path})`;
+                            }
+                            const str = "" + args[0];
+                            // If leading, just print back the arg (irrespective of if it's a valid identifier)
+                            if (path.length === 0) {
+                                path = `${str}`;
+                            }
+                            // Otherwise write a dotted name if possible
+                            else if (isIdentifierText(str, compilerOptions.target)) {
+                                path = `${path}.${str}`;
+                            }
+                            // Failing that, check if the name is already a computed name
+                            else if (str[0] === "[" && str[str.length - 1] === "]") {
+                                path = `${path}${str}`;
+                            }
+                            // And finally write out a computed name as a last resort
+                            else {
+                                path = `${path}[${str}]`;
+                            }
+                            break;
+                        }
+                        case Diagnostics.Call_signature_return_types_0_and_1_are_incompatible.code:
+                        case Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible.code:
+                        case Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code:
+                        case Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code: {
+                            if (path.length === 0) {
+                                // Don't flatten signature compatability errors at the start of a chain - instead prefer
+                                // to unify (the with no arguments bit is excessive for printback) and print them back
+                                let mappedMsg = msg;
+                                if (msg.code === Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code) {
+                                    mappedMsg = Diagnostics.Call_signature_return_types_0_and_1_are_incompatible;
+                                }
+                                else if (msg.code === Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code) {
+                                    mappedMsg = Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible;
+                                }
+                                secondaryRootErrors.unshift([mappedMsg, args[0], args[1]]);
+                            }
+                            else {
+                                const prefix = (msg.code === Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible.code ||
+                                    msg.code === Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code)
+                                        ? "new "
+                                        : "";
+                                const params = (msg.code === Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code ||
+                                    msg.code === Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code)
+                                        ? ""
+                                        : "...";
+                                path = `${prefix}${path}(${params})`;
+                            }
+                            break;
+                        }
+                        default:
+                            return Debug.fail(`Unhandled Diagnostic: ${msg.code}`);
+                    }
+                }
+                if (path) {
+                    reportError(path[path.length - 1] === ")"
+                        ? Diagnostics.The_types_returned_by_0_are_incompatible_between_these_types
+                        : Diagnostics.The_types_of_0_are_incompatible_between_these_types,
+                        path
+                    );
+                }
+                else {
+                    // Remove the innermost secondary error as it will duplicate the error already reported by `reportRelationError` on entry
+                    secondaryRootErrors.shift();
+                }
+                for (const [msg, ...args] of secondaryRootErrors) {
+                    const originalValue = msg.elidedInCompatabilityPyramid;
+                    msg.elidedInCompatabilityPyramid = false; // Teporarily override elision to ensure error is reported
+                    reportError(msg, ...args);
+                    msg.elidedInCompatabilityPyramid = originalValue;
+                }
+                if (info) {
+                    // Actually do the last relation error
+                    reportRelationError(/*headMessage*/ undefined, ...info);
+                }
+            }
+
             function reportError(message: DiagnosticMessage, arg0?: string | number, arg1?: string | number, arg2?: string | number, arg3?: string | number): void {
                 Debug.assert(!!errorNode);
+                if (incompatibleStack.length) reportIncompatibleStack();
+                if (message.elidedInCompatabilityPyramid) return;
                 errorInfo = chainDiagnosticMessages(errorInfo, message, arg0, arg1, arg2, arg3);
             }
 
@@ -12732,6 +12863,7 @@ namespace ts {
             }
 
             function reportRelationError(message: DiagnosticMessage | undefined, source: Type, target: Type) {
+                if (incompatibleStack.length) reportIncompatibleStack();
                 const [sourceType, targetType] = getTypeNamesForErrorDisplay(source, target);
 
                 if (target.flags & TypeFlags.TypeParameter && target.immediateBaseConstraint !== undefined && isTypeAssignableTo(source, target.immediateBaseConstraint)) {
@@ -12889,7 +13021,7 @@ namespace ts {
                 }
 
                 let result = Ternary.False;
-                const saveErrorInfo = errorInfo;
+                const saveErrorInfo = captureErrorCalculationState();
                 let isIntersectionConstituent = !!isApparentIntersectionConstituent;
 
                 // Note that these checks are specifically ordered to produce correct results. In particular,
@@ -12939,11 +13071,11 @@ namespace ts {
                     }
                     if (!result && (source.flags & TypeFlags.StructuredOrInstantiable || target.flags & TypeFlags.StructuredOrInstantiable)) {
                         if (result = recursiveTypeRelatedTo(source, target, reportErrors, isIntersectionConstituent)) {
-                            errorInfo = saveErrorInfo;
+                            resetErrorInfo(saveErrorInfo);
                         }
                     }
                 }
-                if (!result && source.flags & TypeFlags.Intersection) {
+                if (!result && source.flags & (TypeFlags.Intersection | TypeFlags.TypeParameter)) {
                     // The combined constraint of an intersection type is the intersection of the constraints of
                     // the constituents. When an intersection type contains instantiable types with union type
                     // constraints, there are situations where we need to examine the combined constraint. One is
@@ -12953,22 +13085,31 @@ namespace ts {
                     // we need to check this constraint against a union on the target side. Also, given a type
                     // variable V constrained to 'string | number', 'V & number' has a combined constraint of
                     // 'string & number | number & number' which reduces to just 'number'.
-                    const constraint = getUnionConstraintOfIntersection(<IntersectionType>source, !!(target.flags & TypeFlags.Union));
-                    if (constraint) {
-                        if (result = isRelatedTo(constraint, target, reportErrors, /*headMessage*/ undefined, isIntersectionConstituent)) {
-                            errorInfo = saveErrorInfo;
+                    // This also handles type parameters, as a type parameter with a union constraint compared against a union
+                    // needs to have its constraint hoisted into an intersection with said type parameter, this way
+                    // the type param can be compared with itself in the target (with the influence of its constraint to match other parts)
+                    // For example, if `T extends 1 | 2` and `U extends 2 | 3` and we compare `T & U` to `T & U & (1 | 2 | 3)`
+                    const constraint = getEffectiveConstraintOfIntersection(source.flags & TypeFlags.Intersection ? (<IntersectionType>source).types: [source], !!(target.flags & TypeFlags.Union));
+                    if (constraint && (source.flags & TypeFlags.Intersection || target.flags & TypeFlags.Union)) {
+                        if (everyType(constraint, c => c !== source)) { // Skip comparison if expansion contains the source itself
+                            // TODO: Stack errors so we get a pyramid for the "normal" comparison above, _and_ a second for this
+                            if (result = isRelatedTo(constraint, target, /*reportErrors*/ false, /*headMessage*/ undefined, isIntersectionConstituent)) {
+                                resetErrorInfo(saveErrorInfo);
+                            }
                         }
                     }
                 }
 
                 if (!result && reportErrors) {
-                    let maybeSuppress = overrideNextErrorInfo;
-                    overrideNextErrorInfo = undefined;
+                    let maybeSuppress = overrideNextErrorInfo > 0;
+                    if (maybeSuppress) {
+                        overrideNextErrorInfo--;
+                    }
                     if (source.flags & TypeFlags.Object && target.flags & TypeFlags.Object) {
                         const currentError = errorInfo;
                         tryElaborateArrayLikeErrors(source, target, reportErrors);
                         if (errorInfo !== currentError) {
-                            maybeSuppress = errorInfo;
+                            maybeSuppress = !!errorInfo;
                         }
                     }
                     if (source.flags & TypeFlags.Object && target.flags & TypeFlags.Primitive) {
@@ -12988,6 +13129,7 @@ namespace ts {
                         }
                     }
                     if (!headMessage && maybeSuppress) {
+                        lastSkippedInfo = [source, target];
                         // Used by, eg, missing property checking to replace the top-level message with a more informative one
                         return result;
                     }
@@ -13040,6 +13182,11 @@ namespace ts {
                                     // JsxAttributes has an object-literal flag and undergo same type-assignablity check as normal object-literal.
                                     // However, using an object-literal error message will be very confusing to the users so we give different a message.
                                     // TODO: Spelling suggestions for excess jsx attributes (needs new diagnostic messages)
+                                    if (prop.valueDeclaration && isJsxAttribute(prop.valueDeclaration)) {
+                                        // Note that extraneous children (as in `<NoChild>extra</NoChild>`) don't pass this check,
+                                        // since `children` is a SyntaxKind.PropertySignature instead of a SyntaxKind.JsxAttribute.
+                                        errorNode = prop.valueDeclaration.name;
+                                    }
                                     reportError(Diagnostics.Property_0_does_not_exist_on_type_1, symbolToString(prop), typeToString(errorTarget));
                                 }
                                 else {
@@ -13299,18 +13446,6 @@ namespace ts {
                 return result;
             }
 
-            function propagateSidebandVarianceFlags(typeArguments: readonly Type[], variances: VarianceFlags[]) {
-                for (let i = 0; i < variances.length; i++) {
-                    const v = variances[i];
-                    if (v & VarianceFlags.Unmeasurable) {
-                        instantiateType(typeArguments[i], reportUnmeasurableMarkers);
-                    }
-                    if (v & VarianceFlags.Unreliable) {
-                        instantiateType(typeArguments[i], reportUnreliableMarkers);
-                    }
-                }
-            }
-
             // Determine if possibly recursive types are related. First, check if the result is already available in the global cache.
             // Second, check if we have already started a comparison of the given two types in which case we assume the result to be true.
             // Third, check if both types are part of deeply nested chains of generic type instantiations and if so assume the types are
@@ -13321,24 +13456,24 @@ namespace ts {
                     return Ternary.False;
                 }
                 const id = getRelationKey(source, target, relation);
-                const related = relation.get(id);
-                if (related !== undefined) {
-                    if (reportErrors && related === RelationComparisonResult.Failed) {
+                const entry = relation.get(id);
+                if (entry !== undefined) {
+                    if (reportErrors && entry & RelationComparisonResult.Failed && !(entry & RelationComparisonResult.Reported)) {
                         // We are elaborating errors and the cached result is an unreported failure. The result will be reported
                         // as a failure, and should be updated as a reported failure by the bottom of this function.
                     }
                     else {
                         if (outofbandVarianceMarkerHandler) {
                             // We're in the middle of variance checking - integrate any unmeasurable/unreliable flags from this cached component
-                            if (source.flags & (TypeFlags.Object | TypeFlags.Conditional) && source.aliasSymbol &&
-                            source.aliasTypeArguments && source.aliasSymbol === target.aliasSymbol) {
-                                propagateSidebandVarianceFlags(source.aliasTypeArguments, getAliasVariances(source.aliasSymbol));
+                            const saved = entry & RelationComparisonResult.ReportsMask;
+                            if (saved & RelationComparisonResult.ReportsUnmeasurable) {
+                                instantiateType(source, reportUnmeasurableMarkers);
                             }
-                            if (getObjectFlags(source) & ObjectFlags.Reference && getObjectFlags(target) & ObjectFlags.Reference && (<TypeReference>source).target === (<TypeReference>target).target && length((<TypeReference>source).typeArguments)) {
-                                propagateSidebandVarianceFlags((<TypeReference>source).typeArguments!, getVariances((<TypeReference>source).target));
+                            if (saved & RelationComparisonResult.ReportsUnreliable) {
+                                instantiateType(source, reportUnreliableMarkers);
                             }
                         }
-                        return related === RelationComparisonResult.Succeeded ? Ternary.True : Ternary.False;
+                        return entry & RelationComparisonResult.Succeeded ? Ternary.True : Ternary.False;
                     }
                 }
                 if (!maybeKeys) {
@@ -13367,14 +13502,26 @@ namespace ts {
                 const saveExpandingFlags = expandingFlags;
                 if (!(expandingFlags & ExpandingFlags.Source) && isDeeplyNestedType(source, sourceStack, depth)) expandingFlags |= ExpandingFlags.Source;
                 if (!(expandingFlags & ExpandingFlags.Target) && isDeeplyNestedType(target, targetStack, depth)) expandingFlags |= ExpandingFlags.Target;
+                let originalHandler: typeof outofbandVarianceMarkerHandler;
+                let propagatingVarianceFlags: RelationComparisonResult = 0;
+                if (outofbandVarianceMarkerHandler) {
+                    originalHandler = outofbandVarianceMarkerHandler;
+                    outofbandVarianceMarkerHandler = onlyUnreliable => {
+                        propagatingVarianceFlags |= onlyUnreliable ? RelationComparisonResult.ReportsUnreliable : RelationComparisonResult.ReportsUnmeasurable;
+                        return originalHandler!(onlyUnreliable);
+                    };
+                }
                 const result = expandingFlags !== ExpandingFlags.Both ? structuredTypeRelatedTo(source, target, reportErrors, isIntersectionConstituent) : Ternary.Maybe;
+                if (outofbandVarianceMarkerHandler) {
+                    outofbandVarianceMarkerHandler = originalHandler;
+                }
                 expandingFlags = saveExpandingFlags;
                 depth--;
                 if (result) {
                     if (result === Ternary.True || depth === 0) {
                         // If result is definitely true, record all maybe keys as having succeeded
                         for (let i = maybeStart; i < maybeCount; i++) {
-                            relation.set(maybeKeys[i], RelationComparisonResult.Succeeded);
+                            relation.set(maybeKeys[i], RelationComparisonResult.Succeeded | propagatingVarianceFlags);
                         }
                         maybeCount = maybeStart;
                     }
@@ -13382,7 +13529,7 @@ namespace ts {
                 else {
                     // A false result goes straight into global cache (when something is false under
                     // assumptions it will also be false without assumptions)
-                    relation.set(id, reportErrors ? RelationComparisonResult.FailedAndReported : RelationComparisonResult.Failed);
+                    relation.set(id, (reportErrors ? RelationComparisonResult.Reported : 0) | RelationComparisonResult.Failed | propagatingVarianceFlags);
                     maybeCount = maybeStart;
                 }
                 return result;
@@ -13424,7 +13571,7 @@ namespace ts {
                 let result: Ternary;
                 let originalErrorInfo: DiagnosticMessageChain | undefined;
                 let varianceCheckFailed = false;
-                const saveErrorInfo = errorInfo;
+                const saveErrorInfo = captureErrorCalculationState();
 
                 // We limit alias variance probing to only object and conditional types since their alias behavior
                 // is more predictable than other, interned types, which may or may not have an alias depending on
@@ -13516,7 +13663,7 @@ namespace ts {
                                 }
                             }
                             originalErrorInfo = errorInfo;
-                            errorInfo = saveErrorInfo;
+                            resetErrorInfo(saveErrorInfo);
                         }
                     }
                 }
@@ -13528,7 +13675,7 @@ namespace ts {
                             result &= isRelatedTo((<IndexedAccessType>source).indexType, (<IndexedAccessType>target).indexType, reportErrors);
                         }
                         if (result) {
-                            errorInfo = saveErrorInfo;
+                            resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                     }
@@ -13537,25 +13684,25 @@ namespace ts {
                         if (!constraint || (source.flags & TypeFlags.TypeParameter && constraint.flags & TypeFlags.Any)) {
                             // A type variable with no constraint is not related to the non-primitive object type.
                             if (result = isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~TypeFlags.NonPrimitive))) {
-                                errorInfo = saveErrorInfo;
+                                resetErrorInfo(saveErrorInfo);
                                 return result;
                             }
                         }
                         // hi-speed no-this-instantiation check (less accurate, but avoids costly `this`-instantiation when the constraint will suffice), see #28231 for report on why this is needed
                         else if (result = isRelatedTo(constraint, target, /*reportErrors*/ false, /*headMessage*/ undefined, isIntersectionConstituent)) {
-                            errorInfo = saveErrorInfo;
+                            resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                         // slower, fuller, this-instantiated check (necessary when comparing raw `this` types from base classes), see `subclassWithPolymorphicThisIsAssignable.ts` test for example
                         else if (result = isRelatedTo(getTypeWithThisArgument(constraint, source), target, reportErrors, /*headMessage*/ undefined, isIntersectionConstituent)) {
-                            errorInfo = saveErrorInfo;
+                            resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                     }
                 }
                 else if (source.flags & TypeFlags.Index) {
                     if (result = isRelatedTo(keyofConstraintType, target, reportErrors)) {
-                        errorInfo = saveErrorInfo;
+                        resetErrorInfo(saveErrorInfo);
                         return result;
                     }
                 }
@@ -13580,7 +13727,7 @@ namespace ts {
                                 result &= isRelatedTo(getFalseTypeFromConditionalType(<ConditionalType>source), getFalseTypeFromConditionalType(<ConditionalType>target), reportErrors);
                             }
                             if (result) {
-                                errorInfo = saveErrorInfo;
+                                resetErrorInfo(saveErrorInfo);
                                 return result;
                             }
                         }
@@ -13589,14 +13736,14 @@ namespace ts {
                         const distributiveConstraint = getConstraintOfDistributiveConditionalType(<ConditionalType>source);
                         if (distributiveConstraint) {
                             if (result = isRelatedTo(distributiveConstraint, target, reportErrors)) {
-                                errorInfo = saveErrorInfo;
+                                resetErrorInfo(saveErrorInfo);
                                 return result;
                             }
                         }
                         const defaultConstraint = getDefaultConstraintOfConditionalType(<ConditionalType>source);
                         if (defaultConstraint) {
                             if (result = isRelatedTo(defaultConstraint, target, reportErrors)) {
-                                errorInfo = saveErrorInfo;
+                                resetErrorInfo(saveErrorInfo);
                                 return result;
                             }
                         }
@@ -13610,7 +13757,7 @@ namespace ts {
                     if (isGenericMappedType(target)) {
                         if (isGenericMappedType(source)) {
                             if (result = mappedTypeRelatedTo(source, target, reportErrors)) {
-                                errorInfo = saveErrorInfo;
+                                resetErrorInfo(saveErrorInfo);
                                 return result;
                             }
                         }
@@ -13656,7 +13803,7 @@ namespace ts {
                     // relates to X. Thus, we include intersection types on the source side here.
                     if (source.flags & (TypeFlags.Object | TypeFlags.Intersection) && target.flags & TypeFlags.Object) {
                         // Report structural errors only if we haven't reported any errors yet
-                        const reportStructuralErrors = reportErrors && errorInfo === saveErrorInfo && !sourceIsPrimitive;
+                        const reportStructuralErrors = reportErrors && errorInfo === saveErrorInfo.errorInfo && !sourceIsPrimitive;
                         result = propertiesRelatedTo(source, target, reportStructuralErrors, /*excludedProperties*/ undefined, isIntersectionConstituent);
                         if (result) {
                             result &= signaturesRelatedTo(source, target, SignatureKind.Call, reportStructuralErrors);
@@ -13671,7 +13818,7 @@ namespace ts {
                             }
                         }
                         if (varianceCheckFailed && result) {
-                            errorInfo = originalErrorInfo || errorInfo || saveErrorInfo; // Use variance error (there is no structural one) and return false
+                            errorInfo = originalErrorInfo || errorInfo || saveErrorInfo.errorInfo; // Use variance error (there is no structural one) and return false
                         }
                         else if (result) {
                             return result;
@@ -13703,7 +13850,7 @@ namespace ts {
                         // We elide the variance-based error elaborations, since those might not be too helpful, since we'll potentially
                         // be assuming identity of the type parameter.
                         originalErrorInfo = undefined;
-                        errorInfo = saveErrorInfo;
+                        resetErrorInfo(saveErrorInfo);
                         return undefined;
                     }
                     const allowStructuralFallback = targetTypeArguments && hasCovariantVoidArgument(targetTypeArguments, variances);
@@ -13731,7 +13878,7 @@ namespace ts {
                         // comparison unexpectedly succeeds. This can happen when the structural comparison result
                         // is a Ternary.Maybe for example caused by the recursion depth limiter.
                         originalErrorInfo = errorInfo;
-                        errorInfo = saveErrorInfo;
+                        resetErrorInfo(saveErrorInfo);
                     }
                 }
             }
@@ -13965,7 +14112,7 @@ namespace ts {
                 const related = isPropertySymbolTypeRelated(sourceProp, targetProp, getTypeOfSourceProperty, reportErrors, isIntersectionConstituent);
                 if (!related) {
                     if (reportErrors) {
-                        reportError(Diagnostics.Types_of_property_0_are_incompatible, symbolToString(targetProp));
+                        reportIncompatibleError(Diagnostics.Types_of_property_0_are_incompatible, symbolToString(targetProp));
                     }
                     return Ternary.False;
                 }
@@ -14007,8 +14154,8 @@ namespace ts {
                             if (length(unmatchedProperty.declarations)) {
                                 associateRelatedInfo(createDiagnosticForNode(unmatchedProperty.declarations[0], Diagnostics._0_is_declared_here, propName));
                             }
-                            if (shouldSkipElaboration) {
-                                overrideNextErrorInfo = errorInfo;
+                            if (shouldSkipElaboration && errorInfo) {
+                                overrideNextErrorInfo++;
                             }
                         }
                         else if (tryElaborateArrayLikeErrors(source, target, /*reportErrors*/ false)) {
@@ -14018,8 +14165,8 @@ namespace ts {
                             else {
                                 reportError(Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2, typeToString(source), typeToString(target), map(props, p => symbolToString(p)).join(", "));
                             }
-                            if (shouldSkipElaboration) {
-                                overrideNextErrorInfo = errorInfo;
+                            if (shouldSkipElaboration && errorInfo) {
+                                overrideNextErrorInfo++;
                             }
                         }
                         // ELSE: No array like or unmatched property error - just issue top level error (errorInfo = undefined)
@@ -14142,7 +14289,8 @@ namespace ts {
                 }
 
                 let result = Ternary.True;
-                const saveErrorInfo = errorInfo;
+                const saveErrorInfo = captureErrorCalculationState();
+                const incompatibleReporter = kind === SignatureKind.Construct ? reportIncompatibleConstructSignatureReturn : reportIncompatibleCallSignatureReturn;
 
                 if (getObjectFlags(source) & ObjectFlags.Instantiated && getObjectFlags(target) & ObjectFlags.Instantiated && source.symbol === target.symbol) {
                     // We have instantiations of the same anonymous type (which typically will be the type of a
@@ -14150,7 +14298,7 @@ namespace ts {
                     // of the much more expensive N * M comparison matrix we explore below. We erase type parameters
                     // as they are known to always be the same.
                     for (let i = 0; i < targetSignatures.length; i++) {
-                        const related = signatureRelatedTo(sourceSignatures[i], targetSignatures[i], /*erase*/ true, reportErrors);
+                        const related = signatureRelatedTo(sourceSignatures[i], targetSignatures[i], /*erase*/ true, reportErrors, incompatibleReporter(sourceSignatures[i], targetSignatures[i]));
                         if (!related) {
                             return Ternary.False;
                         }
@@ -14164,17 +14312,17 @@ namespace ts {
                     // this regardless of the number of signatures, but the potential costs are prohibitive due
                     // to the quadratic nature of the logic below.
                     const eraseGenerics = relation === comparableRelation || !!compilerOptions.noStrictGenericChecks;
-                    result = signatureRelatedTo(sourceSignatures[0], targetSignatures[0], eraseGenerics, reportErrors);
+                    result = signatureRelatedTo(sourceSignatures[0], targetSignatures[0], eraseGenerics, reportErrors, incompatibleReporter(sourceSignatures[0], targetSignatures[0]));
                 }
                 else {
                     outer: for (const t of targetSignatures) {
                         // Only elaborate errors from the first failure
                         let shouldElaborateErrors = reportErrors;
                         for (const s of sourceSignatures) {
-                            const related = signatureRelatedTo(s, t, /*erase*/ true, shouldElaborateErrors);
+                            const related = signatureRelatedTo(s, t, /*erase*/ true, shouldElaborateErrors, incompatibleReporter(s, t));
                             if (related) {
                                 result &= related;
-                                errorInfo = saveErrorInfo;
+                                resetErrorInfo(saveErrorInfo);
                                 continue outer;
                             }
                             shouldElaborateErrors = false;
@@ -14191,12 +14339,26 @@ namespace ts {
                 return result;
             }
 
+            function reportIncompatibleCallSignatureReturn(siga: Signature, sigb: Signature) {
+                if (siga.parameters.length === 0 && sigb.parameters.length === 0) {
+                    return (source: Type, target: Type) => reportIncompatibleError(Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1, typeToString(source), typeToString(target));
+                }
+                return (source: Type, target: Type) => reportIncompatibleError(Diagnostics.Call_signature_return_types_0_and_1_are_incompatible, typeToString(source), typeToString(target));
+            }
+
+            function reportIncompatibleConstructSignatureReturn(siga: Signature, sigb: Signature) {
+                if (siga.parameters.length === 0 && sigb.parameters.length === 0) {
+                    return (source: Type, target: Type) => reportIncompatibleError(Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1, typeToString(source), typeToString(target));
+                }
+                return (source: Type, target: Type) => reportIncompatibleError(Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible, typeToString(source), typeToString(target));
+            }
+
             /**
              * See signatureAssignableTo, compareSignaturesIdentical
              */
-            function signatureRelatedTo(source: Signature, target: Signature, erase: boolean, reportErrors: boolean): Ternary {
+            function signatureRelatedTo(source: Signature, target: Signature, erase: boolean, reportErrors: boolean, incompatibleReporter: (source: Type, target: Type) => void): Ternary {
                 return compareSignaturesRelated(erase ? getErasedSignature(source) : source, erase ? getErasedSignature(target) : target,
-                    CallbackCheck.None, /*ignoreReturnTypes*/ false, reportErrors, reportError, isRelatedTo);
+                    CallbackCheck.None, /*ignoreReturnTypes*/ false, reportErrors, reportError, incompatibleReporter, isRelatedTo);
             }
 
             function signaturesIdenticalTo(source: Type, target: Type, kind: SignatureKind): Ternary {
@@ -14714,16 +14876,18 @@ namespace ts {
             if (!ignoreReturnTypes) {
                 const sourceTypePredicate = getTypePredicateOfSignature(source);
                 const targetTypePredicate = getTypePredicateOfSignature(target);
-                result &= sourceTypePredicate !== undefined || targetTypePredicate !== undefined
-                    ? compareTypePredicatesIdentical(sourceTypePredicate, targetTypePredicate, compareTypes)
-                    // If they're both type predicates their return types will both be `boolean`, so no need to compare those.
-                    : compareTypes(getReturnTypeOfSignature(source), getReturnTypeOfSignature(target));
+                result &= sourceTypePredicate || targetTypePredicate ?
+                    compareTypePredicatesIdentical(sourceTypePredicate, targetTypePredicate, compareTypes) :
+                    compareTypes(getReturnTypeOfSignature(source), getReturnTypeOfSignature(target));
             }
             return result;
         }
 
         function compareTypePredicatesIdentical(source: TypePredicate | undefined, target: TypePredicate | undefined, compareTypes: (s: Type, t: Type) => Ternary): Ternary {
-            return source === undefined || target === undefined || !typePredicateKindsMatch(source, target) ? Ternary.False : compareTypes(source.type, target.type);
+            return !(source && target && typePredicateKindsMatch(source, target)) ? Ternary.False :
+                source.type === target.type ? Ternary.True :
+                source.type && target.type ? compareTypes(source.type, target.type) :
+                Ternary.False;
         }
 
         function literalTypesWithSameBaseType(types: Type[]): boolean {
@@ -15331,8 +15495,7 @@ namespace ts {
         function applyToReturnTypes(source: Signature, target: Signature, callback: (s: Type, t: Type) => void) {
             const sourceTypePredicate = getTypePredicateOfSignature(source);
             const targetTypePredicate = getTypePredicateOfSignature(target);
-            if (sourceTypePredicate && targetTypePredicate && sourceTypePredicate.kind === targetTypePredicate.kind &&
-                (sourceTypePredicate.kind === TypePredicateKind.This || sourceTypePredicate.parameterIndex === (<IdentifierTypePredicate>targetTypePredicate).parameterIndex)) {
+            if (sourceTypePredicate && targetTypePredicate && typePredicateKindsMatch(sourceTypePredicate, targetTypePredicate) && sourceTypePredicate.type && targetTypePredicate.type) {
                 callback(sourceTypePredicate.type, targetTypePredicate.type);
             }
             else {
@@ -16948,23 +17111,64 @@ namespace ts {
             return isLengthPushOrUnshift || isElementAssignment;
         }
 
-        function maybeTypePredicateCall(node: CallExpression) {
-            const links = getNodeLinks(node);
-            if (links.maybeTypePredicate === undefined) {
-                links.maybeTypePredicate = getMaybeTypePredicate(node);
-            }
-            return links.maybeTypePredicate;
+        function isDeclarationWithExplicitTypeAnnotation(declaration: Declaration | undefined) {
+            return !!(declaration && (
+                declaration.kind === SyntaxKind.VariableDeclaration || declaration.kind === SyntaxKind.Parameter ||
+                declaration.kind === SyntaxKind.PropertyDeclaration || declaration.kind === SyntaxKind.PropertySignature) &&
+                getEffectiveTypeAnnotationNode(declaration as VariableDeclaration | ParameterDeclaration | PropertyDeclaration | PropertySignature));
         }
 
-        function getMaybeTypePredicate(node: CallExpression) {
-            if (node.expression.kind !== SyntaxKind.SuperKeyword) {
-                const funcType = checkNonNullExpression(node.expression);
-                if (funcType !== silentNeverType) {
-                    const apparentType = getApparentType(funcType);
-                    return apparentType !== errorType && some(getSignaturesOfType(apparentType, SignatureKind.Call), signatureHasTypePredicate);
+        function getExplicitTypeOfSymbol(symbol: Symbol) {
+            return symbol.flags & (SymbolFlags.Function | SymbolFlags.Method | SymbolFlags.Class | SymbolFlags.ValueModule) ||
+                symbol.flags & (SymbolFlags.Variable | SymbolFlags.Property) && isDeclarationWithExplicitTypeAnnotation(symbol.valueDeclaration) ?
+                getTypeOfSymbol(symbol) : undefined;
+        }
+
+        // We require the dotted function name in an assertion expression to be comprised of identifiers
+        // that reference function, method, class or value module symbols; or variable, property or
+        // parameter symbols with declarations that have explicit type annotations. Such references are
+        // resolvable with no possibility of triggering circularities in control flow analysis.
+        function getTypeOfDottedName(node: Expression): Type | undefined {
+            if (!(node.flags & NodeFlags.InWithStatement)) {
+                switch (node.kind) {
+                    case SyntaxKind.Identifier:
+                        const symbol = getResolvedSymbol(<Identifier>node);
+                        return getExplicitTypeOfSymbol(symbol.flags & SymbolFlags.Alias ? resolveAlias(symbol) : symbol);
+                    case SyntaxKind.ThisKeyword:
+                        return checkThisExpression(node);
+                    case SyntaxKind.PropertyAccessExpression:
+                        const type = getTypeOfDottedName((<PropertyAccessExpression>node).expression);
+                        const prop = type && getPropertyOfType(type, (<PropertyAccessExpression>node).name.escapedText);
+                        return prop && getExplicitTypeOfSymbol(prop);
+                    case SyntaxKind.ParenthesizedExpression:
+                        return getTypeOfDottedName((<ParenthesizedExpression>node).expression);
                 }
             }
-            return false;
+        }
+
+        function getEffectsSignature(node: CallExpression) {
+            const links = getNodeLinks(node);
+            let signature = links.effectsSignature;
+            if (signature === undefined) {
+                // A call expression parented by an expression statement is a potential assertion. Other call
+                // expressions are potential type predicate function calls. In order to avoid triggering
+                // circularities in control flow analysis, we use getTypeOfDottedName when resolving the call
+                // target expression of an assertion.
+                const funcType = node.parent.kind === SyntaxKind.ExpressionStatement ? getTypeOfDottedName(node.expression) :
+                    node.expression.kind !== SyntaxKind.SuperKeyword ? checkNonNullExpression(node.expression) :
+                    undefined;
+                const signatures = getSignaturesOfType(funcType && getApparentType(funcType) || unknownType, SignatureKind.Call);
+                const candidate = signatures.length === 1 && !signatures[0].typeParameters ? signatures[0] :
+                    some(signatures, hasTypePredicateOrNeverReturnType) ? getResolvedSignature(node) :
+                    undefined;
+                signature = links.effectsSignature = candidate && hasTypePredicateOrNeverReturnType(candidate) ? candidate : unknownSignature;
+            }
+            return signature === unknownSignature ? undefined : signature;
+        }
+
+        function hasTypePredicateOrNeverReturnType(signature: Signature) {
+            return !!(getTypePredicateOfSignature(signature) ||
+                signature.declaration && (getReturnTypeFromAnnotation(signature.declaration) || unknownType).flags & TypeFlags.Never);
         }
 
         function reportFlowControlError(node: Node) {
@@ -16974,6 +17178,71 @@ namespace ts {
             diagnostics.add(createFileDiagnostic(sourceFile, span.start, span.length, Diagnostics.The_containing_function_or_module_body_is_too_large_for_control_flow_analysis));
         }
 
+        function isReachableFlowNode(flow: FlowNode) {
+            const result = isReachableFlowNodeWorker(flow, /*skipCacheCheck*/ false);
+            lastFlowNode = flow;
+            lastFlowNodeReachable = result;
+            return result;
+        }
+
+        function isUnlockedReachableFlowNode(flow: FlowNode) {
+            return !(flow.flags & FlowFlags.PreFinally && (<PreFinallyFlow>flow).lock.locked) && isReachableFlowNodeWorker(flow, /*skipCacheCheck*/ false);
+        }
+
+        function isReachableFlowNodeWorker(flow: FlowNode, noCacheCheck: boolean): boolean {
+            while (true) {
+                if (flow === lastFlowNode) {
+                    return lastFlowNodeReachable;
+                }
+                const flags = flow.flags;
+                if (flags & FlowFlags.Shared) {
+                    if (!noCacheCheck) {
+                        const id = getFlowNodeId(flow);
+                        const reachable = flowNodeReachable[id];
+                        return reachable !== undefined ? reachable : (flowNodeReachable[id] = isReachableFlowNodeWorker(flow, /*skipCacheCheck*/ true));
+                    }
+                    noCacheCheck = false;
+                }
+                if (flags & (FlowFlags.Assignment | FlowFlags.Condition | FlowFlags.ArrayMutation | FlowFlags.PreFinally)) {
+                    flow = (<FlowAssignment | FlowCondition | FlowArrayMutation | PreFinallyFlow>flow).antecedent;
+                }
+                else if (flags & FlowFlags.Call) {
+                    const signature = getEffectsSignature((<FlowCall>flow).node);
+                    if (signature && getReturnTypeOfSignature(signature).flags & TypeFlags.Never) {
+                        return false;
+                    }
+                    flow = (<FlowCall>flow).antecedent;
+                }
+                else if (flags & FlowFlags.BranchLabel) {
+                    // A branching point is reachable if any branch is reachable.
+                    return some((<FlowLabel>flow).antecedents, isUnlockedReachableFlowNode);
+                }
+                else if (flags & FlowFlags.LoopLabel) {
+                    // A loop is reachable if the control flow path that leads to the top is reachable.
+                    flow = (<FlowLabel>flow).antecedents![0];
+                }
+                else if (flags & FlowFlags.SwitchClause) {
+                    // The control flow path representing an unmatched value in a switch statement with
+                    // no default clause is unreachable if the switch statement is exhaustive.
+                    if ((<FlowSwitchClause>flow).clauseStart === (<FlowSwitchClause>flow).clauseEnd && isExhaustiveSwitchStatement((<FlowSwitchClause>flow).switchStatement)) {
+                        return false;
+                    }
+                    flow = (<FlowSwitchClause>flow).antecedent;
+                }
+                else if (flags & FlowFlags.AfterFinally) {
+                    // Cache is unreliable once we start locking nodes
+                    lastFlowNode = undefined;
+                    (<AfterFinallyFlow>flow).locked = true;
+                    const result = isReachableFlowNodeWorker((<AfterFinallyFlow>flow).antecedent, /*skipCacheCheck*/ false);
+                    (<AfterFinallyFlow>flow).locked = false;
+                    return result;
+                }
+                else {
+                    return !(flags & FlowFlags.Unreachable);
+                }
+            }
+        }
+
         function getFlowTypeOfReference(reference: Node, declaredType: Type, initialType = declaredType, flowContainer?: Node, couldBeUninitialized?: boolean) {
             let key: string | undefined;
             let keySet = false;
@@ -16993,7 +17262,7 @@ namespace ts {
             // on empty arrays are possible without implicit any errors and new element types can be inferred without
             // type mismatch errors.
             const resultType = getObjectFlags(evolvedType) & ObjectFlags.EvolvingArray && isEvolvingArrayOperationTarget(reference) ? autoArrayType : finalizeEvolvingArrayType(evolvedType);
-            if (reference.parent && reference.parent.kind === SyntaxKind.NonNullExpression && getTypeWithFacts(resultType, TypeFacts.NEUndefinedOrNull).flags & TypeFlags.Never) {
+            if (resultType === unreachableNeverType|| reference.parent && reference.parent.kind === SyntaxKind.NonNullExpression && getTypeWithFacts(resultType, TypeFacts.NEUndefinedOrNull).flags & TypeFlags.Never) {
                 return declaredType;
             }
             return resultType;
@@ -17048,6 +17317,13 @@ namespace ts {
                             continue;
                         }
                     }
+                    else if (flags & FlowFlags.Call) {
+                        type = getTypeAtFlowCall(<FlowCall>flow);
+                        if (!type) {
+                            flow = (<FlowCall>flow).antecedent;
+                            continue;
+                        }
+                    }
                     else if (flags & FlowFlags.Condition) {
                         type = getTypeAtFlowCondition(<FlowCondition>flow);
                     }
@@ -17072,7 +17348,7 @@ namespace ts {
                     }
                     else if (flags & FlowFlags.Start) {
                         // Check if we should continue with the control flow of the containing function.
-                        const container = (<FlowStart>flow).container;
+                        const container = (<FlowStart>flow).node;
                         if (container && container !== flowContainer &&
                             reference.kind !== SyntaxKind.PropertyAccessExpression &&
                             reference.kind !== SyntaxKind.ElementAccessExpression &&
@@ -17125,6 +17401,9 @@ namespace ts {
                 // Assignments only narrow the computed type if the declared type is a union type. Thus, we
                 // only need to evaluate the assigned type if the declared type is a union type.
                 if (isMatchingReference(reference, node)) {
+                    if (!isReachableFlowNode(flow)) {
+                        return unreachableNeverType;
+                    }
                     if (getAssignmentTargetKind(node) === AssignmentKind.Compound) {
                         const flowType = getTypeAtFlowNode(flow.antecedent);
                         return createFlowType(getBaseTypeOfLiteralType(getTypeFromFlowType(flowType)), isIncomplete(flowType));
@@ -17146,6 +17425,9 @@ namespace ts {
                 // reference 'x.y.z', we may be at an assignment to 'x.y' or 'x'. In that case,
                 // return the declared type.
                 if (containsMatchingReference(reference, node)) {
+                    if (!isReachableFlowNode(flow)) {
+                        return unreachableNeverType;
+                    }
                     // A matching dotted name might also be an expando property on a function *expression*,
                     // in which case we continue control flow analysis back to the function's declaration
                     if (isVariableDeclaration(node) && (isInJSFile(node) || isVarConst(node))) {
@@ -17164,6 +17446,38 @@ namespace ts {
                 return undefined;
             }
 
+            function narrowTypeByAssertion(type: Type, expr: Expression): Type {
+                const node = skipParentheses(expr);
+                if (node.kind === SyntaxKind.BinaryExpression) {
+                    if ((<BinaryExpression>node).operatorToken.kind === SyntaxKind.AmpersandAmpersandToken) {
+                        return narrowTypeByAssertion(narrowTypeByAssertion(type, (<BinaryExpression>node).left), (<BinaryExpression>node).right);
+                    }
+                    if ((<BinaryExpression>node).operatorToken.kind === SyntaxKind.BarBarToken) {
+                        return getUnionType([narrowTypeByAssertion(type, (<BinaryExpression>node).left), narrowTypeByAssertion(type, (<BinaryExpression>node).right)]);
+                    }
+                }
+                return narrowType(type, node, /*assumeTrue*/ true);
+            }
+
+            function getTypeAtFlowCall(flow: FlowCall): FlowType | undefined {
+                const signature = getEffectsSignature(flow.node);
+                if (signature) {
+                    const predicate = getTypePredicateOfSignature(signature);
+                    if (predicate && (predicate.kind === TypePredicateKind.AssertsThis || predicate.kind === TypePredicateKind.AssertsIdentifier)) {
+                        const flowType = getTypeAtFlowNode(flow.antecedent);
+                        const type = getTypeFromFlowType(flowType);
+                        const narrowedType = predicate.type ? narrowTypeByTypePredicate(type, predicate, flow.node, /*assumeTrue*/ true) :
+                            predicate.kind === TypePredicateKind.AssertsIdentifier ? narrowTypeByAssertion(type, flow.node.arguments[predicate.parameterIndex]) :
+                            type;
+                        return narrowedType === type ? flowType : createFlowType(narrowedType, isIncomplete(flowType));
+                    }
+                    if (getReturnTypeOfSignature(signature).flags & TypeFlags.Never) {
+                        return unreachableNeverType;
+                    }
+                }
+                return undefined;
+            }
+
             function getTypeAtFlowArrayMutation(flow: FlowArrayMutation): FlowType | undefined {
                 if (declaredType === autoType || declaredType === autoArrayType) {
                     const node = flow.node;
@@ -17210,7 +17524,7 @@ namespace ts {
                 // *only* place a silent never type is ever generated.
                 const assumeTrue = (flow.flags & FlowFlags.TrueCondition) !== 0;
                 const nonEvolvingType = finalizeEvolvingArrayType(type);
-                const narrowedType = narrowType(nonEvolvingType, flow.expression, assumeTrue);
+                const narrowedType = narrowType(nonEvolvingType, flow.node, assumeTrue);
                 if (narrowedType === nonEvolvingType) {
                     return flowType;
                 }
@@ -17238,6 +17552,9 @@ namespace ts {
                 else if (containsMatchingReferenceDiscriminant(reference, expr)) {
                     type = declaredType;
                 }
+                else if (flow.clauseStart === flow.clauseEnd && isExhaustiveSwitchStatement(flow.switchStatement)) {
+                    return unreachableNeverType;
+                }
                 return createFlowType(type, isIncomplete(flowType));
             }
 
@@ -17754,24 +18071,25 @@ namespace ts {
                     getIntersectionType([type, candidate]);
             }
 
-            function narrowTypeByTypePredicate(type: Type, callExpression: CallExpression, assumeTrue: boolean): Type {
-                if (!hasMatchingArgument(callExpression, reference) || !maybeTypePredicateCall(callExpression)) {
-                    return type;
-                }
-                const signature = getResolvedSignature(callExpression);
-                const predicate = getTypePredicateOfSignature(signature);
-                if (!predicate) {
-                    return type;
+            function narrowTypeByCallExpression(type: Type, callExpression: CallExpression, assumeTrue: boolean): Type {
+                if (hasMatchingArgument(callExpression, reference)) {
+                    const signature = getEffectsSignature(callExpression);
+                    const predicate = signature && getTypePredicateOfSignature(signature);
+                    if (predicate && (predicate.kind === TypePredicateKind.This || predicate.kind === TypePredicateKind.Identifier)) {
+                        return narrowTypeByTypePredicate(type, predicate, callExpression, assumeTrue);
+                    }
                 }
+                return type;
+            }
 
+            function narrowTypeByTypePredicate(type: Type, predicate: TypePredicate, callExpression: CallExpression, assumeTrue: boolean): Type {
                 // Don't narrow from 'any' if the predicate type is exactly 'Object' or 'Function'
                 if (isTypeAny(type) && (predicate.type === globalObjectType || predicate.type === globalFunctionType)) {
                     return type;
                 }
-
-                if (isIdentifierTypePredicate(predicate)) {
+                if (predicate.kind === TypePredicateKind.Identifier || predicate.kind === TypePredicateKind.AssertsIdentifier) {
                     const predicateArgument = callExpression.arguments[predicate.parameterIndex];
-                    if (predicateArgument) {
+                    if (predicateArgument && predicate.type) {
                         if (isMatchingReference(reference, predicateArgument)) {
                             return getNarrowedType(type, predicate.type, assumeTrue, isTypeSubtypeOf);
                         }
@@ -17782,7 +18100,7 @@ namespace ts {
                 }
                 else {
                     const invokedExpression = skipParentheses(callExpression.expression);
-                    if (isAccessExpression(invokedExpression)) {
+                    if (isAccessExpression(invokedExpression) && predicate.type) {
                         const possibleReference = skipParentheses(invokedExpression.expression);
                         if (isMatchingReference(reference, possibleReference)) {
                             return getNarrowedType(type, predicate.type, assumeTrue, isTypeSubtypeOf);
@@ -17806,7 +18124,7 @@ namespace ts {
                     case SyntaxKind.ElementAccessExpression:
                         return narrowTypeByTruthiness(type, expr, assumeTrue);
                     case SyntaxKind.CallExpression:
-                        return narrowTypeByTypePredicate(type, <CallExpression>expr, assumeTrue);
+                        return narrowTypeByCallExpression(type, <CallExpression>expr, assumeTrue);
                     case SyntaxKind.ParenthesizedExpression:
                         return narrowType(type, (<ParenthesizedExpression>expr).expression, assumeTrue);
                     case SyntaxKind.BinaryExpression:
@@ -19236,7 +19554,7 @@ namespace ts {
                 getContextualTypeForObjectLiteralMethod(node, contextFlags) :
                 getContextualType(node, contextFlags);
             const instantiatedType = instantiateContextualType(contextualType, node, contextFlags);
-            if (instantiatedType) {
+            if (instantiatedType && !(contextFlags && contextFlags & ContextFlags.NoConstraints && instantiatedType.flags & TypeFlags.TypeVariable)) {
                 const apparentType = mapType(instantiatedType, getApparentType, /*noReductions*/ true);
                 if (apparentType.flags & TypeFlags.Union) {
                     if (isObjectLiteralExpression(node)) {
@@ -23692,9 +24010,11 @@ namespace ts {
         }
 
         function isExhaustiveSwitchStatement(node: SwitchStatement): boolean {
-            if (!node.possiblyExhaustive) {
-                return false;
-            }
+            const links = getNodeLinks(node);
+            return links.isExhaustive !== undefined ? links.isExhaustive : (links.isExhaustive = computeExhaustiveSwitchStatement(node));
+        }
+
+        function computeExhaustiveSwitchStatement(node: SwitchStatement): boolean {
             if (node.expression.kind === SyntaxKind.TypeOfExpression) {
                 const operandType = getTypeOfExpression((node.expression as TypeOfExpression).expression);
                 // This cast is safe because the switch is possibly exhaustive and does not contain a default case, so there can be no undefined.
@@ -23716,14 +24036,7 @@ namespace ts {
         }
 
         function functionHasImplicitReturn(func: FunctionLikeDeclaration) {
-            if (!(func.flags & NodeFlags.HasImplicitReturn)) {
-                return false;
-            }
-
-            if (some((<Block>func.body).statements, statement => statement.kind === SyntaxKind.SwitchStatement && isExhaustiveSwitchStatement(<SwitchStatement>statement))) {
-                return false;
-            }
-            return true;
+            return func.endFlowNode && isReachableFlowNode(func.endFlowNode);
         }
 
         /** NOTE: Return value of `[]` means a different thing than `undefined`. `[]` means func returns `void`, `undefined` means it returns `never`. */
@@ -25142,8 +25455,8 @@ namespace ts {
                 const constructSignature = getSingleSignature(type, SignatureKind.Construct, /*allowMembers*/ true);
                 const signature = callSignature || constructSignature;
                 if (signature && signature.typeParameters) {
-                    const contextualType = getApparentTypeOfContextualType(<Expression>node);
-                    if (contextualType && !isMixinConstructorType(contextualType)) {
+                    const contextualType = getApparentTypeOfContextualType(<Expression>node, ContextFlags.NoConstraints);
+                    if (contextualType) {
                         const contextualSignature = getSingleSignature(getNonNullableType(contextualType), callSignature ? SignatureKind.Call : SignatureKind.Construct, /*allowMembers*/ false);
                         if (contextualSignature && !contextualSignature.typeParameters) {
                             if (checkMode & CheckMode.SkipGenericFunctions) {
@@ -25549,7 +25862,7 @@ namespace ts {
             checkSourceElement(node.type);
 
             const { parameterName } = node;
-            if (isThisTypePredicate(typePredicate)) {
+            if (typePredicate.kind === TypePredicateKind.This || typePredicate.kind === TypePredicateKind.AssertsThis) {
                 getTypeFromThisTypeNode(parameterName as ThisTypeNode);
             }
             else {
@@ -25558,12 +25871,14 @@ namespace ts {
                         error(parameterName, Diagnostics.A_type_predicate_cannot_reference_a_rest_parameter);
                     }
                     else {
-                        const leadingError = () => chainDiagnosticMessages(/*details*/ undefined, Diagnostics.A_type_predicate_s_type_must_be_assignable_to_its_parameter_s_type);
-                        checkTypeAssignableTo(typePredicate.type,
-                            getTypeOfSymbol(signature.parameters[typePredicate.parameterIndex]),
-                            node.type,
-                            /*headMessage*/ undefined,
-                            leadingError);
+                        if (typePredicate.type) {
+                            const leadingError = () => chainDiagnosticMessages(/*details*/ undefined, Diagnostics.A_type_predicate_s_type_must_be_assignable_to_its_parameter_s_type);
+                            checkTypeAssignableTo(typePredicate.type,
+                                getTypeOfSymbol(signature.parameters[typePredicate.parameterIndex]),
+                                node.type,
+                                /*headMessage*/ undefined,
+                                leadingError);
+                        }
                     }
                 }
                 else if (parameterName) {
@@ -30429,6 +30744,9 @@ namespace ts {
                         cancellationToken.throwIfCancellationRequested();
                 }
             }
+            if (kind >= SyntaxKind.FirstStatement && kind <= SyntaxKind.LastStatement && node.flowNode && !isReachableFlowNode(node.flowNode)) {
+                errorOrSuggestion(compilerOptions.allowUnreachableCode === false, node, Diagnostics.Unreachable_code_detected);
+            }
 
             switch (kind) {
                 case SyntaxKind.TypeParameter:
@@ -30730,7 +31048,7 @@ namespace ts {
         function checkSourceFileWorker(node: SourceFile) {
             const links = getNodeLinks(node);
             if (!(links.flags & NodeCheckFlags.TypeChecked)) {
-                if (skipTypeChecking(node, compilerOptions)) {
+                if (skipTypeChecking(node, compilerOptions, host)) {
                     return;
                 }
 
@@ -31427,8 +31745,7 @@ namespace ts {
                     const nameType = checkComputedPropertyName(name);
                     return isTypeAssignableToKind(nameType, TypeFlags.ESSymbolLike) ? nameType : stringType;
                 default:
-                    Debug.fail("Unsupported property name.");
-                    return errorType;
+                    return Debug.fail("Unsupported property name.");
             }
         }
 
@@ -32997,6 +33314,7 @@ namespace ts {
 
                 // Modifiers are never allowed on properties except for 'async' on a method declaration
                 if (prop.modifiers) {
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
                     for (const mod of prop.modifiers!) { // TODO: GH#19955
                         if (mod.kind !== SyntaxKind.AsyncKeyword || prop.kind !== SyntaxKind.MethodDeclaration) {
                             grammarErrorOnNode(mod, Diagnostics._0_modifier_cannot_be_used_here, getTextOfNode(mod));
diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
index 009c04fbb8c..fd0d428d54b 100644
--- a/src/compiler/commandLineParser.ts
+++ b/src/compiler/commandLineParser.ts
@@ -772,6 +772,12 @@ namespace ts {
             category: Diagnostics.Advanced_Options,
             description: Diagnostics.Disable_size_limitations_on_JavaScript_projects
         },
+        {
+            name: "disableSourceOfProjectReferenceRedirect",
+            type: "boolean",
+            category: Diagnostics.Advanced_Options,
+            description: Diagnostics.Disable_use_of_source_files_instead_of_declaration_files_from_referenced_projects
+        },
         {
             name: "noImplicitUseStrict",
             type: "boolean",
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index 44bba361bbc..7ae7588bb13 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -1040,6 +1040,35 @@
         "code": 1357
     },
 
+    "The types of '{0}' are incompatible between these types.": {
+        "category": "Error",
+        "code": 2200
+    },
+    "The types returned by '{0}' are incompatible between these types.": {
+        "category": "Error",
+        "code": 2201
+    },
+    "Call signature return types '{0}' and '{1}' are incompatible.": {
+        "category": "Error",
+        "code": 2202,
+        "elidedInCompatabilityPyramid": true
+    },
+    "Construct signature return types '{0}' and '{1}' are incompatible.": {
+        "category": "Error",
+        "code": 2203,
+        "elidedInCompatabilityPyramid": true
+    },
+    "Call signatures with no arguments have incompatible return types '{0}' and '{1}'.": {
+        "category": "Error",
+        "code": 2204,
+        "elidedInCompatabilityPyramid": true
+    },
+    "Construct signatures with no arguments have incompatible return types '{0}' and '{1}'.": {
+        "category": "Error",
+        "code": 2205,
+        "elidedInCompatabilityPyramid": true
+    },
+
     "Duplicate identifier '{0}'.": {
         "category": "Error",
         "code": 2300
@@ -4007,6 +4036,10 @@
         "category": "Message",
         "code": 6220
     },
+    "Disable use of source files instead of declaration files from referenced projects.": {
+        "category": "Message",
+        "code": 6221
+    },
 
     "Projects to reference": {
         "category": "Message",
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index 7bad8359b26..2ed08f29e21 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -1946,11 +1946,17 @@ namespace ts {
         //
 
         function emitTypePredicate(node: TypePredicateNode) {
+            if (node.assertsModifier) {
+                emit(node.assertsModifier);
+                writeSpace();
+            }
             emit(node.parameterName);
-            writeSpace();
-            writeKeyword("is");
-            writeSpace();
-            emit(node.type);
+            if (node.type) {
+                writeSpace();
+                writeKeyword("is");
+                writeSpace();
+                emit(node.type);
+            }
         }
 
         function emitTypeReference(node: TypeReferenceNode) {
diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
index 033299cd587..bd2dcbee6f1 100644
--- a/src/compiler/factory.ts
+++ b/src/compiler/factory.ts
@@ -669,16 +669,26 @@ namespace ts {
     }
 
     export function createTypePredicateNode(parameterName: Identifier | ThisTypeNode | string, type: TypeNode) {
+        return createTypePredicateNodeWithModifier(/*assertsModifier*/ undefined, parameterName, type);
+    }
+
+    export function createTypePredicateNodeWithModifier(assertsModifier: AssertsToken | undefined, parameterName: Identifier | ThisTypeNode | string, type: TypeNode | undefined) {
         const node = createSynthesizedNode(SyntaxKind.TypePredicate) as TypePredicateNode;
+        node.assertsModifier = assertsModifier;
         node.parameterName = asName(parameterName);
         node.type = type;
         return node;
     }
 
     export function updateTypePredicateNode(node: TypePredicateNode, parameterName: Identifier | ThisTypeNode, type: TypeNode) {
-        return node.parameterName !== parameterName
+        return updateTypePredicateNodeWithModifier(node, node.assertsModifier, parameterName, type);
+    }
+
+    export function updateTypePredicateNodeWithModifier(node: TypePredicateNode, assertsModifier: AssertsToken | undefined, parameterName: Identifier | ThisTypeNode, type: TypeNode | undefined) {
+        return node.assertsModifier !== assertsModifier
+            || node.parameterName !== parameterName
             || node.type !== type
-            ? updateNode(createTypePredicateNode(parameterName, type), node)
+            ? updateNode(createTypePredicateNodeWithModifier(assertsModifier, parameterName, type), node)
             : node;
     }
 
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index f437ca697a8..edaa7ebeaeb 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -165,7 +165,8 @@ namespace ts {
                 return visitNode(cbNode, (<TypeReferenceNode>node).typeName) ||
                     visitNodes(cbNode, cbNodes, (<TypeReferenceNode>node).typeArguments);
             case SyntaxKind.TypePredicate:
-                return visitNode(cbNode, (<TypePredicateNode>node).parameterName) ||
+                return visitNode(cbNode, (<TypePredicateNode>node).assertsModifier) ||
+                    visitNode(cbNode, (<TypePredicateNode>node).parameterName) ||
                     visitNode(cbNode, (<TypePredicateNode>node).type);
             case SyntaxKind.TypeQuery:
                 return visitNode(cbNode, (<TypeQueryNode>node).exprName);
@@ -3041,6 +3042,8 @@ namespace ts {
                     return parseParenthesizedType();
                 case SyntaxKind.ImportKeyword:
                     return parseImportType();
+                case SyntaxKind.AssertsKeyword:
+                    return lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine) ? parseAssertsTypePredicate() : parseTypeReference();
                 default:
                     return parseTypeReference();
             }
@@ -3081,6 +3084,7 @@ namespace ts {
                 case SyntaxKind.DotDotDotToken:
                 case SyntaxKind.InferKeyword:
                 case SyntaxKind.ImportKeyword:
+                case SyntaxKind.AssertsKeyword:
                     return true;
                 case SyntaxKind.FunctionKeyword:
                     return !inStartOfParameter;
@@ -3257,6 +3261,7 @@ namespace ts {
             const type = parseType();
             if (typePredicateVariable) {
                 const node = <TypePredicateNode>createNode(SyntaxKind.TypePredicate, typePredicateVariable.pos);
+                node.assertsModifier = undefined;
                 node.parameterName = typePredicateVariable;
                 node.type = type;
                 return finishNode(node);
@@ -3274,6 +3279,14 @@ namespace ts {
             }
         }
 
+        function parseAssertsTypePredicate(): TypeNode {
+            const node = <TypePredicateNode>createNode(SyntaxKind.TypePredicate);
+            node.assertsModifier = parseExpectedToken(SyntaxKind.AssertsKeyword);
+            node.parameterName = token() === SyntaxKind.ThisKeyword ? parseThisTypeNode() : parseIdentifier();
+            node.type = parseOptional(SyntaxKind.IsKeyword) ? parseType() : undefined;
+            return finishNode(node);
+        }
+
         function parseType(): TypeNode {
             // The rules about 'yield' only apply to actual code/expression contexts.  They don't
             // apply to 'type' contexts.  So we disable these parameters here before moving on.
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
index 23a3e660c82..e7c51ba84cb 100644
--- a/src/compiler/program.ts
+++ b/src/compiler/program.ts
@@ -817,6 +817,8 @@ namespace ts {
         let resolvedProjectReferences: readonly (ResolvedProjectReference | undefined)[] | undefined;
         let projectReferenceRedirects: Map<ResolvedProjectReference | false> | undefined;
         let mapFromFileToProjectReferenceRedirects: Map<Path> | undefined;
+        let mapFromToProjectReferenceRedirectSource: Map<SourceOfProjectReferenceRedirect> | undefined;
+        const useSourceOfProjectReferenceRedirect = !!host.useSourceOfProjectReferenceRedirect && host.useSourceOfProjectReferenceRedirect();
 
         const shouldCreateNewSourceFile = shouldProgramCreateNewSourceFiles(oldProgram, options);
         // We set `structuralIsReused` to `undefined` because `tryReuseStructureFromOldProgram` calls `tryReuseStructureFromOldProgram` which checks
@@ -831,17 +833,32 @@ namespace ts {
                 if (!resolvedProjectReferences) {
                     resolvedProjectReferences = projectReferences.map(parseProjectReferenceConfigFile);
                 }
+                if (host.setResolvedProjectReferenceCallbacks) {
+                    host.setResolvedProjectReferenceCallbacks({
+                        getSourceOfProjectReferenceRedirect,
+                        forEachResolvedProjectReference
+                    });
+                }
                 if (rootNames.length) {
                     for (const parsedRef of resolvedProjectReferences) {
                         if (!parsedRef) continue;
                         const out = parsedRef.commandLine.options.outFile || parsedRef.commandLine.options.out;
-                        if (out) {
-                            processSourceFile(changeExtension(out, ".d.ts"), /*isDefaultLib*/ false, /*ignoreNoDefaultLib*/ false, /*packageId*/ undefined);
+                        if (useSourceOfProjectReferenceRedirect) {
+                            if (out || getEmitModuleKind(parsedRef.commandLine.options) === ModuleKind.None) {
+                                for (const fileName of parsedRef.commandLine.fileNames) {
+                                    processSourceFile(fileName, /*isDefaultLib*/ false, /*ignoreNoDefaultLib*/ false, /*packageId*/ undefined);
+                                }
+                            }
                         }
-                        else if (getEmitModuleKind(parsedRef.commandLine.options) === ModuleKind.None) {
-                            for (const fileName of parsedRef.commandLine.fileNames) {
-                                if (!fileExtensionIs(fileName, Extension.Dts) && hasTSFileExtension(fileName)) {
-                                    processSourceFile(getOutputDeclarationFileName(fileName, parsedRef.commandLine, !host.useCaseSensitiveFileNames()), /*isDefaultLib*/ false, /*ignoreNoDefaultLib*/ false, /*packageId*/ undefined);
+                        else {
+                            if (out) {
+                                processSourceFile(changeExtension(out, ".d.ts"), /*isDefaultLib*/ false, /*ignoreNoDefaultLib*/ false, /*packageId*/ undefined);
+                            }
+                            else if (getEmitModuleKind(parsedRef.commandLine.options) === ModuleKind.None) {
+                                for (const fileName of parsedRef.commandLine.fileNames) {
+                                    if (!fileExtensionIs(fileName, Extension.Dts) && hasTSFileExtension(fileName)) {
+                                        processSourceFile(getOutputDeclarationFileName(fileName, parsedRef.commandLine, !host.useCaseSensitiveFileNames()), /*isDefaultLib*/ false, /*ignoreNoDefaultLib*/ false, /*packageId*/ undefined);
+                                    }
                                 }
                             }
                         }
@@ -955,6 +972,7 @@ namespace ts {
             getResolvedProjectReferenceToRedirect,
             getResolvedProjectReferenceByPath,
             forEachResolvedProjectReference,
+            isSourceOfProjectReferenceRedirect,
             emitBuildInfo
         };
 
@@ -987,9 +1005,15 @@ namespace ts {
             return ts.toPath(fileName, currentDirectory, getCanonicalFileName);
         }
 
+        function isValidSourceFileForEmit(file: SourceFile) {
+            // source file is allowed to be emitted and its not source of project reference redirect
+            return sourceFileMayBeEmitted(file, options, isSourceFileFromExternalLibrary, getResolvedProjectReferenceToRedirect) &&
+                !isSourceOfProjectReferenceRedirect(file.fileName);
+        }
+
         function getCommonSourceDirectory() {
             if (commonSourceDirectory === undefined) {
-                const emittedFiles = filter(files, file => sourceFileMayBeEmitted(file, options, isSourceFileFromExternalLibrary, getResolvedProjectReferenceToRedirect));
+                const emittedFiles = filter(files, file => isValidSourceFileForEmit(file));
                 if (options.rootDir && checkSourceFilesBelongToPath(emittedFiles, options.rootDir)) {
                     // If a rootDir is specified use it as the commonSourceDirectory
                     commonSourceDirectory = getNormalizedAbsolutePath(options.rootDir, currentDirectory);
@@ -1220,6 +1244,12 @@ namespace ts {
             }
             if (projectReferences) {
                 resolvedProjectReferences = projectReferences.map(parseProjectReferenceConfigFile);
+                if (host.setResolvedProjectReferenceCallbacks) {
+                    host.setResolvedProjectReferenceCallbacks({
+                        getSourceOfProjectReferenceRedirect,
+                        forEachResolvedProjectReference
+                    });
+                }
             }
 
             // check if program source files has changed in the way that can affect structure of the program
@@ -1403,6 +1433,13 @@ namespace ts {
             for (const newSourceFile of newSourceFiles) {
                 const filePath = newSourceFile.path;
                 addFileToFilesByName(newSourceFile, filePath, newSourceFile.resolvedPath);
+                if (useSourceOfProjectReferenceRedirect) {
+                    const redirectProject = getProjectReferenceRedirectProject(newSourceFile.fileName);
+                    if (redirectProject && !(redirectProject.commandLine.options.outFile || redirectProject.commandLine.options.out)) {
+                        const redirect = getProjectReferenceOutputName(redirectProject, newSourceFile.fileName);
+                        addFileToFilesByName(newSourceFile, toPath(redirect), /*redirectedPath*/ undefined);
+                    }
+                }
                 // Set the file as found during node modules search if it was found that way in old progra,
                 if (oldProgram.isSourceFileFromExternalLibrary(oldProgram.getSourceFileByPath(newSourceFile.resolvedPath)!)) {
                     sourceFilesFoundSearchingNodeModules.set(filePath, true);
@@ -1682,7 +1719,7 @@ namespace ts {
 
         function getSemanticDiagnosticsForFileNoCache(sourceFile: SourceFile, cancellationToken: CancellationToken): Diagnostic[] | undefined {
             return runWithCancellationToken(() => {
-                if (skipTypeChecking(sourceFile, options)) {
+                if (skipTypeChecking(sourceFile, options, program)) {
                     return emptyArray;
                 }
 
@@ -2234,6 +2271,16 @@ namespace ts {
 
         // Get source file from normalized fileName
         function findSourceFile(fileName: string, path: Path, isDefaultLib: boolean, ignoreNoDefaultLib: boolean, refFile: RefFile | undefined, packageId: PackageId | undefined): SourceFile | undefined {
+            if (useSourceOfProjectReferenceRedirect) {
+                const source = getSourceOfProjectReferenceRedirect(fileName);
+                if (source) {
+                    const file = isString(source) ?
+                        findSourceFile(source, toPath(source), isDefaultLib, ignoreNoDefaultLib, refFile, packageId) :
+                        undefined;
+                    if (file) addFileToFilesByName(file, path, /*redirectedPath*/ undefined);
+                    return file;
+                }
+            }
             const originalFileName = fileName;
             if (filesByName.has(path)) {
                 const file = filesByName.get(path);
@@ -2282,7 +2329,7 @@ namespace ts {
             }
 
             let redirectedPath: Path | undefined;
-            if (refFile) {
+            if (refFile && !useSourceOfProjectReferenceRedirect) {
                 const redirectProject = getProjectReferenceRedirectProject(fileName);
                 if (redirectProject) {
                     if (redirectProject.commandLine.options.outFile || redirectProject.commandLine.options.out) {
@@ -2451,6 +2498,36 @@ namespace ts {
             });
         }
 
+        function getSourceOfProjectReferenceRedirect(file: string) {
+            if (!isDeclarationFileName(file)) return undefined;
+            if (mapFromToProjectReferenceRedirectSource === undefined) {
+                mapFromToProjectReferenceRedirectSource = createMap();
+                forEachResolvedProjectReference(resolvedRef => {
+                    if (resolvedRef) {
+                        const out = resolvedRef.commandLine.options.outFile || resolvedRef.commandLine.options.out;
+                        if (out) {
+                            // Dont know which source file it means so return true?
+                            const outputDts = changeExtension(out, Extension.Dts);
+                            mapFromToProjectReferenceRedirectSource!.set(toPath(outputDts), true);
+                        }
+                        else {
+                            forEach(resolvedRef.commandLine.fileNames, fileName => {
+                                if (!fileExtensionIs(fileName, Extension.Dts) && hasTSFileExtension(fileName)) {
+                                    const outputDts = getOutputDeclarationFileName(fileName, resolvedRef.commandLine, host.useCaseSensitiveFileNames());
+                                    mapFromToProjectReferenceRedirectSource!.set(toPath(outputDts), fileName);
+                                }
+                            });
+                        }
+                    }
+                });
+            }
+            return mapFromToProjectReferenceRedirectSource.get(toPath(file));
+        }
+
+        function isSourceOfProjectReferenceRedirect(fileName: string) {
+            return useSourceOfProjectReferenceRedirect && !!getResolvedProjectReferenceToRedirect(fileName);
+        }
+
         function forEachProjectReference<T>(
             projectReferences: readonly ProjectReference[] | undefined,
             resolvedProjectReferences: readonly (ResolvedProjectReference | undefined)[] | undefined,
@@ -2858,8 +2935,7 @@ namespace ts {
                 const rootPaths = arrayToSet(rootNames, toPath);
                 for (const file of files) {
                     // Ignore file that is not emitted
-                    if (!sourceFileMayBeEmitted(file, options, isSourceFileFromExternalLibrary, getResolvedProjectReferenceToRedirect)) continue;
-                    if (!rootPaths.has(file.path)) {
+                    if (isValidSourceFileForEmit(file) && !rootPaths.has(file.path)) {
                         addProgramDiagnosticAtRefPath(
                             file,
                             rootPaths,
diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts
index ad60d29866d..1de4327d2b4 100644
--- a/src/compiler/scanner.ts
+++ b/src/compiler/scanner.ts
@@ -66,6 +66,7 @@ namespace ts {
         abstract: SyntaxKind.AbstractKeyword,
         any: SyntaxKind.AnyKeyword,
         as: SyntaxKind.AsKeyword,
+        asserts: SyntaxKind.AssertsKeyword,
         bigint: SyntaxKind.BigIntKeyword,
         boolean: SyntaxKind.BooleanKeyword,
         break: SyntaxKind.BreakKeyword,
diff --git a/src/compiler/sys.ts b/src/compiler/sys.ts
index 06d08c388ab..6a3f4ed86bd 100644
--- a/src/compiler/sys.ts
+++ b/src/compiler/sys.ts
@@ -522,6 +522,33 @@ namespace ts {
         }
     }
 
+    function recursiveCreateDirectory(directoryPath: string, sys: System) {
+        const basePath = getDirectoryPath(directoryPath);
+        const shouldCreateParent = basePath !== "" && directoryPath !== basePath && !sys.directoryExists(basePath);
+        if (shouldCreateParent) {
+            recursiveCreateDirectory(basePath, sys);
+        }
+        if (shouldCreateParent || !sys.directoryExists(directoryPath)) {
+            sys.createDirectory(directoryPath);
+        }
+    }
+
+    /**
+     * patch writefile to create folder before writing the file
+     */
+    /*@internal*/
+    export function patchWriteFileEnsuringDirectory(sys: System) {
+        // patch writefile to create folder before writing the file
+        const originalWriteFile = sys.writeFile;
+        sys.writeFile = (path, data, writeBom) => {
+            const directoryPath = getDirectoryPath(normalizeSlashes(path));
+            if (directoryPath && !sys.directoryExists(directoryPath)) {
+                recursiveCreateDirectory(directoryPath, sys);
+            }
+            originalWriteFile.call(sys, path, data, writeBom);
+        };
+    }
+
     /*@internal*/
     export type BufferEncoding = "ascii" | "utf8" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "latin1" | "binary" | "hex";
 
@@ -1367,17 +1394,6 @@ namespace ts {
             };
         }
 
-        function recursiveCreateDirectory(directoryPath: string, sys: System) {
-            const basePath = getDirectoryPath(directoryPath);
-            const shouldCreateParent = basePath !== "" && directoryPath !== basePath && !sys.directoryExists(basePath);
-            if (shouldCreateParent) {
-                recursiveCreateDirectory(basePath, sys);
-            }
-            if (shouldCreateParent || !sys.directoryExists(directoryPath)) {
-                sys.createDirectory(directoryPath);
-            }
-        }
-
         let sys: System | undefined;
         if (typeof ChakraHost !== "undefined") {
             sys = getChakraSystem();
@@ -1389,14 +1405,7 @@ namespace ts {
         }
         if (sys) {
             // patch writefile to create folder before writing the file
-            const originalWriteFile = sys.writeFile;
-            sys.writeFile = (path, data, writeBom) => {
-                const directoryPath = getDirectoryPath(normalizeSlashes(path));
-                if (directoryPath && !sys!.directoryExists(directoryPath)) {
-                    recursiveCreateDirectory(directoryPath, sys!);
-                }
-                originalWriteFile.call(sys, path, data, writeBom);
-            };
+            patchWriteFileEnsuringDirectory(sys);
         }
         return sys!;
     })();
diff --git a/src/compiler/transformers/generators.ts b/src/compiler/transformers/generators.ts
index 3b1a8379e07..cc16aef6009 100644
--- a/src/compiler/transformers/generators.ts
+++ b/src/compiler/transformers/generators.ts
@@ -2871,7 +2871,7 @@ namespace ts {
         function tryEnterOrLeaveBlock(operationIndex: number): void {
             if (blocks) {
                 for (; blockIndex < blockActions!.length && blockOffsets![blockIndex] <= operationIndex; blockIndex++) {
-                    const block = blocks[blockIndex];
+                    const block: CodeBlock = blocks[blockIndex];
                     const blockAction = blockActions![blockIndex];
                     switch (block.kind) {
                         case CodeBlockKind.Exception:
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 1828d056405..def1074ee10 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -32,6 +32,7 @@ namespace ts {
         | SyntaxKind.AbstractKeyword
         | SyntaxKind.AnyKeyword
         | SyntaxKind.AsKeyword
+        | SyntaxKind.AssertsKeyword
         | SyntaxKind.BigIntKeyword
         | SyntaxKind.BooleanKeyword
         | SyntaxKind.BreakKeyword
@@ -250,6 +251,7 @@ namespace ts {
         // Contextual keywords
         AbstractKeyword,
         AsKeyword,
+        AssertsKeyword,
         AnyKeyword,
         AsyncKeyword,
         AwaitKeyword,
@@ -361,8 +363,8 @@ namespace ts {
         SemicolonClassElement,
         // Element
         Block,
-        VariableStatement,
         EmptyStatement,
+        VariableStatement,
         ExpressionStatement,
         IfStatement,
         DoStatement,
@@ -512,6 +514,8 @@ namespace ts {
         LastTemplateToken = TemplateTail,
         FirstBinaryOperator = LessThanToken,
         LastBinaryOperator = CaretEqualsToken,
+        FirstStatement = VariableStatement,
+        LastStatement = DebuggerStatement,
         FirstNode = QualifiedName,
         FirstJSDocNode = JSDocTypeExpression,
         LastJSDocNode = JSDocPropertyTag,
@@ -614,9 +618,13 @@ namespace ts {
 
     /* @internal */
     export const enum RelationComparisonResult {
-        Succeeded = 1, // Should be truthy
-        Failed = 2,
-        FailedAndReported = 3
+        Succeeded           = 1 << 0, // Should be truthy
+        Failed              = 1 << 1,
+        Reported            = 1 << 2,
+
+        ReportsUnmeasurable = 1 << 3,
+        ReportsUnreliable   = 1 << 4,
+        ReportsMask         = ReportsUnmeasurable | ReportsUnreliable
     }
 
     export interface Node extends TextRange {
@@ -736,6 +744,7 @@ namespace ts {
     export type AwaitKeywordToken = Token<SyntaxKind.AwaitKeyword>;
     export type PlusToken = Token<SyntaxKind.PlusToken>;
     export type MinusToken = Token<SyntaxKind.MinusToken>;
+    export type AssertsToken = Token<SyntaxKind.AssertsKeyword>;
 
     export type Modifier
         = Token<SyntaxKind.AbstractKeyword>
@@ -1037,6 +1046,7 @@ namespace ts {
         questionToken?: QuestionToken;
         exclamationToken?: ExclamationToken;
         body?: Block | Expression;
+        /* @internal */ endFlowNode?: FlowNode;
     }
 
     export type FunctionLikeDeclaration =
@@ -1180,8 +1190,9 @@ namespace ts {
     export interface TypePredicateNode extends TypeNode {
         kind: SyntaxKind.TypePredicate;
         parent: SignatureDeclaration | JSDocTypeExpression;
+        assertsModifier?: AssertsToken;
         parameterName: Identifier | ThisTypeNode;
-        type: TypeNode;
+        type?: TypeNode;
     }
 
     export interface TypeQueryNode extends TypeNode {
@@ -2570,16 +2581,33 @@ namespace ts {
         FalseCondition = 1 << 6,  // Condition known to be false
         SwitchClause   = 1 << 7,  // Switch statement clause
         ArrayMutation  = 1 << 8,  // Potential array mutation
-        Referenced     = 1 << 9,  // Referenced as antecedent once
-        Shared         = 1 << 10, // Referenced as antecedent more than once
-        PreFinally     = 1 << 11, // Injected edge that links pre-finally label and pre-try flow
-        AfterFinally   = 1 << 12, // Injected edge that links post-finally flow with the rest of the graph
+        Call           = 1 << 9,  // Potential assertion call
+        Referenced     = 1 << 10, // Referenced as antecedent once
+        Shared         = 1 << 11, // Referenced as antecedent more than once
+        PreFinally     = 1 << 12, // Injected edge that links pre-finally label and pre-try flow
+        AfterFinally   = 1 << 13, // Injected edge that links post-finally flow with the rest of the graph
         /** @internal */
-        Cached         = 1 << 13, // Indicates that at least one cross-call cache entry exists for this node, even if not a loop participant
+        Cached         = 1 << 14, // Indicates that at least one cross-call cache entry exists for this node, even if not a loop participant
         Label = BranchLabel | LoopLabel,
         Condition = TrueCondition | FalseCondition
     }
 
+    export type FlowNode =
+        | AfterFinallyFlow
+        | PreFinallyFlow
+        | FlowStart
+        | FlowLabel
+        | FlowAssignment
+        | FlowCall
+        | FlowCondition
+        | FlowSwitchClause
+        | FlowArrayMutation;
+
+    export interface FlowNodeBase {
+        flags: FlowFlags;
+        id?: number;     // Node id used by flow type cache in checker
+    }
+
     export interface FlowLock {
         locked?: boolean;
     }
@@ -2593,18 +2621,11 @@ namespace ts {
         lock: FlowLock;
     }
 
-    export type FlowNode =
-        | AfterFinallyFlow | PreFinallyFlow | FlowStart | FlowLabel | FlowAssignment | FlowCondition | FlowSwitchClause | FlowArrayMutation;
-    export interface FlowNodeBase {
-        flags: FlowFlags;
-        id?: number;     // Node id used by flow type cache in checker
-    }
-
     // FlowStart represents the start of a control flow. For a function expression or arrow
-    // function, the container property references the function (which in turn has a flowNode
+    // function, the node property references the function (which in turn has a flowNode
     // property for the containing control flow).
     export interface FlowStart extends FlowNodeBase {
-        container?: FunctionExpression | ArrowFunction | MethodDeclaration;
+        node?: FunctionExpression | ArrowFunction | MethodDeclaration;
     }
 
     // FlowLabel represents a junction with multiple possible preceding control flows.
@@ -2619,10 +2640,15 @@ namespace ts {
         antecedent: FlowNode;
     }
 
+    export interface FlowCall extends FlowNodeBase {
+        node: CallExpression;
+        antecedent: FlowNode;
+    }
+
     // FlowCondition represents a condition that is known to be true or false at the
     // node's location in the control flow.
     export interface FlowCondition extends FlowNodeBase {
-        expression: Expression;
+        node: Expression;
         antecedent: FlowNode;
     }
 
@@ -3039,6 +3065,7 @@ namespace ts {
         /*@internal*/ getResolvedProjectReferenceToRedirect(fileName: string): ResolvedProjectReference | undefined;
         /*@internal*/ forEachResolvedProjectReference<T>(cb: (resolvedProjectReference: ResolvedProjectReference | undefined, resolvedProjectReferencePath: Path) => T | undefined): T | undefined;
         /*@internal*/ getResolvedProjectReferenceByPath(projectReferencePath: Path): ResolvedProjectReference | undefined;
+        /*@internal*/ isSourceOfProjectReferenceRedirect(fileName: string): boolean;
         /*@internal*/ getProgramBuildInfo?(): ProgramBuildInfo | undefined;
         /*@internal*/ emitBuildInfo(writeFile?: WriteFileCallback, cancellationToken?: CancellationToken): EmitResult;
     }
@@ -3139,6 +3166,7 @@ namespace ts {
         getSourceFile(fileName: string): SourceFile | undefined;
         getResolvedTypeReferenceDirectives(): ReadonlyMap<ResolvedTypeReferenceDirective | undefined>;
         getProjectReferenceRedirect(fileName: string): string | undefined;
+        isSourceOfProjectReferenceRedirect(fileName: string): boolean;
 
         readonly redirectTargetsMap: RedirectTargetsMap;
     }
@@ -3289,6 +3317,7 @@ namespace ts {
         /* @internal */ getElementTypeOfArrayType(arrayType: Type): Type | undefined;
         /* @internal */ createPromiseType(type: Type): Type;
 
+        /* @internal */ isTypeAssignableTo(source: Type, target: Type): boolean;
         /* @internal */ createAnonymousType(symbol: Symbol, members: SymbolTable, callSignatures: Signature[], constructSignatures: Signature[], stringIndexInfo: IndexInfo | undefined, numberIndexInfo: IndexInfo | undefined): Type;
         /* @internal */ createSignature(
             declaration: SignatureDeclaration,
@@ -3527,25 +3556,45 @@ namespace ts {
 
     export const enum TypePredicateKind {
         This,
-        Identifier
+        Identifier,
+        AssertsThis,
+        AssertsIdentifier
     }
 
     export interface TypePredicateBase {
         kind: TypePredicateKind;
-        type: Type;
+        type: Type | undefined;
     }
 
     export interface ThisTypePredicate extends TypePredicateBase {
         kind: TypePredicateKind.This;
+        parameterName: undefined;
+        parameterIndex: undefined;
+        type: Type;
     }
 
     export interface IdentifierTypePredicate extends TypePredicateBase {
         kind: TypePredicateKind.Identifier;
         parameterName: string;
         parameterIndex: number;
+        type: Type;
     }
 
-    export type TypePredicate = IdentifierTypePredicate | ThisTypePredicate;
+    export interface AssertsThisTypePredicate extends TypePredicateBase {
+        kind: TypePredicateKind.AssertsThis;
+        parameterName: undefined;
+        parameterIndex: undefined;
+        type: Type | undefined;
+    }
+
+    export interface AssertsIdentifierTypePredicate extends TypePredicateBase {
+        kind: TypePredicateKind.AssertsIdentifier;
+        parameterName: string;
+        parameterIndex: number;
+        type: Type | undefined;
+    }
+
+    export type TypePredicate = ThisTypePredicate | IdentifierTypePredicate | AssertsThisTypePredicate | AssertsIdentifierTypePredicate;
 
     /* @internal */
     export type AnyImportSyntax = ImportDeclaration | ImportEqualsDeclaration;
@@ -3963,7 +4012,7 @@ namespace ts {
         resolvedSignature?: Signature;    // Cached signature of signature node or call expression
         resolvedSymbol?: Symbol;          // Cached name resolution result
         resolvedIndexInfo?: IndexInfo;    // Cached indexing info resolution result
-        maybeTypePredicate?: boolean;     // Cached check whether call expression might reference a type predicate
+        effectsSignature?: Signature;     // Signature with possible control flow effects
         enumMemberValue?: string | number;  // Constant value of enum member
         isVisible?: boolean;              // Is this node visible
         containsArgumentsReference?: boolean; // Whether a function-like declaration contains an 'arguments' reference
@@ -3978,6 +4027,7 @@ namespace ts {
         contextFreeType?: Type;          // Cached context-free type used by the first pass of inference; used when a function's return is partially contextually sensitive
         deferredNodes?: Map<Node>; // Set of nodes whose checking has been deferred
         capturedBlockScopeBindings?: Symbol[]; // Block-scoped bindings captured beneath this part of an IterationStatement
+        isExhaustive?: boolean;           // Is node an exhaustive switch statement
     }
 
     export const enum TypeFlags {
@@ -4202,7 +4252,7 @@ namespace ts {
     }
 
     // Object type or intersection of object types
-    export type BaseType = ObjectType | IntersectionType;
+    export type BaseType = ObjectType | IntersectionType | TypeVariable; // Also `any` and `object`
 
     export interface InterfaceTypeWithDeclaredMembers extends InterfaceType {
         declaredProperties: Symbol[];                   // Declared members
@@ -4631,6 +4681,8 @@ namespace ts {
         code: number;
         message: string;
         reportsUnnecessary?: {};
+        /* @internal */
+        elidedInCompatabilityPyramid?: boolean;
     }
 
     /**
@@ -4725,6 +4777,7 @@ namespace ts {
         /* @internal */ diagnostics?: boolean;
         /* @internal */ extendedDiagnostics?: boolean;
         disableSizeLimit?: boolean;
+        disableSourceOfProjectReferenceRedirect?: boolean;
         downlevelIteration?: boolean;
         emitBOM?: boolean;
         emitDecoratorMetadata?: boolean;
@@ -5253,11 +5306,23 @@ namespace ts {
         /* @internal */ hasChangedAutomaticTypeDirectiveNames?: boolean;
         createHash?(data: string): string;
         getParsedCommandLine?(fileName: string): ParsedCommandLine | undefined;
+        /* @internal */ setResolvedProjectReferenceCallbacks?(callbacks: ResolvedProjectReferenceCallbacks): void;
+        /* @internal */ useSourceOfProjectReferenceRedirect?(): boolean;
 
         // TODO: later handle this in better way in builder host instead once the api for tsbuild finalizes and doesn't use compilerHost as base
         /*@internal*/createDirectory?(directory: string): void;
     }
 
+    /** true if --out otherwise source file name */
+    /*@internal*/
+    export type SourceOfProjectReferenceRedirect = string | true;
+
+    /*@internal*/
+    export interface ResolvedProjectReferenceCallbacks {
+        getSourceOfProjectReferenceRedirect(fileName: string): SourceOfProjectReferenceRedirect | undefined;
+        forEachResolvedProjectReference<T>(cb: (resolvedProjectReference: ResolvedProjectReference | undefined, resolvedProjectReferencePath: Path) => T | undefined): T | undefined;
+    }
+
     /* @internal */
     export const enum TransformFlags {
         None = 0,
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 1645b9339ae..6b48cb80625 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -8713,11 +8713,16 @@ namespace ts {
         return { pos: typeParameters.pos - 1, end: typeParameters.end + 1 };
     }
 
-    export function skipTypeChecking(sourceFile: SourceFile, options: CompilerOptions) {
+    export interface HostWithIsSourceOfProjectReferenceRedirect {
+        isSourceOfProjectReferenceRedirect(fileName: string): boolean;
+    }
+    export function skipTypeChecking(sourceFile: SourceFile, options: CompilerOptions, host: HostWithIsSourceOfProjectReferenceRedirect) {
         // If skipLibCheck is enabled, skip reporting errors if file is a declaration file.
         // If skipDefaultLibCheck is enabled, skip reporting errors if file contains a
         // '/// <reference no-default-lib="true"/>' directive.
-        return options.skipLibCheck && sourceFile.isDeclarationFile || options.skipDefaultLibCheck && sourceFile.hasNoDefaultLib;
+        return (options.skipLibCheck && sourceFile.isDeclarationFile ||
+            options.skipDefaultLibCheck && sourceFile.hasNoDefaultLib) ||
+            host.isSourceOfProjectReferenceRedirect(sourceFile.fileName);
     }
 
     export function isJsonEqual(a: unknown, b: unknown): boolean {
diff --git a/src/compiler/visitor.ts b/src/compiler/visitor.ts
index 8b7805e6905..3ef382cd10f 100644
--- a/src/compiler/visitor.ts
+++ b/src/compiler/visitor.ts
@@ -333,7 +333,8 @@ namespace ts {
 
             // Types
             case SyntaxKind.TypePredicate:
-                return updateTypePredicateNode(<TypePredicateNode>node,
+                return updateTypePredicateNodeWithModifier(<TypePredicateNode>node,
+                    visitNode((<TypePredicateNode>node).assertsModifier, visitor),
                     visitNode((<TypePredicateNode>node).parameterName, visitor),
                     visitNode((<TypePredicateNode>node).type, visitor, isTypeNode));
 
diff --git a/src/harness/virtualFileSystemWithWatch.ts b/src/harness/virtualFileSystemWithWatch.ts
index 1a2fd5f4cc8..0417ad55c99 100644
--- a/src/harness/virtualFileSystemWithWatch.ts
+++ b/src/harness/virtualFileSystemWithWatch.ts
@@ -44,7 +44,10 @@ interface Array<T> { length: number; [n: number]: T; }`
     }
 
     export function createServerHost(fileOrFolderList: readonly FileOrFolderOrSymLink[], params?: TestServerHostCreationParameters): TestServerHost {
-        return new TestServerHost(/*withSafelist*/ true, fileOrFolderList, params);
+        const host = new TestServerHost(/*withSafelist*/ true, fileOrFolderList, params);
+        // Just like sys, patch the host to use writeFile
+        patchWriteFileEnsuringDirectory(host);
+        return host;
     }
 
     export interface File {
@@ -174,8 +177,8 @@ interface Array<T> { length: number; [n: number]: T; }`
         }
     }
 
-    export function checkWatchedFiles(host: TestServerHost, expectedFiles: string[]) {
-        checkMapKeys("watchedFiles", host.watchedFiles, expectedFiles);
+    export function checkWatchedFiles(host: TestServerHost, expectedFiles: string[], additionalInfo?: string) {
+        checkMapKeys(`watchedFiles:: ${additionalInfo || ""}::`, host.watchedFiles, expectedFiles);
     }
 
     export function checkWatchedFilesDetailed(host: TestServerHost, expectedFiles: ReadonlyMap<number>): void;
@@ -1016,6 +1019,19 @@ interface Array<T> { length: number; [n: number]: T; }`
         }
     }
 
+    export type TestServerHostTrackingWrittenFiles = TestServerHost & { writtenFiles: Map<true>; };
+
+    export function changeToHostTrackingWrittenFiles(inputHost: TestServerHost) {
+        const host = inputHost as TestServerHostTrackingWrittenFiles;
+        const originalWriteFile = host.writeFile;
+        host.writtenFiles = createMap<true>();
+        host.writeFile = (fileName, content) => {
+            originalWriteFile.call(host, fileName, content);
+            const path = host.toFullPath(fileName);
+            host.writtenFiles.set(path, true);
+        };
+        return host;
+    }
     export const tsbuildProjectsLocation = "/user/username/projects";
     export function getTsBuildProjectFilePath(project: string, file: string) {
         return `${tsbuildProjectsLocation}/${project}/${file}`;
diff --git a/src/lib/es2015.promise.d.ts b/src/lib/es2015.promise.d.ts
index 83776137c33..45b0fa5dc59 100644
--- a/src/lib/es2015.promise.d.ts
+++ b/src/lib/es2015.promise.d.ts
@@ -18,7 +18,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike <T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>, T10 | PromiseLike<T10>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>;
+    all<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike <T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>, T10 | PromiseLike<T10>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -26,7 +26,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike <T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>;
+    all<T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike <T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -34,7 +34,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike <T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8]>;
+    all<T1, T2, T3, T4, T5, T6, T7, T8>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike <T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -42,7 +42,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T1, T2, T3, T4, T5, T6, T7>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike <T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>]): Promise<[T1, T2, T3, T4, T5, T6, T7]>;
+    all<T1, T2, T3, T4, T5, T6, T7>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike <T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>]): Promise<[T1, T2, T3, T4, T5, T6, T7]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -50,7 +50,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T1, T2, T3, T4, T5, T6>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike <T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[T1, T2, T3, T4, T5, T6]>;
+    all<T1, T2, T3, T4, T5, T6>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike <T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[T1, T2, T3, T4, T5, T6]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -58,7 +58,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T1, T2, T3, T4, T5>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike <T4>, T5 | PromiseLike<T5>]): Promise<[T1, T2, T3, T4, T5]>;
+    all<T1, T2, T3, T4, T5>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike <T4>, T5 | PromiseLike<T5>]): Promise<[T1, T2, T3, T4, T5]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -66,7 +66,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T1, T2, T3, T4>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike <T4>]): Promise<[T1, T2, T3, T4]>;
+    all<T1, T2, T3, T4>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike <T4>]): Promise<[T1, T2, T3, T4]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -74,7 +74,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T1, T2, T3>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>;
+    all<T1, T2, T3>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -82,7 +82,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T1, T2>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>;
+    all<T1, T2>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -90,7 +90,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T>(values: (T | PromiseLike<T>)[]): Promise<T[]>;
+    all<T>(values: readonly (T | PromiseLike<T>)[]): Promise<T[]>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
@@ -98,7 +98,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    race<T>(values: T[]): Promise<T extends PromiseLike<infer U> ? U : T>;
+    race<T>(values: readonly T[]): Promise<T extends PromiseLike<infer U> ? U : T>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
index 37b4ddc47a5..759eec5d54f 100644
--- a/src/server/editorServices.ts
+++ b/src/server/editorServices.ts
@@ -1777,6 +1777,12 @@ namespace ts.server {
                 configFileErrors.push(...parsedCommandLine.errors);
             }
 
+            this.logger.info(`Config: ${configFilename} : ${JSON.stringify({
+                rootNames: parsedCommandLine.fileNames,
+                options: parsedCommandLine.options,
+                projectReferences: parsedCommandLine.projectReferences
+            }, /*replacer*/ undefined, " ")}`);
+
             Debug.assert(!!parsedCommandLine.fileNames);
             const compilerOptions = parsedCommandLine.options;
 
@@ -1818,7 +1824,7 @@ namespace ts.server {
                 let scriptInfo: ScriptInfo | NormalizedPath;
                 let path: Path;
                 // Use the project's fileExists so that it can use caching instead of reaching to disk for the query
-                if (!isDynamic && !project.fileExists(newRootFile)) {
+                if (!isDynamic && !project.fileExistsWithCache(newRootFile)) {
                     path = normalizedPathToPath(normalizedPath, this.currentDirectory, this.toCanonicalFileName);
                     const existingValue = projectRootFilesMap.get(path)!;
                     if (isScriptInfo(existingValue)) {
@@ -1851,7 +1857,7 @@ namespace ts.server {
                 projectRootFilesMap.forEach((value, path) => {
                     if (!newRootScriptInfoMap.has(path)) {
                         if (isScriptInfo(value)) {
-                            project.removeFile(value, project.fileExists(path), /*detachFromProject*/ true);
+                            project.removeFile(value, project.fileExistsWithCache(path), /*detachFromProject*/ true);
                         }
                         else {
                             projectRootFilesMap.delete(path);
@@ -2584,7 +2590,9 @@ namespace ts.server {
 
         /*@internal*/
         getOriginalLocationEnsuringConfiguredProject(project: Project, location: DocumentPosition): DocumentPosition | undefined {
-            const originalLocation = project.getSourceMapper().tryGetSourcePosition(location);
+            const originalLocation = project.isSourceOfProjectReferenceRedirect(location.fileName) ?
+                location :
+                project.getSourceMapper().tryGetSourcePosition(location);
             if (!originalLocation) return undefined;
 
             const { fileName } = originalLocation;
@@ -2595,7 +2603,8 @@ namespace ts.server {
             if (!configFileName) return undefined;
 
             const configuredProject = this.findConfiguredProjectByProjectName(configFileName) ||
-                this.createAndLoadConfiguredProject(configFileName, `Creating project for original file: ${originalFileInfo.fileName} for location: ${location.fileName}`);
+                this.createAndLoadConfiguredProject(configFileName, `Creating project for original file: ${originalFileInfo.fileName}${location !== originalLocation ? " for location: " + location.fileName : ""}`);
+            if (configuredProject === project) return originalLocation;
             updateProjectIfDirty(configuredProject);
             // Keep this configured project as referenced from project
             addOriginalConfiguredProject(configuredProject);
diff --git a/src/server/project.ts b/src/server/project.ts
index 4b38a099b2b..418532bdc45 100644
--- a/src/server/project.ts
+++ b/src/server/project.ts
@@ -196,6 +196,11 @@ namespace ts.server {
         /*@internal*/
         originalConfiguredProjects: Map<true> | undefined;
 
+        /*@internal*/
+        getResolvedProjectReferenceToRedirect(_fileName: string): ResolvedProjectReference | undefined {
+            return undefined;
+        }
+
         private readonly cancellationToken: ThrottledCancellationToken;
 
         public isNonTsProject() {
@@ -391,6 +396,11 @@ namespace ts.server {
         }
 
         fileExists(file: string): boolean {
+            return this.fileExistsWithCache(file);
+        }
+
+        /* @internal */
+        fileExistsWithCache(file: string): boolean {
             // As an optimization, don't hit the disks for files we already know don't exist
             // (because we're watching for their creation).
             const path = this.toPath(file);
@@ -527,8 +537,11 @@ namespace ts.server {
             return this.projectService.getSourceFileLike(fileName, this);
         }
 
-        private shouldEmitFile(scriptInfo: ScriptInfo) {
-            return scriptInfo && !scriptInfo.isDynamicOrHasMixedContent();
+        /*@internal*/
+        shouldEmitFile(scriptInfo: ScriptInfo | undefined) {
+            return scriptInfo &&
+                !scriptInfo.isDynamicOrHasMixedContent() &&
+                !this.program!.isSourceOfProjectReferenceRedirect(scriptInfo.path);
         }
 
         getCompileOnSaveAffectedFileList(scriptInfo: ScriptInfo): string[] {
@@ -538,7 +551,7 @@ namespace ts.server {
             updateProjectIfDirty(this);
             this.builderState = BuilderState.create(this.program!, this.projectService.toCanonicalFileName, this.builderState);
             return mapDefined(BuilderState.getFilesAffectedBy(this.builderState, this.program!, scriptInfo.path, this.cancellationToken, data => this.projectService.host.createHash!(data)), // TODO: GH#18217
-                sourceFile => this.shouldEmitFile(this.projectService.getScriptInfoForPath(sourceFile.path)!) ? sourceFile.fileName : undefined);
+                sourceFile => this.shouldEmitFile(this.projectService.getScriptInfoForPath(sourceFile.path)) ? sourceFile.fileName : undefined);
         }
 
         /**
@@ -1223,6 +1236,11 @@ namespace ts.server {
             this.rootFilesMap.delete(info.path);
         }
 
+        /*@internal*/
+        isSourceOfProjectReferenceRedirect(fileName: string) {
+            return !!this.program && this.program.isSourceOfProjectReferenceRedirect(fileName);
+        }
+
         protected enableGlobalPlugins(options: CompilerOptions, pluginConfigOverrides: Map<any> | undefined) {
             const host = this.projectService.host;
 
@@ -1475,6 +1493,8 @@ namespace ts.server {
         configFileWatcher: FileWatcher | undefined;
         private directoriesWatchedForWildcards: Map<WildcardDirectoryWatcher> | undefined;
         readonly canonicalConfigFilePath: NormalizedPath;
+        private projectReferenceCallbacks: ResolvedProjectReferenceCallbacks | undefined;
+        private mapOfDeclarationDirectories: Map<true> | undefined;
 
         /* @internal */
         pendingReload: ConfigFileProgramReloadLevel | undefined;
@@ -1520,6 +1540,63 @@ namespace ts.server {
             this.canonicalConfigFilePath = asNormalizedPath(projectService.toCanonicalFileName(configFileName));
         }
 
+        /* @internal */
+        setResolvedProjectReferenceCallbacks(projectReferenceCallbacks: ResolvedProjectReferenceCallbacks) {
+            this.projectReferenceCallbacks = projectReferenceCallbacks;
+        }
+
+        /* @internal */
+        useSourceOfProjectReferenceRedirect = () => !!this.languageServiceEnabled &&
+            !this.getCompilerOptions().disableSourceOfProjectReferenceRedirect;
+
+        /**
+         * This implementation of fileExists checks if the file being requested is
+         * .d.ts file for the referenced Project.
+         * If it is it returns true irrespective of whether that file exists on host
+         */
+        fileExists(file: string): boolean {
+            // Project references go to source file instead of .d.ts file
+            if (this.useSourceOfProjectReferenceRedirect() && this.projectReferenceCallbacks) {
+                const source = this.projectReferenceCallbacks.getSourceOfProjectReferenceRedirect(file);
+                if (source) return isString(source) ? super.fileExists(source) : true;
+            }
+            return super.fileExists(file);
+        }
+
+        /**
+         * This implementation of directoryExists checks if the directory being requested is
+         * directory of .d.ts file for the referenced Project.
+         * If it is it returns true irrespective of whether that directory exists on host
+         */
+        directoryExists(path: string): boolean {
+            if (super.directoryExists(path)) return true;
+            if (!this.useSourceOfProjectReferenceRedirect() || !this.projectReferenceCallbacks) return false;
+
+            if (!this.mapOfDeclarationDirectories) {
+                this.mapOfDeclarationDirectories = createMap();
+                this.projectReferenceCallbacks.forEachResolvedProjectReference(ref => {
+                    if (!ref) return;
+                    const out = ref.commandLine.options.outFile || ref.commandLine.options.outDir;
+                    if (out) {
+                        this.mapOfDeclarationDirectories!.set(getDirectoryPath(this.toPath(out)), true);
+                    }
+                    else {
+                        // Set declaration's in different locations only, if they are next to source the directory present doesnt change
+                        const declarationDir = ref.commandLine.options.declarationDir || ref.commandLine.options.outDir;
+                        if (declarationDir) {
+                            this.mapOfDeclarationDirectories!.set(this.toPath(declarationDir), true);
+                        }
+                    }
+                });
+            }
+            const dirPath = this.toPath(path);
+            const dirPathWithTrailingDirectorySeparator = `${dirPath}${directorySeparator}`;
+            return !!forEachKey(
+                this.mapOfDeclarationDirectories,
+                declDirPath => dirPath === declDirPath || startsWith(declDirPath, dirPathWithTrailingDirectorySeparator)
+            );
+        }
+
         /**
          * If the project has reload from disk pending, it reloads (and then updates graph as part of that) instead of just updating the graph
          * @returns: true if set of files in the project stays the same and false - otherwise.
@@ -1528,6 +1605,8 @@ namespace ts.server {
             this.isInitialLoadPending = returnFalse;
             const reloadLevel = this.pendingReload;
             this.pendingReload = ConfigFileProgramReloadLevel.None;
+            this.projectReferenceCallbacks = undefined;
+            this.mapOfDeclarationDirectories = undefined;
             let result: boolean;
             switch (reloadLevel) {
                 case ConfigFileProgramReloadLevel.Partial:
@@ -1570,6 +1649,12 @@ namespace ts.server {
             return program && program.forEachResolvedProjectReference(cb);
         }
 
+        /*@internal*/
+        getResolvedProjectReferenceToRedirect(fileName: string): ResolvedProjectReference | undefined {
+            const program = this.getCurrentProgram();
+            return program && program.getResolvedProjectReferenceToRedirect(fileName);
+        }
+
         /*@internal*/
         enablePluginsWithOptions(options: CompilerOptions, pluginConfigOverrides: Map<any> | undefined) {
             const host = this.projectService.host;
@@ -1652,6 +1737,8 @@ namespace ts.server {
             this.stopWatchingWildCards();
             this.projectErrors = undefined;
             this.configFileSpecs = undefined;
+            this.projectReferenceCallbacks = undefined;
+            this.mapOfDeclarationDirectories = undefined;
             super.close();
         }
 
diff --git a/src/server/scriptInfo.ts b/src/server/scriptInfo.ts
index e441ca54d37..cbd006dd9d2 100644
--- a/src/server/scriptInfo.ts
+++ b/src/server/scriptInfo.ts
@@ -495,15 +495,17 @@ namespace ts.server {
                     // the default project; if no configured projects, the first external project should
                     // be the default project; otherwise the first inferred project should be the default.
                     let firstExternalProject;
+                    let firstConfiguredProject;
                     for (const project of this.containingProjects) {
                         if (project.projectKind === ProjectKind.Configured) {
-                            return project;
+                            if (!project.isSourceOfProjectReferenceRedirect(this.fileName)) return project;
+                            if (!firstConfiguredProject) firstConfiguredProject = project;
                         }
                         else if (project.projectKind === ProjectKind.External && !firstExternalProject) {
                             firstExternalProject = project;
                         }
                     }
-                    return firstExternalProject || this.containingProjects[0];
+                    return firstConfiguredProject || firstExternalProject || this.containingProjects[0];
             }
         }
 
diff --git a/src/server/session.ts b/src/server/session.ts
index f2996b98dd8..6fe392c722b 100644
--- a/src/server/session.ts
+++ b/src/server/session.ts
@@ -448,7 +448,9 @@ namespace ts.server {
 
     function getDefinitionInProject(definition: DocumentPosition | undefined, definingProject: Project, project: Project): DocumentPosition | undefined {
         if (!definition || project.containsFile(toNormalizedPath(definition.fileName))) return definition;
-        const mappedDefinition = definingProject.getLanguageService().getSourceMapper().tryGetGeneratedPosition(definition);
+        const mappedDefinition = definingProject.isSourceOfProjectReferenceRedirect(definition.fileName) ?
+            definition :
+            definingProject.getLanguageService().getSourceMapper().tryGetGeneratedPosition(definition);
         return mappedDefinition && project.containsFile(toNormalizedPath(mappedDefinition.fileName)) ? mappedDefinition : undefined;
     }
 
@@ -477,7 +479,7 @@ namespace ts.server {
                     for (const symlinkedProject of symlinkedProjects) addToTodo({ project: symlinkedProject, location: originalLocation as TLocation }, toDo!, seenProjects);
                 });
             }
-            return originalLocation;
+            return originalLocation === location ? undefined : originalLocation;
         });
         return toDo;
     }
@@ -1037,7 +1039,9 @@ namespace ts.server {
 
         private getEmitOutput(args: protocol.FileRequestArgs): EmitOutput {
             const { file, project } = this.getFileAndProject(args);
-            return project.getLanguageService().getEmitOutput(file);
+            return project.shouldEmitFile(project.getScriptInfo(file)) ?
+                project.getLanguageService().getEmitOutput(file) :
+                { emitSkipped: true, outputFiles: [] };
         }
 
         private mapDefinitionInfo(definitions: readonly DefinitionInfo[], project: Project): readonly protocol.FileSpanWithContext[] {
@@ -1672,10 +1676,10 @@ namespace ts.server {
             }
         }
 
-        private createCheckList(fileNames: string[], defaultProject?: Project): PendingErrorCheck[] {
+        private createCheckList(fileNames: string[]): PendingErrorCheck[] {
             return mapDefined<string, PendingErrorCheck>(fileNames, uncheckedFileName => {
                 const fileName = toNormalizedPath(uncheckedFileName);
-                const project = defaultProject || this.projectService.tryGetDefaultProjectForFile(fileName);
+                const project = this.projectService.tryGetDefaultProjectForFile(fileName);
                 return project && { fileName, project };
             });
         }
diff --git a/src/services/codefixes/inferFromUsage.ts b/src/services/codefixes/inferFromUsage.ts
index 60cd06101dc..5dd34782885 100644
--- a/src/services/codefixes/inferFromUsage.ts
+++ b/src/services/codefixes/inferFromUsage.ts
@@ -393,6 +393,19 @@ namespace ts.codefix {
 
     function inferTypeFromReferences(program: Program, references: readonly Identifier[], cancellationToken: CancellationToken) {
         const checker = program.getTypeChecker();
+        const builtinConstructors: { [s: string]: (t: Type) => Type } = {
+            string: () => checker.getStringType(),
+            number: () => checker.getNumberType(),
+            Array: t => checker.createArrayType(t),
+            Promise: t => checker.createPromiseType(t),
+        };
+        const builtins = [
+            checker.getStringType(),
+            checker.getNumberType(),
+            checker.createArrayType(checker.getAnyType()),
+            checker.createPromiseType(checker.getAnyType()),
+        ];
+
         return {
             single,
             parameters,
@@ -401,26 +414,74 @@ namespace ts.codefix {
 
         interface CallUsage {
             argumentTypes: Type[];
-            returnType: Usage;
+            return_: Usage;
         }
 
         interface Usage {
-            isNumber?: boolean;
-            isString?: boolean;
+            isNumber: boolean | undefined;
+            isString: boolean | undefined;
             /** Used ambiguously, eg x + ___ or object[___]; results in string | number if no other evidence exists */
-            isNumberOrString?: boolean;
+            isNumberOrString: boolean | undefined;
 
-            candidateTypes?: Type[];
-            properties?: UnderscoreEscapedMap<Usage>;
-            calls?: CallUsage[];
-            constructs?: CallUsage[];
-            numberIndex?: Usage;
-            stringIndex?: Usage;
-            candidateThisTypes?: Type[];
+            candidateTypes: Type[] | undefined;
+            properties: UnderscoreEscapedMap<Usage> | undefined;
+            calls: CallUsage[] | undefined;
+            constructs: CallUsage[] | undefined;
+            numberIndex: Usage | undefined;
+            stringIndex: Usage | undefined;
+            candidateThisTypes: Type[] | undefined;
+            inferredTypes: Type[] | undefined;
+        }
+
+        function createEmptyUsage(): Usage {
+            return {
+                isNumber: undefined,
+                isString: undefined,
+                isNumberOrString: undefined,
+                candidateTypes: undefined,
+                properties: undefined,
+                calls: undefined,
+                constructs: undefined,
+                numberIndex: undefined,
+                stringIndex: undefined,
+                candidateThisTypes: undefined,
+                inferredTypes: undefined,
+            };
+        }
+
+        function combineUsages(usages: Usage[]): Usage {
+            const combinedProperties = createUnderscoreEscapedMap<Usage[]>();
+            for (const u of usages) {
+                if (u.properties) {
+                    u.properties.forEach((p, name) => {
+                        if (!combinedProperties.has(name)) {
+                            combinedProperties.set(name, []);
+                        }
+                        combinedProperties.get(name)!.push(p);
+                    });
+                }
+            }
+            const properties = createUnderscoreEscapedMap<Usage>();
+            combinedProperties.forEach((ps, name) => {
+                properties.set(name, combineUsages(ps));
+            });
+            return {
+                isNumber: usages.some(u => u.isNumber),
+                isString: usages.some(u => u.isString),
+                isNumberOrString: usages.some(u => u.isNumberOrString),
+                candidateTypes: flatMap(usages, u => u.candidateTypes) as Type[],
+                properties,
+                calls: flatMap(usages, u => u.calls) as CallUsage[],
+                constructs: flatMap(usages, u => u.constructs) as CallUsage[],
+                numberIndex: forEach(usages, u => u.numberIndex),
+                stringIndex: forEach(usages, u => u.stringIndex),
+                candidateThisTypes: flatMap(usages, u => u.candidateThisTypes) as Type[],
+                inferredTypes: undefined, // clear type cache
+            };
         }
 
         function single(): Type {
-            return unifyFromUsage(inferTypesFromReferencesSingle(references));
+            return combineTypes(inferTypesFromReferencesSingle(references));
         }
 
         function parameters(declaration: FunctionLike): ParameterInference[] | undefined {
@@ -428,7 +489,7 @@ namespace ts.codefix {
                 return undefined;
             }
 
-            const usage: Usage = {};
+            const usage = createEmptyUsage();
             for (const reference of references) {
                 cancellationToken.throwIfCancellationRequested();
                 calculateUsageOfNode(reference, usage);
@@ -456,7 +517,7 @@ namespace ts.codefix {
                     const inferred = inferTypesFromReferencesSingle(getReferences(parameter.name, program, cancellationToken));
                     types.push(...(isRest ? mapDefined(inferred, checker.getElementTypeOfArrayType) : inferred));
                 }
-                const type = unifyFromUsage(types);
+                const type = combineTypes(types);
                 return {
                     type: isRest ? checker.createArrayType(type) : type,
                     isOptional: isOptional && !isRest,
@@ -466,22 +527,22 @@ namespace ts.codefix {
         }
 
         function thisParameter() {
-            const usage: Usage = {};
+            const usage = createEmptyUsage();
             for (const reference of references) {
                 cancellationToken.throwIfCancellationRequested();
                 calculateUsageOfNode(reference, usage);
             }
 
-            return unifyFromUsage(usage.candidateThisTypes || emptyArray);
+            return combineTypes(usage.candidateThisTypes || emptyArray);
         }
 
         function inferTypesFromReferencesSingle(references: readonly Identifier[]): Type[] {
-            const usage: Usage = {};
+            const usage: Usage = createEmptyUsage();
             for (const reference of references) {
                 cancellationToken.throwIfCancellationRequested();
                 calculateUsageOfNode(reference, usage);
             }
-            return inferFromUsage(usage);
+            return inferTypes(usage);
         }
 
         function calculateUsageOfNode(node: Expression, usage: Usage): void {
@@ -490,6 +551,9 @@ namespace ts.codefix {
             }
 
             switch (node.parent.kind) {
+                case SyntaxKind.ExpressionStatement:
+                    addCandidateType(usage, checker.getVoidType());
+                    break;
                 case SyntaxKind.PostfixUnaryExpression:
                     usage.isNumber = true;
                     break;
@@ -632,6 +696,9 @@ namespace ts.codefix {
                     else if (otherOperandType.flags & TypeFlags.StringLike) {
                         usage.isString = true;
                     }
+                    else if (otherOperandType.flags & TypeFlags.Any) {
+                        // do nothing, maybe we'll learn something elsewhere
+                    }
                     else {
                         usage.isNumberOrString = true;
                     }
@@ -677,7 +744,7 @@ namespace ts.codefix {
         function inferTypeFromCallExpression(parent: CallExpression | NewExpression, usage: Usage): void {
             const call: CallUsage = {
                 argumentTypes: [],
-                returnType: {}
+                return_: createEmptyUsage()
             };
 
             if (parent.arguments) {
@@ -686,7 +753,7 @@ namespace ts.codefix {
                 }
             }
 
-            calculateUsageOfNode(parent, call.returnType);
+            calculateUsageOfNode(parent, call.return_);
             if (parent.kind === SyntaxKind.CallExpression) {
                 (usage.calls || (usage.calls = [])).push(call);
             }
@@ -700,7 +767,7 @@ namespace ts.codefix {
             if (!usage.properties) {
                 usage.properties = createUnderscoreEscapedMap<Usage>();
             }
-            const propertyUsage = usage.properties.get(name) || { };
+            const propertyUsage = usage.properties.get(name) || createEmptyUsage();
             calculateUsageOfNode(parent, propertyUsage);
             usage.properties.set(name, propertyUsage);
         }
@@ -712,7 +779,7 @@ namespace ts.codefix {
             }
             else {
                 const indexType = checker.getTypeAtLocation(parent.argumentExpression);
-                const indexUsage = {};
+                const indexUsage = createEmptyUsage();
                 calculateUsageOfNode(parent, indexUsage);
                 if (indexType.flags & TypeFlags.NumberLike) {
                     usage.numberIndex = indexUsage;
@@ -752,8 +819,12 @@ namespace ts.codefix {
             return inferences.filter(i => toRemove.every(f => !f(i)));
         }
 
-        function unifyFromUsage(inferences: readonly Type[], fallback = checker.getAnyType()): Type {
-            if (!inferences.length) return fallback;
+        function combineFromUsage(usage: Usage) {
+            return combineTypes(inferTypes(usage));
+        }
+
+        function combineTypes(inferences: readonly Type[]): Type {
+            if (!inferences.length) return checker.getAnyType();
 
             // 1. string or number individually override string | number
             // 2. non-any, non-void overrides any or void
@@ -776,12 +847,12 @@ namespace ts.codefix {
             const anons = good.filter(i => checker.getObjectFlags(i) & ObjectFlags.Anonymous) as AnonymousType[];
             if (anons.length) {
                 good = good.filter(i => !(checker.getObjectFlags(i) & ObjectFlags.Anonymous));
-                good.push(unifyAnonymousTypes(anons));
+                good.push(combineAnonymousTypes(anons));
             }
-            return checker.getWidenedType(checker.getUnionType(good));
+            return checker.getWidenedType(checker.getUnionType(good.map(checker.getBaseTypeOfLiteralType), UnionReduction.Subtype));
         }
 
-        function unifyAnonymousTypes(anons: AnonymousType[]) {
+        function combineAnonymousTypes(anons: AnonymousType[]) {
             if (anons.length === 1) {
                 return anons[0];
             }
@@ -822,7 +893,7 @@ namespace ts.codefix {
                 numberIndices.length ? checker.createIndexInfo(checker.getUnionType(numberIndices), numberIndexReadonly) : undefined);
         }
 
-        function inferFromUsage(usage: Usage) {
+        function inferTypes(usage: Usage): Type[] {
             const types = [];
 
             if (usage.isNumber) {
@@ -834,92 +905,155 @@ namespace ts.codefix {
             if (usage.isNumberOrString) {
                 types.push(checker.getUnionType([checker.getStringType(), checker.getNumberType()]));
             }
+            if (usage.numberIndex) {
+                types.push(checker.createArrayType(combineFromUsage(usage.numberIndex)));
+            }
+            if (usage.properties && usage.properties.size
+                || usage.calls && usage.calls.length
+                || usage.constructs && usage.constructs.length
+                || usage.stringIndex) {
+                types.push(inferStructuralType(usage));
+            }
 
             types.push(...(usage.candidateTypes || []).map(t => checker.getBaseTypeOfLiteralType(t)));
+            types.push(...inferNamedTypesFromProperties(usage));
 
-            if (usage.properties && hasCalls(usage.properties.get("then" as __String))) {
-                const paramType = getParameterTypeFromCalls(0, usage.properties.get("then" as __String)!.calls!, /*isRestParameter*/ false)!; // TODO: GH#18217
-                const types = paramType.getCallSignatures().map(sig => sig.getReturnType());
-                types.push(checker.createPromiseType(types.length ? checker.getUnionType(types, UnionReduction.Subtype) : checker.getAnyType()));
-            }
-            else if (usage.properties && hasCalls(usage.properties.get("push" as __String))) {
-                types.push(checker.createArrayType(getParameterTypeFromCalls(0, usage.properties.get("push" as __String)!.calls!, /*isRestParameter*/ false)!));
-            }
-
-            if (usage.numberIndex) {
-                types.push(checker.createArrayType(recur(usage.numberIndex)));
-            }
-            else if (usage.properties || usage.calls || usage.constructs || usage.stringIndex) {
-                const members = createUnderscoreEscapedMap<Symbol>();
-                const callSignatures: Signature[] = [];
-                const constructSignatures: Signature[] = [];
-                let stringIndexInfo: IndexInfo | undefined;
-
-                if (usage.properties) {
-                    usage.properties.forEach((u, name) => {
-                        const symbol = checker.createSymbol(SymbolFlags.Property, name);
-                        symbol.type = recur(u);
-                        members.set(name, symbol);
-                    });
-                }
-
-                if (usage.calls) {
-                    for (const call of usage.calls) {
-                        callSignatures.push(getSignatureFromCall(call));
-                    }
-                }
-
-                if (usage.constructs) {
-                    for (const construct of usage.constructs) {
-                        constructSignatures.push(getSignatureFromCall(construct));
-                    }
-                }
-
-                if (usage.stringIndex) {
-                    stringIndexInfo = checker.createIndexInfo(recur(usage.stringIndex), /*isReadonly*/ false);
-                }
-
-                types.push(checker.createAnonymousType(/*symbol*/ undefined!, members, callSignatures, constructSignatures, stringIndexInfo, /*numberIndexInfo*/ undefined)); // TODO: GH#18217
-            }
             return types;
-
-            function recur(innerUsage: Usage): Type {
-                return unifyFromUsage(inferFromUsage(innerUsage));
-            }
         }
 
-        function getParameterTypeFromCalls(parameterIndex: number, calls: CallUsage[], isRestParameter: boolean) {
-            let types: Type[] = [];
-            if (calls) {
-                for (const call of calls) {
-                    if (call.argumentTypes.length > parameterIndex) {
-                        if (isRestParameter) {
-                            types = concatenate(types, map(call.argumentTypes.slice(parameterIndex), a => checker.getBaseTypeOfLiteralType(a)));
-                        }
-                        else {
-                            types.push(checker.getBaseTypeOfLiteralType(call.argumentTypes[parameterIndex]));
+        function inferStructuralType(usage: Usage) {
+            const members = createUnderscoreEscapedMap<Symbol>();
+            if (usage.properties) {
+                usage.properties.forEach((u, name) => {
+                    const symbol = checker.createSymbol(SymbolFlags.Property, name);
+                    symbol.type = combineFromUsage(u);
+                    members.set(name, symbol);
+                });
+            }
+            const callSignatures: Signature[] = usage.calls ? [getSignatureFromCalls(usage.calls)] : [];
+            const constructSignatures: Signature[] = usage.constructs ? [getSignatureFromCalls(usage.constructs)] : [];
+            const stringIndexInfo = usage.stringIndex && checker.createIndexInfo(combineFromUsage(usage.stringIndex), /*isReadonly*/ false);
+            return checker.createAnonymousType(/*symbol*/ undefined!, members, callSignatures, constructSignatures, stringIndexInfo, /*numberIndexInfo*/ undefined); // TODO: GH#18217
+        }
+
+        function inferNamedTypesFromProperties(usage: Usage): Type[] {
+            if (!usage.properties || !usage.properties.size) return [];
+            const types = builtins.filter(t => allPropertiesAreAssignableToUsage(t, usage));
+            if (0 < types.length && types.length < 3) {
+                return types.map(t => inferInstantiationFromUsage(t, usage));
+            }
+            return [];
+        }
+
+        function allPropertiesAreAssignableToUsage(type: Type, usage: Usage) {
+            if (!usage.properties) return false;
+            return !forEachEntry(usage.properties, (propUsage, name) => {
+                const source = checker.getTypeOfPropertyOfType(type, name as string);
+                if (!source) {
+                    return true;
+                }
+                if (propUsage.calls) {
+                    const sigs = checker.getSignaturesOfType(source, SignatureKind.Call);
+                    return !sigs.length || !checker.isTypeAssignableTo(source, getFunctionFromCalls(propUsage.calls));
+                }
+                else {
+                    return !checker.isTypeAssignableTo(source, combineFromUsage(propUsage));
+                }
+            });
+        }
+
+        /**
+         * inference is limited to
+         * 1. generic types with a single parameter
+         * 2. inference to/from calls with a single signature
+         */
+        function inferInstantiationFromUsage(type: Type, usage: Usage) {
+            if (!(getObjectFlags(type) & ObjectFlags.Reference) || !usage.properties) {
+                return type;
+            }
+            const generic = (type as TypeReference).target;
+            const singleTypeParameter = singleOrUndefined(generic.typeParameters);
+            if (!singleTypeParameter) return type;
+
+            const types: Type[] = [];
+            usage.properties.forEach((propUsage, name) => {
+                const genericPropertyType = checker.getTypeOfPropertyOfType(generic, name as string);
+                Debug.assert(!!genericPropertyType, "generic should have all the properties of its reference.");
+                types.push(...inferTypeParameters(genericPropertyType!, combineFromUsage(propUsage), singleTypeParameter));
+            });
+            return builtinConstructors[type.symbol.escapedName as string](combineTypes(types));
+        }
+
+        function inferTypeParameters(genericType: Type, usageType: Type, typeParameter: Type): readonly Type[] {
+            if (genericType === typeParameter) {
+                return [usageType];
+            }
+            else if (genericType.flags & TypeFlags.UnionOrIntersection) {
+                return flatMap((genericType as UnionOrIntersectionType).types, t => inferTypeParameters(t, usageType, typeParameter));
+            }
+            else if (getObjectFlags(genericType) & ObjectFlags.Reference && getObjectFlags(usageType) & ObjectFlags.Reference) {
+                // this is wrong because we need a reference to the targetType to, so we can check that it's also a reference
+                const genericArgs = (genericType as TypeReference).typeArguments;
+                const usageArgs = (usageType as TypeReference).typeArguments;
+                const types = [];
+                if (genericArgs && usageArgs) {
+                    for (let i = 0; i < genericArgs.length; i++) {
+                        if (usageArgs[i]) {
+                            types.push(...inferTypeParameters(genericArgs[i], usageArgs[i], typeParameter));
                         }
                     }
                 }
+                return types;
             }
-
-            if (types.length) {
-                const type = checker.getWidenedType(checker.getUnionType(types, UnionReduction.Subtype));
-                return isRestParameter ? checker.createArrayType(type) : type;
+            const genericSigs = checker.getSignaturesOfType(genericType, SignatureKind.Call);
+            const usageSigs = checker.getSignaturesOfType(usageType, SignatureKind.Call);
+            if (genericSigs.length === 1 && usageSigs.length === 1) {
+                return inferFromSignatures(genericSigs[0], usageSigs[0], typeParameter);
             }
-            return undefined;
+            return [];
         }
 
-        function getSignatureFromCall(call: CallUsage): Signature {
+        function inferFromSignatures(genericSig: Signature, usageSig: Signature, typeParameter: Type) {
+            const types = [];
+            for (let i = 0; i < genericSig.parameters.length; i++) {
+                const genericParam = genericSig.parameters[i];
+                const usageParam = usageSig.parameters[i];
+                const isRest = genericSig.declaration && isRestParameter(genericSig.declaration.parameters[i]);
+                if (!usageParam) {
+                    break;
+                }
+                let genericParamType = checker.getTypeOfSymbolAtLocation(genericParam, genericParam.valueDeclaration);
+                const elementType = isRest && checker.getElementTypeOfArrayType(genericParamType);
+                if (elementType) {
+                    genericParamType = elementType;
+                }
+                const targetType = (usageParam as SymbolLinks).type || checker.getTypeOfSymbolAtLocation(usageParam, usageParam.valueDeclaration);
+                types.push(...inferTypeParameters(genericParamType, targetType, typeParameter));
+            }
+            const genericReturn = checker.getReturnTypeOfSignature(genericSig);
+            const usageReturn = checker.getReturnTypeOfSignature(usageSig);
+            types.push(...inferTypeParameters(genericReturn, usageReturn, typeParameter));
+            return types;
+        }
+
+        function getFunctionFromCalls(calls: CallUsage[]) {
+            return checker.createAnonymousType(undefined!, createSymbolTable(), [getSignatureFromCalls(calls)], emptyArray, /*stringIndexInfo*/ undefined, /*numberIndexInfo*/ undefined);
+        }
+
+        function getSignatureFromCalls(calls: CallUsage[]): Signature {
             const parameters: Symbol[] = [];
-            for (let i = 0; i < call.argumentTypes.length; i++) {
+            const length = Math.max(...calls.map(c => c.argumentTypes.length));
+            for (let i = 0; i < length; i++) {
                 const symbol = checker.createSymbol(SymbolFlags.FunctionScopedVariable, escapeLeadingUnderscores(`arg${i}`));
-                symbol.type = checker.getWidenedType(checker.getBaseTypeOfLiteralType(call.argumentTypes[i]));
+                symbol.type = combineTypes(calls.map(call => call.argumentTypes[i] || checker.getUndefinedType()));
+                if (calls.some(call => call.argumentTypes[i] === undefined)) {
+                    symbol.flags |= SymbolFlags.Optional;
+                }
                 parameters.push(symbol);
             }
-            const returnType = unifyFromUsage(inferFromUsage(call.returnType), checker.getVoidType());
+            const returnType = combineFromUsage(combineUsages(calls.map(call => call.return_)));
             // TODO: GH#18217
-            return checker.createSignature(/*declaration*/ undefined!, /*typeParameters*/ undefined, /*thisParameter*/ undefined, parameters, returnType, /*typePredicate*/ undefined, call.argumentTypes.length, /*hasRestParameter*/ false, /*hasLiteralTypes*/ false);
+            return checker.createSignature(/*declaration*/ undefined!, /*typeParameters*/ undefined, /*thisParameter*/ undefined, parameters, returnType, /*typePredicate*/ undefined, length, /*hasRestParameter*/ false, /*hasLiteralTypes*/ false);
         }
 
         function addCandidateType(usage: Usage, type: Type | undefined) {
@@ -933,9 +1067,5 @@ namespace ts.codefix {
                 (usage.candidateThisTypes || (usage.candidateThisTypes = [])).push(type);
             }
         }
-
-        function hasCalls(usage: Usage | undefined): boolean {
-            return !!usage && !!usage.calls;
-        }
     }
 }
diff --git a/src/services/services.ts b/src/services/services.ts
index 644629ce2af..fb5c35d8f5d 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -1149,10 +1149,10 @@ namespace ts {
             useCaseSensitiveFileNames: () => useCaseSensitiveFileNames,
             getCurrentDirectory: () => currentDirectory,
             getProgram,
-            fileExists: host.fileExists && (f => host.fileExists!(f)),
-            readFile: host.readFile && ((f, encoding) => host.readFile!(f, encoding)),
-            getDocumentPositionMapper: host.getDocumentPositionMapper && ((generatedFileName, sourceFileName) => host.getDocumentPositionMapper!(generatedFileName, sourceFileName)),
-            getSourceFileLike: host.getSourceFileLike && (f => host.getSourceFileLike!(f)),
+            fileExists: maybeBind(host, host.fileExists),
+            readFile: maybeBind(host, host.readFile),
+            getDocumentPositionMapper: maybeBind(host, host.getDocumentPositionMapper),
+            getSourceFileLike: maybeBind(host, host.getSourceFileLike),
             log
         });
 
@@ -1250,6 +1250,12 @@ namespace ts {
             if (host.resolveTypeReferenceDirectives) {
                 compilerHost.resolveTypeReferenceDirectives = (...args) => host.resolveTypeReferenceDirectives!(...args);
             }
+            if (host.setResolvedProjectReferenceCallbacks) {
+                compilerHost.setResolvedProjectReferenceCallbacks = callbacks => host.setResolvedProjectReferenceCallbacks!(callbacks);
+            }
+            if (host.useSourceOfProjectReferenceRedirect) {
+                compilerHost.useSourceOfProjectReferenceRedirect = () => host.useSourceOfProjectReferenceRedirect!();
+            }
 
             const documentRegistryBucketKey = documentRegistry.getKeyForCompilationSettings(newSettings);
             const options: CreateProgramOptions = {
diff --git a/src/services/sourcemaps.ts b/src/services/sourcemaps.ts
index d07c21a9f43..6ab656b4236 100644
--- a/src/services/sourcemaps.ts
+++ b/src/services/sourcemaps.ts
@@ -70,6 +70,11 @@ namespace ts {
             if (!sourceFile) return undefined;
 
             const program = host.getProgram()!;
+            // If this is source file of project reference source (instead of redirect) there is no generated position
+            if (program.isSourceOfProjectReferenceRedirect(sourceFile.fileName)) {
+                return undefined;
+            }
+
             const options = program.getCompilerOptions();
             const outPath = options.outFile || options.out;
 
diff --git a/src/services/types.ts b/src/services/types.ts
index c44370febe3..d77007f045d 100644
--- a/src/services/types.ts
+++ b/src/services/types.ts
@@ -234,6 +234,10 @@ namespace ts {
         getDocumentPositionMapper?(generatedFileName: string, sourceFileName?: string): DocumentPositionMapper | undefined;
         /* @internal */
         getSourceFileLike?(fileName: string): SourceFileLike | undefined;
+        /* @internal */
+        setResolvedProjectReferenceCallbacks?(callbacks: ResolvedProjectReferenceCallbacks): void;
+        /* @internal */
+        useSourceOfProjectReferenceRedirect?(): boolean;
     }
 
     /* @internal */
diff --git a/src/testRunner/tsconfig.json b/src/testRunner/tsconfig.json
index 5f8b3e87ec9..14544ce0bc1 100644
--- a/src/testRunner/tsconfig.json
+++ b/src/testRunner/tsconfig.json
@@ -146,6 +146,8 @@
         "unittests/tsserver/occurences.ts",
         "unittests/tsserver/openFile.ts",
         "unittests/tsserver/projectErrors.ts",
+        "unittests/tsserver/projectReferenceCompileOnSave.ts",
+        "unittests/tsserver/projectReferenceErrors.ts",
         "unittests/tsserver/projectReferences.ts",
         "unittests/tsserver/projects.ts",
         "unittests/tsserver/refactors.ts",
diff --git a/src/testRunner/unittests/tsbuild/watchMode.ts b/src/testRunner/unittests/tsbuild/watchMode.ts
index bc5cd79f7ef..b2f2eac1582 100644
--- a/src/testRunner/unittests/tsbuild/watchMode.ts
+++ b/src/testRunner/unittests/tsbuild/watchMode.ts
@@ -2,18 +2,12 @@ namespace ts.tscWatch {
     import projectsLocation = TestFSWithWatch.tsbuildProjectsLocation;
     import getFilePathInProject = TestFSWithWatch.getTsBuildProjectFilePath;
     import getFileFromProject = TestFSWithWatch.getTsBuildProjectFile;
-    type TsBuildWatchSystem = WatchedSystem & { writtenFiles: Map<true>; };
+    type TsBuildWatchSystem = TestFSWithWatch.TestServerHostTrackingWrittenFiles;
 
     function createTsBuildWatchSystem(fileOrFolderList: readonly TestFSWithWatch.FileOrFolderOrSymLink[], params?: TestFSWithWatch.TestServerHostCreationParameters) {
-        const host = createWatchedSystem(fileOrFolderList, params) as TsBuildWatchSystem;
-        const originalWriteFile = host.writeFile;
-        host.writtenFiles = createMap<true>();
-        host.writeFile = (fileName, content) => {
-            originalWriteFile.call(host, fileName, content);
-            const path = host.toFullPath(fileName);
-            host.writtenFiles.set(path, true);
-        };
-        return host;
+        return TestFSWithWatch.changeToHostTrackingWrittenFiles(
+            createWatchedSystem(fileOrFolderList, params)
+        );
     }
 
     export function createSolutionBuilder(system: WatchedSystem, rootNames: readonly string[], defaultOptions?: BuildOptions) {
@@ -710,8 +704,8 @@ let x: string = 10;`);
                     const coreIndexDts = projectFileName(SubProject.core, "index.d.ts");
                     const coreAnotherModuleDts = projectFileName(SubProject.core, "anotherModule.d.ts");
                     const logicIndexDts = projectFileName(SubProject.logic, "index.d.ts");
-                    const expectedWatchedFiles = () => [core[0], logic[0], ...tests, libFile].map(f => f.path).concat([coreIndexDts, coreAnotherModuleDts, logicIndexDts].map(f => f.toLowerCase()));
                     const expectedWatchedDirectoriesRecursive = projectSystem.getTypeRootsFromLocation(projectPath(SubProject.tests));
+                    const expectedProjectFiles = () => [libFile, ...tests, ...logic.slice(1), ...core.slice(1, core.length - 1)].map(f => f.path);
                     const expectedProgramFiles = () => [tests[1].path, libFile.path, coreIndexDts, coreAnotherModuleDts, logicIndexDts];
 
                     function createSolutionAndWatchMode() {
@@ -723,12 +717,19 @@ let x: string = 10;`);
                     }
 
                     function verifyWatches(host: TsBuildWatchSystem, withTsserver?: boolean) {
-                        verifyWatchesOfProject(host, withTsserver ? expectedWatchedFiles().filter(f => f !== tests[1].path.toLowerCase()) : expectedWatchedFiles(), expectedWatchedDirectoriesRecursive);
+                        verifyWatchesOfProject(
+                            host,
+                            withTsserver ?
+                                [...core.slice(0, core.length - 1), ...logic, tests[0], libFile].map(f => f.path.toLowerCase()) :
+                                [core[0], logic[0], ...tests, libFile].map(f => f.path).concat([coreIndexDts, coreAnotherModuleDts, logicIndexDts].map(f => f.toLowerCase())),
+                            expectedWatchedDirectoriesRecursive
+                        );
                     }
 
                     function verifyScenario(
                         edit: (host: TsBuildWatchSystem, solutionBuilder: SolutionBuilder<EmitAndSemanticDiagnosticsBuilderProgram>) => void,
-                        expectedFilesAfterEdit: () => readonly string[]
+                        expectedProgramFilesAfterEdit: () => readonly string[],
+                        expectedProjectFilesAfterEdit: () => readonly string[]
                     ) {
                         it("with tsc-watch", () => {
                             const { host, solutionBuilder, watch } = createSolutionAndWatchMode();
@@ -737,7 +738,7 @@ let x: string = 10;`);
 
                             host.checkTimeoutQueueLengthAndRun(1);
                             checkOutputErrorsIncremental(host, emptyArray);
-                            checkProgramActualFiles(watch(), expectedFilesAfterEdit());
+                            checkProgramActualFiles(watch(), expectedProgramFilesAfterEdit());
 
                         });
 
@@ -747,7 +748,7 @@ let x: string = 10;`);
                             edit(host, solutionBuilder);
 
                             host.checkTimeoutQueueLengthAndRun(2);
-                            checkProjectActualFiles(service, tests[0].path, [tests[0].path, ...expectedFilesAfterEdit()]);
+                            checkProjectActualFiles(service, tests[0].path, expectedProjectFilesAfterEdit());
                         });
                     }
 
@@ -777,7 +778,7 @@ function foo() {
 
                             // not ideal, but currently because of d.ts but no new file is written
                             // There will be timeout queued even though file contents are same
-                        }, expectedProgramFiles);
+                        }, expectedProgramFiles, expectedProjectFiles);
                     });
 
                     describe("non local edit in ts file, rebuilds in watch compilation", () => {
@@ -787,7 +788,7 @@ export function gfoo() {
 }`);
                             solutionBuilder.invalidateProject(logic[0].path.toLowerCase() as ResolvedConfigFilePath);
                             solutionBuilder.buildNextInvalidatedProject();
-                        }, expectedProgramFiles);
+                        }, expectedProgramFiles, expectedProjectFiles);
                     });
 
                     describe("change in project reference config file builds correctly", () => {
@@ -798,7 +799,7 @@ export function gfoo() {
                             }));
                             solutionBuilder.invalidateProject(logic[0].path.toLowerCase() as ResolvedConfigFilePath, ConfigFileProgramReloadLevel.Full);
                             solutionBuilder.buildNextInvalidatedProject();
-                        }, () => [tests[1].path, libFile.path, coreIndexDts, coreAnotherModuleDts, projectFilePath(SubProject.logic, "decls/index.d.ts")]);
+                        }, () => [tests[1].path, libFile.path, coreIndexDts, coreAnotherModuleDts, projectFilePath(SubProject.logic, "decls/index.d.ts")], expectedProjectFiles);
                     });
                 });
 
@@ -888,7 +889,9 @@ export function gfoo() {
                         const aDts = dtsFile(multiFolder ? "a/index" : "a"), bDts = dtsFile(multiFolder ? "b/index" : "b");
                         const expectedFiles = [jsFile(multiFolder ? "a/index" : "a"), aDts, jsFile(multiFolder ? "b/index" : "b"), bDts, jsFile(multiFolder ? "c/index" : "c")];
                         const expectedProgramFiles = [cTs.path, libFile.path, aDts, refs.path, bDts];
+                        const expectedProjectFiles = [cTs.path, libFile.path, aTs.path, refs.path, bTs.path];
                         const expectedWatchedFiles = expectedProgramFiles.concat(cTsconfig.path, bTsconfig.path, aTsconfig.path).map(s => s.toLowerCase());
+                        const expectedProjectWatchedFiles = expectedProjectFiles.concat(cTsconfig.path, bTsconfig.path, aTsconfig.path).map(s => s.toLowerCase());
                         const expectedWatchedDirectories = multiFolder ? [
                             getProjectPath(project).toLowerCase() // watches for directories created for resolution of b
                         ] : emptyArray;
@@ -926,22 +929,29 @@ export function gfoo() {
                         }
 
                         function verifyProject(host: TsBuildWatchSystem, service: projectSystem.TestProjectService, orphanInfos?: readonly string[]) {
-                            verifyServerState(host, service, expectedProgramFiles, expectedWatchedFiles, expectedWatchedDirectoriesRecursive, orphanInfos);
+                            verifyServerState({ host, service, expectedProjectFiles, expectedProjectWatchedFiles, expectedWatchedDirectoriesRecursive, orphanInfos });
                         }
 
-                        function verifyServerState(
-                            host: TsBuildWatchSystem,
-                            service: projectSystem.TestProjectService,
-                            expectedProgramFiles: readonly string[],
-                            expectedWatchedFiles: readonly string[],
-                            expectedWatchedDirectoriesRecursive: readonly string[],
-                            orphanInfos?: readonly string[]) {
-                            checkProjectActualFiles(service, cTsconfig.path, expectedProgramFiles.concat(cTsconfig.path));
-                            const watchedFiles = expectedWatchedFiles.filter(f => f !== cTs.path.toLowerCase());
-                            if (orphanInfos) {
+                        interface VerifyServerState {
+                            host: TsBuildWatchSystem;
+                            service: projectSystem.TestProjectService;
+                            expectedProjectFiles: readonly string[];
+                            expectedProjectWatchedFiles: readonly string[];
+                            expectedWatchedDirectoriesRecursive: readonly string[];
+                            orphanInfos?: readonly string[];
+                        }
+                        function verifyServerState({ host, service, expectedProjectFiles, expectedProjectWatchedFiles, expectedWatchedDirectoriesRecursive, orphanInfos }: VerifyServerState) {
+                            checkProjectActualFiles(service, cTsconfig.path, expectedProjectFiles.concat(cTsconfig.path));
+                            const watchedFiles = expectedProjectWatchedFiles.filter(f => f !== cTs.path.toLowerCase());
+                            const actualOrphan = arrayFrom(mapDefinedIterator(
+                                service.filenameToScriptInfo.values(),
+                                v => v.containingProjects.length === 0 ? v.fileName : undefined
+                            ));
+                            assert.equal(actualOrphan.length, orphanInfos ? orphanInfos.length : 0, `Orphans found: ${JSON.stringify(actualOrphan, /*replacer*/ undefined, " ")}`);
+                            if (orphanInfos && orphanInfos.length) {
                                 for (const orphan of orphanInfos) {
                                     const info = service.getScriptInfoForPath(orphan as Path);
-                                    assert.isDefined(info);
+                                    assert.isDefined(info, `${orphan} expected to be present. Actual: ${JSON.stringify(actualOrphan, /*replacer*/ undefined, " ")}`);
                                     assert.equal(info!.containingProjects.length, 0);
                                     watchedFiles.push(orphan);
                                 }
@@ -949,16 +959,20 @@ export function gfoo() {
                             verifyWatchesOfProject(host, watchedFiles, expectedWatchedDirectoriesRecursive, expectedWatchedDirectories);
                         }
 
-                        function verifyScenario(
-                            edit: (host: TsBuildWatchSystem, solutionBuilder: SolutionBuilder<EmitAndSemanticDiagnosticsBuilderProgram>) => void,
-                            expectedEditErrors: readonly string[],
-                            expectedProgramFiles: readonly string[],
-                            expectedWatchedFiles: readonly string[],
-                            expectedWatchedDirectoriesRecursive: readonly string[],
-                            dependencies: readonly [string, readonly string[]][],
-                            revert?: (host: TsBuildWatchSystem) => void,
-                            orphanInfosAfterEdit?: readonly string[],
-                            orphanInfosAfterRevert?: readonly string[]) {
+                        interface VerifyScenario {
+                            edit: (host: TsBuildWatchSystem, solutionBuilder: SolutionBuilder<EmitAndSemanticDiagnosticsBuilderProgram>) => void;
+                            expectedEditErrors: readonly string[];
+                            expectedProgramFiles: readonly string[];
+                            expectedProjectFiles: readonly string[];
+                            expectedWatchedFiles: readonly string[];
+                            expectedProjectWatchedFiles: readonly string[];
+                            expectedWatchedDirectoriesRecursive: readonly string[];
+                            dependencies: readonly [string, readonly string[]][];
+                            revert?: (host: TsBuildWatchSystem) => void;
+                            orphanInfosAfterEdit?: readonly string[];
+                            orphanInfosAfterRevert?: readonly string[];
+                        }
+                        function verifyScenario({ edit, expectedEditErrors, expectedProgramFiles, expectedProjectFiles, expectedWatchedFiles, expectedProjectWatchedFiles, expectedWatchedDirectoriesRecursive, dependencies, revert, orphanInfosAfterEdit, orphanInfosAfterRevert }: VerifyScenario) {
                             it("with tsc-watch", () => {
                                 const { host, solutionBuilder, watch } = createSolutionAndWatchMode();
 
@@ -985,7 +999,7 @@ export function gfoo() {
                                 edit(host, solutionBuilder);
 
                                 host.checkTimeoutQueueLengthAndRun(2);
-                                verifyServerState(host, service, expectedProgramFiles, expectedWatchedFiles, expectedWatchedDirectoriesRecursive, orphanInfosAfterEdit);
+                                verifyServerState({ host, service, expectedProjectFiles, expectedProjectWatchedFiles, expectedWatchedDirectoriesRecursive, orphanInfos: orphanInfosAfterEdit });
 
                                 if (revert) {
                                     revert(host);
@@ -1010,20 +1024,21 @@ export function gfoo() {
                         });
 
                         describe("non local edit updates the program and watch correctly", () => {
-                            verifyScenario(
-                                (host, solutionBuilder) => {
+                            verifyScenario({
+                                edit: (host, solutionBuilder) => {
                                     // edit
-                                    host.writeFile(bTs.path, `${bTs.content}
-export function gfoo() {
-}`);
-                                    solutionBuilder.invalidateProject(bTsconfig.path.toLowerCase() as ResolvedConfigFilePath);
+                                    host.writeFile(bTs.path, `${bTs.content}\nexport function gfoo() {\n}`);
+                                    solutionBuilder.invalidateProject((bTsconfig.path.toLowerCase() as ResolvedConfigFilePath));
                                     solutionBuilder.buildNextInvalidatedProject();
                                 },
-                                emptyArray,
+                                expectedEditErrors: emptyArray,
                                 expectedProgramFiles,
+                                expectedProjectFiles,
                                 expectedWatchedFiles,
+                                expectedProjectWatchedFiles,
                                 expectedWatchedDirectoriesRecursive,
-                                defaultDependencies);
+                                dependencies: defaultDependencies
+                            });
                         });
 
                         describe("edit on config file", () => {
@@ -1032,30 +1047,32 @@ export function gfoo() {
                                 path: getFilePathInProject(project, "nrefs/a.d.ts"),
                                 content: refs.content
                             };
-                            verifyScenario(
-                                host => {
+                            verifyScenario({
+                                edit: host => {
                                     const cTsConfigJson = JSON.parse(cTsconfig.content);
                                     host.ensureFileOrFolder(nrefs);
                                     cTsConfigJson.compilerOptions.paths = { "@ref/*": nrefsPath };
                                     host.writeFile(cTsconfig.path, JSON.stringify(cTsConfigJson));
                                 },
-                                emptyArray,
-                                expectedProgramFiles.map(nrefReplacer),
-                                expectedWatchedFiles.map(nrefReplacer),
-                                expectedWatchedDirectoriesRecursive.map(nrefReplacer),
-                                [
+                                expectedEditErrors: emptyArray,
+                                expectedProgramFiles: expectedProgramFiles.map(nrefReplacer),
+                                expectedProjectFiles: expectedProjectFiles.map(nrefReplacer),
+                                expectedWatchedFiles: expectedWatchedFiles.map(nrefReplacer),
+                                expectedProjectWatchedFiles: expectedProjectWatchedFiles.map(nrefReplacer),
+                                expectedWatchedDirectoriesRecursive: expectedWatchedDirectoriesRecursive.map(nrefReplacer),
+                                dependencies: [
                                     [aDts, [aDts]],
                                     [bDts, [bDts, aDts]],
                                     [nrefs.path, [nrefs.path]],
                                     [cTs.path, [cTs.path, nrefs.path, bDts]]
                                 ],
                                 // revert the update
-                                host => host.writeFile(cTsconfig.path, cTsconfig.content),
+                                revert: host => host.writeFile(cTsconfig.path, cTsconfig.content),
                                 // AfterEdit:: Extra watched files on server since the script infos arent deleted till next file open
-                                [refs.path.toLowerCase()],
+                                orphanInfosAfterEdit: [refs.path.toLowerCase()],
                                 // AfterRevert:: Extra watched files on server since the script infos arent deleted till next file open
-                                [nrefs.path.toLowerCase()]
-                            );
+                                orphanInfosAfterRevert: [nrefs.path.toLowerCase()]
+                            });
                         });
 
                         describe("edit in referenced config file", () => {
@@ -1064,82 +1081,84 @@ export function gfoo() {
                                 content: "export declare class A {}"
                             };
                             const expectedProgramFiles = [cTs.path, bDts, nrefs.path, refs.path, libFile.path];
+                            const expectedProjectFiles = [cTs.path, bTs.path, nrefs.path, refs.path, libFile.path];
                             const [, ...expectedWatchedDirectoriesRecursiveWithoutA] = expectedWatchedDirectoriesRecursive; // Not looking in a folder for resolution in multi folder scenario
-                            verifyScenario(
-                                host => {
+                            verifyScenario({
+                                edit: host => {
                                     const bTsConfigJson = JSON.parse(bTsconfig.content);
                                     host.ensureFileOrFolder(nrefs);
                                     bTsConfigJson.compilerOptions.paths = { "@ref/*": nrefsPath };
                                     host.writeFile(bTsconfig.path, JSON.stringify(bTsConfigJson));
                                 },
-                                emptyArray,
+                                expectedEditErrors: emptyArray,
                                 expectedProgramFiles,
-                                expectedProgramFiles.concat(cTsconfig.path, bTsconfig.path, aTsconfig.path).map(s => s.toLowerCase()),
-                                (multiFolder ? expectedWatchedDirectoriesRecursiveWithoutA : expectedWatchedDirectoriesRecursive).concat(getFilePathInProject(project, "nrefs").toLowerCase()),
-                                [
+                                expectedProjectFiles,
+                                expectedWatchedFiles: expectedProgramFiles.concat(cTsconfig.path, bTsconfig.path, aTsconfig.path).map(s => s.toLowerCase()),
+                                expectedProjectWatchedFiles: expectedProjectFiles.concat(cTsconfig.path, bTsconfig.path, aTsconfig.path).map(s => s.toLowerCase()),
+                                expectedWatchedDirectoriesRecursive: (multiFolder ? expectedWatchedDirectoriesRecursiveWithoutA : expectedWatchedDirectoriesRecursive).concat(getFilePathInProject(project, "nrefs").toLowerCase()),
+                                dependencies: [
                                     [nrefs.path, [nrefs.path]],
                                     [bDts, [bDts, nrefs.path]],
                                     [refs.path, [refs.path]],
                                     [cTs.path, [cTs.path, refs.path, bDts]],
                                 ],
                                 // revert the update
-                                host => host.writeFile(bTsconfig.path, bTsconfig.content),
+                                revert: host => host.writeFile(bTsconfig.path, bTsconfig.content),
                                 // AfterEdit:: Extra watched files on server since the script infos arent deleted till next file open
-                                [aDts.toLowerCase()],
+                                orphanInfosAfterEdit: [aTs.path.toLowerCase()],
                                 // AfterRevert:: Extra watched files on server since the script infos arent deleted till next file open
-                                [nrefs.path.toLowerCase()]
-                            );
+                                orphanInfosAfterRevert: [nrefs.path.toLowerCase()]
+                            });
                         });
 
                         describe("deleting referenced config file", () => {
                             const expectedProgramFiles = [cTs.path, bTs.path, refs.path, libFile.path];
+                            const expectedWatchedFiles = expectedProgramFiles.concat(cTsconfig.path, bTsconfig.path).map(s => s.toLowerCase());
                             const [, ...expectedWatchedDirectoriesRecursiveWithoutA] = expectedWatchedDirectoriesRecursive; // Not looking in a folder for resolution in multi folder scenario
                             // Resolutions should change now
                             // Should map to b.ts instead with options from our own config
-                            verifyScenario(
-                                host => host.deleteFile(bTsconfig.path),
-                                [
+                            verifyScenario({
+                                edit: host => host.deleteFile(bTsconfig.path),
+                                expectedEditErrors: [
                                     `${multiFolder ? "c/tsconfig.json" : "tsconfig.c.json"}(9,21): error TS6053: File '/user/username/projects/transitiveReferences/${multiFolder ? "b" : "tsconfig.b.json"}' not found.\n`
                                 ],
                                 expectedProgramFiles,
-                                expectedProgramFiles.concat(cTsconfig.path, bTsconfig.path).map(s => s.toLowerCase()),
-                                multiFolder ? expectedWatchedDirectoriesRecursiveWithoutA : expectedWatchedDirectoriesRecursive,
-                                [
+                                expectedProjectFiles: expectedProgramFiles,
+                                expectedWatchedFiles,
+                                expectedProjectWatchedFiles: expectedWatchedFiles,
+                                expectedWatchedDirectoriesRecursive: multiFolder ? expectedWatchedDirectoriesRecursiveWithoutA : expectedWatchedDirectoriesRecursive,
+                                dependencies: [
                                     [bTs.path, [bTs.path, refs.path]],
                                     [refs.path, [refs.path]],
                                     [cTs.path, [cTs.path, refs.path, bTs.path]],
                                 ],
                                 // revert the update
-                                host => host.writeFile(bTsconfig.path, bTsconfig.content),
+                                revert: host => host.writeFile(bTsconfig.path, bTsconfig.content),
                                 // AfterEdit:: Extra watched files on server since the script infos arent deleted till next file open
-                                [bDts.toLowerCase(), aDts.toLowerCase(), aTsconfig.path.toLowerCase()],
-                                // AfterRevert:: Extra watched files on server since the script infos arent deleted till next file open
-                                [bTs.path.toLowerCase()]
-                            );
+                                orphanInfosAfterEdit: [aTs.path.toLowerCase(), aTsconfig.path.toLowerCase()],
+                            });
                         });
 
                         describe("deleting transitively referenced config file", () => {
-                            verifyScenario(
-                                host => host.deleteFile(aTsconfig.path),
-                                [
+                            verifyScenario({
+                                edit: host => host.deleteFile(aTsconfig.path),
+                                expectedEditErrors: [
                                     `${multiFolder ? "b/tsconfig.json" : "tsconfig.b.json"}(10,21): error TS6053: File '/user/username/projects/transitiveReferences/${multiFolder ? "a" : "tsconfig.a.json"}' not found.\n`
                                 ],
-                                expectedProgramFiles.map(s => s.replace(aDts, aTs.path)),
-                                expectedWatchedFiles.map(s => s.replace(aDts.toLowerCase(), aTs.path.toLocaleLowerCase())),
+                                expectedProgramFiles: expectedProgramFiles.map(s => s.replace(aDts, aTs.path)),
+                                expectedProjectFiles,
+                                expectedWatchedFiles: expectedWatchedFiles.map(s => s.replace(aDts.toLowerCase(), aTs.path.toLocaleLowerCase())),
+                                expectedProjectWatchedFiles,
                                 expectedWatchedDirectoriesRecursive,
-                                [
+                                dependencies: [
                                     [aTs.path, [aTs.path]],
                                     [bDts, [bDts, aTs.path]],
                                     [refs.path, [refs.path]],
                                     [cTs.path, [cTs.path, refs.path, bDts]],
                                 ],
                                 // revert the update
-                                host => host.writeFile(aTsconfig.path, aTsconfig.content),
-                                // AfterEdit:: Extra watched files on server since the script infos arent deleted till next file open
-                                [aDts.toLowerCase()],
-                                // AfterRevert:: Extra watched files on server since the script infos arent deleted till next file open
-                                [aTs.path.toLowerCase()]
-                            );
+                                revert: host => host.writeFile(aTsconfig.path, aTsconfig.content),
+                            });
                         });
                     }
 
diff --git a/src/testRunner/unittests/tsserver/declarationFileMaps.ts b/src/testRunner/unittests/tsserver/declarationFileMaps.ts
index d1c64fe46ce..a6f217385d9 100644
--- a/src/testRunner/unittests/tsserver/declarationFileMaps.ts
+++ b/src/testRunner/unittests/tsserver/declarationFileMaps.ts
@@ -179,7 +179,7 @@ namespace ts.projectSystem {
         }
 
         function verifyUserTsConfigProject(session: TestSession) {
-            checkProjectActualFiles(session.getProjectService().configuredProjects.get(userTsconfig.path)!, [userTs.path, aDts.path, userTsconfig.path]);
+            checkProjectActualFiles(session.getProjectService().configuredProjects.get(userTsconfig.path)!, [userTs.path, aTs.path, userTsconfig.path]);
         }
 
         it("goToDefinition", () => {
@@ -450,6 +450,13 @@ namespace ts.projectSystem {
                         name: "function f(): void",
                     },
                     references: [
+                        makeReferenceEntry({
+                            file: aTs,
+                            text: "f",
+                            options: { index: 1 },
+                            contextText: "function f() {}",
+                            isDefinition: true
+                        }),
                         {
                             fileName: bTs.path,
                             isDefinition: false,
@@ -457,13 +464,6 @@ namespace ts.projectSystem {
                             isWriteAccess: false,
                             textSpan: { start: 0, length: 1 },
                         },
-                        makeReferenceEntry({
-                            file: aTs,
-                            text: "f",
-                            options: { index: 1 },
-                            contextText: "function f() {}",
-                            isDefinition: true
-                        })
                     ],
                 }
             ]);
diff --git a/src/testRunner/unittests/tsserver/events/projectLoading.ts b/src/testRunner/unittests/tsserver/events/projectLoading.ts
index cb22f41ff25..5f4bf1a52c9 100644
--- a/src/testRunner/unittests/tsserver/events/projectLoading.ts
+++ b/src/testRunner/unittests/tsserver/events/projectLoading.ts
@@ -73,44 +73,64 @@ namespace ts.projectSystem {
                 verifyEvent(project, `Change in config file detected`);
             });
 
-            it("when opening original location project", () => {
-                const aDTs: File = {
-                    path: `${projectRoot}/a/a.d.ts`,
-                    content: `export declare class A {
+            describe("when opening original location project", () => {
+                it("with project references", () => {
+                    verify();
+                });
+
+                it("when disableSourceOfProjectReferenceRedirect is true", () => {
+                    verify(/*disableSourceOfProjectReferenceRedirect*/ true);
+                });
+
+                function verify(disableSourceOfProjectReferenceRedirect?: true) {
+                    const aDTs: File = {
+                        path: `${projectRoot}/a/a.d.ts`,
+                        content: `export declare class A {
 }
 //# sourceMappingURL=a.d.ts.map
 `
-                };
-                const aDTsMap: File = {
-                    path: `${projectRoot}/a/a.d.ts.map`,
-                    content: `{"version":3,"file":"a.d.ts","sourceRoot":"","sources":["./a.ts"],"names":[],"mappings":"AAAA,qBAAa,CAAC;CAAI"}`
-                };
-                const bTs: File = {
-                    path: bTsPath,
-                    content: `import {A} from "../a/a"; new A();`
-                };
-                const configB: File = {
-                    path: configBPath,
-                    content: JSON.stringify({
-                        references: [{ path: "../a" }]
-                    })
-                };
+                    };
+                    const aDTsMap: File = {
+                        path: `${projectRoot}/a/a.d.ts.map`,
+                        content: `{"version":3,"file":"a.d.ts","sourceRoot":"","sources":["./a.ts"],"names":[],"mappings":"AAAA,qBAAa,CAAC;CAAI"}`
+                    };
+                    const bTs: File = {
+                        path: bTsPath,
+                        content: `import {A} from "../a/a"; new A();`
+                    };
+                    const configB: File = {
+                        path: configBPath,
+                        content: JSON.stringify({
+                            ...(disableSourceOfProjectReferenceRedirect && {
+                                compilerOptions: {
+                                    disableSourceOfProjectReferenceRedirect
+                                }
+                            }),
+                            references: [{ path: "../a" }]
+                        })
+                    };
 
-                const { service, session, verifyEventWithOpenTs, verifyEvent } = createSessionToVerifyEvent(files.concat(aDTs, aDTsMap, bTs, configB));
-                verifyEventWithOpenTs(bTs, configB.path, 1);
+                    const { service, session, verifyEventWithOpenTs, verifyEvent } = createSessionToVerifyEvent(files.concat(aDTs, aDTsMap, bTs, configB));
+                    verifyEventWithOpenTs(bTs, configB.path, 1);
 
-                session.executeCommandSeq<protocol.ReferencesRequest>({
-                    command: protocol.CommandTypes.References,
-                    arguments: {
-                        file: bTs.path,
-                        ...protocolLocationFromSubstring(bTs.content, "A()")
-                    }
-                });
+                    session.executeCommandSeq<protocol.ReferencesRequest>({
+                        command: protocol.CommandTypes.References,
+                        arguments: {
+                            file: bTs.path,
+                            ...protocolLocationFromSubstring(bTs.content, "A()")
+                        }
+                    });
 
-                checkNumberOfProjects(service, { configuredProjects: 2 });
-                const project = service.configuredProjects.get(configA.path)!;
-                assert.isDefined(project);
-                verifyEvent(project, `Creating project for original file: ${aTs.path} for location: ${aDTs.path}`);
+                    checkNumberOfProjects(service, { configuredProjects: 2 });
+                    const project = service.configuredProjects.get(configA.path)!;
+                    assert.isDefined(project);
+                    verifyEvent(
+                        project,
+                        disableSourceOfProjectReferenceRedirect ?
+                            `Creating project for original file: ${aTs.path} for location: ${aDTs.path}` :
+                            `Creating project for original file: ${aTs.path}`
+                    );
+                }
             });
 
             describe("with external projects and config files ", () => {
diff --git a/src/testRunner/unittests/tsserver/helpers.ts b/src/testRunner/unittests/tsserver/helpers.ts
index 1fb35935906..a8c79d0b603 100644
--- a/src/testRunner/unittests/tsserver/helpers.ts
+++ b/src/testRunner/unittests/tsserver/helpers.ts
@@ -491,8 +491,8 @@ namespace ts.projectSystem {
         checkArray("Open files", arrayFrom(projectService.openFiles.keys(), path => projectService.getScriptInfoForPath(path as Path)!.fileName), expectedFiles.map(file => file.path));
     }
 
-    export function checkScriptInfos(projectService: server.ProjectService, expectedFiles: readonly string[]) {
-        checkArray("ScriptInfos files", arrayFrom(projectService.filenameToScriptInfo.values(), info => info.fileName), expectedFiles);
+    export function checkScriptInfos(projectService: server.ProjectService, expectedFiles: readonly string[], additionInfo?: string) {
+        checkArray(`ScriptInfos files: ${additionInfo || ""}`, arrayFrom(projectService.filenameToScriptInfo.values(), info => info.fileName), expectedFiles);
     }
 
     export function protocolLocationFromSubstring(str: string, substring: string): protocol.Location {
@@ -501,7 +501,7 @@ namespace ts.projectSystem {
         return protocolToLocation(str)(start);
     }
 
-    function protocolToLocation(text: string): (pos: number) => protocol.Location {
+    export function protocolToLocation(text: string): (pos: number) => protocol.Location {
         const lineStarts = computeLineStarts(text);
         return pos => {
             const x = computeLineAndCharacterOfPosition(lineStarts, pos);
diff --git a/src/testRunner/unittests/tsserver/projectReferenceCompileOnSave.ts b/src/testRunner/unittests/tsserver/projectReferenceCompileOnSave.ts
new file mode 100644
index 00000000000..9602ef6360e
--- /dev/null
+++ b/src/testRunner/unittests/tsserver/projectReferenceCompileOnSave.ts
@@ -0,0 +1,410 @@
+namespace ts.projectSystem {
+    describe("unittests:: tsserver:: with project references and compile on save", () => {
+        const projectLocation = "/user/username/projects/myproject";
+        const dependecyLocation = `${projectLocation}/dependency`;
+        const usageLocation = `${projectLocation}/usage`;
+        const dependencyTs: File = {
+            path: `${dependecyLocation}/fns.ts`,
+            content: `export function fn1() { }
+export function fn2() { }
+`
+        };
+        const dependencyConfig: File = {
+            path: `${dependecyLocation}/tsconfig.json`,
+            content: JSON.stringify({
+                compilerOptions: { composite: true, declarationDir: "../decls" },
+                compileOnSave: true
+            })
+        };
+        const usageTs: File = {
+            path: `${usageLocation}/usage.ts`,
+            content: `import {
+    fn1,
+    fn2,
+} from '../decls/fns'
+fn1();
+fn2();
+`
+        };
+        const usageConfig: File = {
+            path: `${usageLocation}/tsconfig.json`,
+            content: JSON.stringify({
+                compileOnSave: true,
+                references: [{ path: "../dependency" }]
+            })
+        };
+
+        interface VerifySingleScenarioWorker extends VerifySingleScenario {
+            withProject: boolean;
+        }
+        function verifySingleScenarioWorker({
+            withProject, scenario, openFiles, requestArgs, change, expectedResult
+        }: VerifySingleScenarioWorker) {
+            it(scenario, () => {
+                const host = TestFSWithWatch.changeToHostTrackingWrittenFiles(
+                    createServerHost([dependencyTs, dependencyConfig, usageTs, usageConfig, libFile])
+                );
+                const session = createSession(host);
+                openFilesForSession(openFiles(), session);
+                const reqArgs = requestArgs();
+                const {
+                    expectedAffected,
+                    expectedEmit: { expectedEmitSuccess, expectedFiles },
+                    expectedEmitOutput
+                } = expectedResult(withProject);
+
+                if (change) {
+                    session.executeCommandSeq<protocol.CompileOnSaveAffectedFileListRequest>({
+                        command: protocol.CommandTypes.CompileOnSaveAffectedFileList,
+                        arguments: { file: dependencyTs.path }
+                    });
+                    const { file, insertString } = change();
+                    if (session.getProjectService().openFiles.has(file.path)) {
+                        const toLocation = protocolToLocation(file.content);
+                        const location = toLocation(file.content.length);
+                        session.executeCommandSeq<protocol.ChangeRequest>({
+                            command: protocol.CommandTypes.Change,
+                            arguments: {
+                                file: file.path,
+                                ...location,
+                                endLine: location.line,
+                                endOffset: location.offset,
+                                insertString
+                            }
+                        });
+                    }
+                    else {
+                        host.writeFile(file.path, `${file.content}${insertString}`);
+                    }
+                    host.writtenFiles.clear();
+                }
+
+                const args = withProject ? reqArgs : { file: reqArgs.file };
+                // Verify CompileOnSaveAffectedFileList
+                const actualAffectedFiles = session.executeCommandSeq<protocol.CompileOnSaveAffectedFileListRequest>({
+                    command: protocol.CommandTypes.CompileOnSaveAffectedFileList,
+                    arguments: args
+                }).response as protocol.CompileOnSaveAffectedFileListSingleProject[];
+                assert.deepEqual(actualAffectedFiles, expectedAffected, "Affected files");
+
+                // Verify CompileOnSaveEmit
+                const actualEmit = session.executeCommandSeq<protocol.CompileOnSaveEmitFileRequest>({
+                    command: protocol.CommandTypes.CompileOnSaveEmitFile,
+                    arguments: args
+                }).response;
+                assert.deepEqual(actualEmit, expectedEmitSuccess, "Emit files");
+                assert.equal(host.writtenFiles.size, expectedFiles.length);
+                for (const file of expectedFiles) {
+                    assert.equal(host.readFile(file.path), file.content, `Expected to write ${file.path}`);
+                    assert.isTrue(host.writtenFiles.has(file.path), `${file.path} is newly written`);
+                }
+
+                // Verify EmitOutput
+                const { exportedModulesFromDeclarationEmit: _1, ...actualEmitOutput } = session.executeCommandSeq<protocol.EmitOutputRequest>({
+                    command: protocol.CommandTypes.EmitOutput,
+                    arguments: args
+                }).response as EmitOutput;
+                assert.deepEqual(actualEmitOutput, expectedEmitOutput, "Emit output");
+            });
+        }
+
+        interface VerifySingleScenario {
+            scenario: string;
+            openFiles: () => readonly File[];
+            requestArgs: () => protocol.FileRequestArgs;
+            skipWithoutProject?: boolean;
+            change?: () => SingleScenarioChange;
+            expectedResult: GetSingleScenarioResult;
+        }
+        function verifySingleScenario(scenario: VerifySingleScenario) {
+            if (!scenario.skipWithoutProject) {
+                describe("without specifying project file", () => {
+                    verifySingleScenarioWorker({
+                        withProject: false,
+                        ...scenario
+                    });
+                });
+            }
+            describe("with specifying project file", () => {
+                verifySingleScenarioWorker({
+                    withProject: true,
+                    ...scenario
+                });
+            });
+        }
+
+        interface SingleScenarioExpectedEmit {
+            expectedEmitSuccess: boolean;
+            expectedFiles: readonly File[];
+        }
+        interface SingleScenarioResult {
+            expectedAffected: protocol.CompileOnSaveAffectedFileListSingleProject[];
+            expectedEmit: SingleScenarioExpectedEmit;
+            expectedEmitOutput: EmitOutput;
+        }
+        type GetSingleScenarioResult = (withProject: boolean) => SingleScenarioResult;
+        interface SingleScenarioChange {
+            file: File;
+            insertString: string;
+        }
+        interface ScenarioDetails {
+            scenarioName: string;
+            requestArgs: () => protocol.FileRequestArgs;
+            skipWithoutProject?: boolean;
+            initial: GetSingleScenarioResult;
+            localChangeToDependency: GetSingleScenarioResult;
+            localChangeToUsage: GetSingleScenarioResult;
+            changeToDependency: GetSingleScenarioResult;
+            changeToUsage: GetSingleScenarioResult;
+        }
+        interface VerifyScenario {
+            openFiles: () => readonly File[];
+            scenarios: readonly ScenarioDetails[];
+        }
+
+        const localChange = "function fn3() { }";
+        const change = `export ${localChange}`;
+        const changeJs = `function fn3() { }
+exports.fn3 = fn3;`;
+        const changeDts = "export declare function fn3(): void;";
+        function verifyScenario({ openFiles, scenarios }: VerifyScenario) {
+            for (const {
+                scenarioName, requestArgs, skipWithoutProject, initial,
+                localChangeToDependency, localChangeToUsage,
+                changeToDependency, changeToUsage
+            } of scenarios) {
+                describe(scenarioName, () => {
+                    verifySingleScenario({
+                        scenario: "with initial file open",
+                        openFiles,
+                        requestArgs,
+                        skipWithoutProject,
+                        expectedResult: initial
+                    });
+
+                    verifySingleScenario({
+                        scenario: "with local change to dependency",
+                        openFiles,
+                        requestArgs,
+                        skipWithoutProject,
+                        change: () => ({ file: dependencyTs, insertString: localChange }),
+                        expectedResult: localChangeToDependency
+                    });
+
+                    verifySingleScenario({
+                        scenario: "with local change to usage",
+                        openFiles,
+                        requestArgs,
+                        skipWithoutProject,
+                        change: () => ({ file: usageTs, insertString: localChange }),
+                        expectedResult: localChangeToUsage
+                    });
+
+                    verifySingleScenario({
+                        scenario: "with change to dependency",
+                        openFiles,
+                        requestArgs,
+                        skipWithoutProject,
+                        change: () => ({ file: dependencyTs, insertString: change }),
+                        expectedResult: changeToDependency
+                    });
+
+                    verifySingleScenario({
+                        scenario: "with change to usage",
+                        openFiles,
+                        requestArgs,
+                        skipWithoutProject,
+                        change: () => ({ file: usageTs, insertString: change }),
+                        expectedResult: changeToUsage
+                    });
+                });
+            }
+        }
+
+        function expectedAffectedFiles(config: File, fileNames: File[]): protocol.CompileOnSaveAffectedFileListSingleProject {
+            return {
+                projectFileName: config.path,
+                fileNames: fileNames.map(f => f.path),
+                projectUsesOutFile: false
+            };
+        }
+
+        function expectedUsageEmit(appendJsText?: string): SingleScenarioExpectedEmit {
+            const appendJs = appendJsText ? `${appendJsText}
+` : "";
+            return {
+                expectedEmitSuccess: true,
+                expectedFiles: [{
+                    path: `${usageLocation}/usage.js`,
+                    content: `"use strict";
+exports.__esModule = true;
+var fns_1 = require("../decls/fns");
+fns_1.fn1();
+fns_1.fn2();
+${appendJs}`
+                }]
+            };
+        }
+
+        function expectedEmitOutput({ expectedFiles }: SingleScenarioExpectedEmit): EmitOutput {
+            return {
+                outputFiles: expectedFiles.map(({ path, content }) => ({
+                    name: path,
+                    text: content,
+                    writeByteOrderMark: false
+                })),
+                emitSkipped: false
+            };
+        }
+
+        function expectedUsageEmitOutput(appendJsText?: string): EmitOutput {
+            return expectedEmitOutput(expectedUsageEmit(appendJsText));
+        }
+
+        function noEmit(): SingleScenarioExpectedEmit {
+            return {
+                expectedEmitSuccess: false,
+                expectedFiles: emptyArray
+            };
+        }
+
+        function noEmitOutput(): EmitOutput {
+            return {
+                emitSkipped: true,
+                outputFiles: []
+            };
+        }
+
+        function expectedDependencyEmit(appendJsText?: string, appendDtsText?: string): SingleScenarioExpectedEmit {
+            const appendJs = appendJsText ? `${appendJsText}
+` : "";
+            const appendDts = appendDtsText ? `${appendDtsText}
+` : "";
+            return {
+                expectedEmitSuccess: true,
+                expectedFiles: [
+                    {
+                        path: `${dependecyLocation}/fns.js`,
+                        content: `"use strict";
+exports.__esModule = true;
+function fn1() { }
+exports.fn1 = fn1;
+function fn2() { }
+exports.fn2 = fn2;
+${appendJs}`
+                    },
+                    {
+                        path: `${projectLocation}/decls/fns.d.ts`,
+                        content: `export declare function fn1(): void;
+export declare function fn2(): void;
+${appendDts}`
+                    }
+                ]
+            };
+        }
+
+        function expectedDependencyEmitOutput(appendJsText?: string, appendDtsText?: string): EmitOutput {
+            return expectedEmitOutput(expectedDependencyEmit(appendJsText, appendDtsText));
+        }
+
+        function scenarioDetailsOfUsage(isDependencyOpen?: boolean): ScenarioDetails[] {
+            return [
+                {
+                    scenarioName: "Of usageTs",
+                    requestArgs: () => ({ file: usageTs.path, projectFileName: usageConfig.path }),
+                    initial: () => initialUsageTs(),
+                    // no change to usage so same as initial only usage file
+                    localChangeToDependency: () => initialUsageTs(),
+                    localChangeToUsage: () => initialUsageTs(localChange),
+                    changeToDependency: () => initialUsageTs(),
+                    changeToUsage: () => initialUsageTs(changeJs)
+                },
+                {
+                    scenarioName: "Of dependencyTs in usage project",
+                    requestArgs: () => ({ file: dependencyTs.path, projectFileName: usageConfig.path }),
+                    skipWithoutProject: !!isDependencyOpen,
+                    initial: () => initialDependencyTs(),
+                    localChangeToDependency: () => initialDependencyTs(/*noUsageFiles*/ true),
+                    localChangeToUsage: () => initialDependencyTs(/*noUsageFiles*/ true),
+                    changeToDependency: () => initialDependencyTs(),
+                    changeToUsage: () => initialDependencyTs(/*noUsageFiles*/ true)
+                }
+            ];
+
+            function initialUsageTs(jsText?: string) {
+                return {
+                    expectedAffected: [
+                        expectedAffectedFiles(usageConfig, [usageTs])
+                    ],
+                    expectedEmit: expectedUsageEmit(jsText),
+                    expectedEmitOutput: expectedUsageEmitOutput(jsText)
+                };
+            }
+
+            function initialDependencyTs(noUsageFiles?: true) {
+                return {
+                    expectedAffected: [
+                        expectedAffectedFiles(usageConfig, noUsageFiles ? [] : [usageTs])
+                    ],
+                    expectedEmit: noEmit(),
+                    expectedEmitOutput: noEmitOutput()
+                };
+            }
+        }
+
+        function scenarioDetailsOfDependencyWhenOpen(): ScenarioDetails {
+            return {
+                scenarioName: "Of dependencyTs",
+                requestArgs: () => ({ file: dependencyTs.path, projectFileName: dependencyConfig.path }),
+                initial,
+                localChangeToDependency: withProject => ({
+                    expectedAffected: withProject ?
+                        [
+                            expectedAffectedFiles(dependencyConfig, [dependencyTs])
+                        ] :
+                        [
+                            expectedAffectedFiles(usageConfig, []),
+                            expectedAffectedFiles(dependencyConfig, [dependencyTs])
+                        ],
+                    expectedEmit: expectedDependencyEmit(localChange),
+                    expectedEmitOutput: expectedDependencyEmitOutput(localChange)
+                }),
+                localChangeToUsage: withProject => initial(withProject, /*noUsageFiles*/ true),
+                changeToDependency: withProject => initial(withProject, /*noUsageFiles*/ undefined, changeJs, changeDts),
+                changeToUsage: withProject => initial(withProject, /*noUsageFiles*/ true)
+            };
+
+            function initial(withProject: boolean, noUsageFiles?: true, appendJs?: string, appendDts?: string): SingleScenarioResult {
+                return {
+                    expectedAffected: withProject ?
+                        [
+                            expectedAffectedFiles(dependencyConfig, [dependencyTs])
+                        ] :
+                        [
+                            expectedAffectedFiles(usageConfig, noUsageFiles ? [] : [usageTs]),
+                            expectedAffectedFiles(dependencyConfig, [dependencyTs])
+                        ],
+                    expectedEmit: expectedDependencyEmit(appendJs, appendDts),
+                    expectedEmitOutput: expectedDependencyEmitOutput(appendJs, appendDts)
+                };
+            }
+        }
+
+        describe("when dependency project is not open", () => {
+            verifyScenario({
+                openFiles: () => [usageTs],
+                scenarios: scenarioDetailsOfUsage()
+            });
+        });
+
+        describe("when the depedency file is open", () => {
+            verifyScenario({
+                openFiles: () => [usageTs, dependencyTs],
+                scenarios: [
+                    ...scenarioDetailsOfUsage(/*isDependencyOpen*/ true),
+                    scenarioDetailsOfDependencyWhenOpen(),
+                ]
+            });
+        });
+    });
+}
diff --git a/src/testRunner/unittests/tsserver/projectReferenceErrors.ts b/src/testRunner/unittests/tsserver/projectReferenceErrors.ts
new file mode 100644
index 00000000000..a3ec4848615
--- /dev/null
+++ b/src/testRunner/unittests/tsserver/projectReferenceErrors.ts
@@ -0,0 +1,430 @@
+namespace ts.projectSystem {
+    describe("unittests:: tsserver:: with project references and error reporting", () => {
+        const projectLocation = "/user/username/projects/myproject";
+        const dependecyLocation = `${projectLocation}/dependency`;
+        const usageLocation = `${projectLocation}/usage`;
+
+        interface CheckErrorsInFile {
+            session: TestSession;
+            host: TestServerHost;
+            expected: GetErrDiagnostics;
+            expectedSequenceId?: number;
+        }
+        function checkErrorsInFile({ session, host, expected: { file, syntax, semantic, suggestion }, expectedSequenceId }: CheckErrorsInFile) {
+            host.checkTimeoutQueueLengthAndRun(1);
+            checkErrorMessage(session, "syntaxDiag", { file: file.path, diagnostics: syntax });
+            session.clearMessages();
+
+            host.runQueuedImmediateCallbacks(1);
+            checkErrorMessage(session, "semanticDiag", { file: file.path, diagnostics: semantic });
+            session.clearMessages();
+
+            host.runQueuedImmediateCallbacks(1);
+            checkErrorMessage(session, "suggestionDiag", { file: file.path, diagnostics: suggestion });
+            if (expectedSequenceId !== undefined) {
+                checkCompleteEvent(session, 2, expectedSequenceId);
+            }
+            session.clearMessages();
+        }
+
+        interface CheckAllErrors {
+            session: TestSession;
+            host: TestServerHost;
+            expected: readonly GetErrDiagnostics[];
+            expectedSequenceId: number;
+        }
+        function checkAllErrors({ session, host, expected, expectedSequenceId }: CheckAllErrors) {
+            for (let i = 0; i < expected.length; i++) {
+                checkErrorsInFile({
+                    session,
+                    host,
+                    expected: expected[i],
+                    expectedSequenceId: i === expected.length - 1 ? expectedSequenceId : undefined
+                });
+            }
+        }
+
+        function verifyErrorsUsingGeterr({ allFiles, openFiles, expectedGetErr }: VerifyScenario) {
+            it("verifies the errors in open file", () => {
+                const host = createServerHost([...allFiles(), libFile]);
+                const session = createSession(host, { canUseEvents: true, });
+                openFilesForSession(openFiles(), session);
+
+                session.clearMessages();
+                const expectedSequenceId = session.getNextSeq();
+                const expected = expectedGetErr();
+                session.executeCommandSeq<protocol.GeterrRequest>({
+                    command: protocol.CommandTypes.Geterr,
+                    arguments: {
+                        delay: 0,
+                        files: expected.map(f => f.file.path)
+                    }
+                });
+
+                checkAllErrors({ session, host, expected, expectedSequenceId });
+            });
+        }
+
+        function verifyErrorsUsingGeterrForProject({ allFiles, openFiles, expectedGetErrForProject }: VerifyScenario) {
+            it("verifies the errors in projects", () => {
+                const host = createServerHost([...allFiles(), libFile]);
+                const session = createSession(host, { canUseEvents: true, });
+                openFilesForSession(openFiles(), session);
+
+                session.clearMessages();
+                for (const expected of expectedGetErrForProject()) {
+                    const expectedSequenceId = session.getNextSeq();
+                    session.executeCommandSeq<protocol.GeterrForProjectRequest>({
+                        command: protocol.CommandTypes.GeterrForProject,
+                        arguments: {
+                            delay: 0,
+                            file: expected.project
+                        }
+                    });
+
+                    checkAllErrors({ session, host, expected: expected.errors, expectedSequenceId });
+                }
+            });
+        }
+
+        function verifyErrorsUsingSyncMethods({ allFiles, openFiles, expectedSyncDiagnostics }: VerifyScenario) {
+            it("verifies the errors using sync commands", () => {
+                const host = createServerHost([...allFiles(), libFile]);
+                const session = createSession(host);
+                openFilesForSession(openFiles(), session);
+                for (const { file, project, syntax, semantic, suggestion } of expectedSyncDiagnostics()) {
+                    const actualSyntax = session.executeCommandSeq<protocol.SyntacticDiagnosticsSyncRequest>({
+                        command: protocol.CommandTypes.SyntacticDiagnosticsSync,
+                        arguments: {
+                            file: file.path,
+                            projectFileName: project
+                        }
+                    }).response as protocol.Diagnostic[];
+                    assert.deepEqual(actualSyntax, syntax, `Syntax diagnostics for file: ${file.path}, project: ${project}`);
+                    const actualSemantic = session.executeCommandSeq<protocol.SemanticDiagnosticsSyncRequest>({
+                        command: protocol.CommandTypes.SemanticDiagnosticsSync,
+                        arguments: {
+                            file: file.path,
+                            projectFileName: project
+                        }
+                    }).response as protocol.Diagnostic[];
+                    assert.deepEqual(actualSemantic, semantic, `Semantic diagnostics for file: ${file.path}, project: ${project}`);
+                    const actualSuggestion = session.executeCommandSeq<protocol.SuggestionDiagnosticsSyncRequest>({
+                        command: protocol.CommandTypes.SuggestionDiagnosticsSync,
+                        arguments: {
+                            file: file.path,
+                            projectFileName: project
+                        }
+                    }).response as protocol.Diagnostic[];
+                    assert.deepEqual(actualSuggestion, suggestion, `Suggestion diagnostics for file: ${file.path}, project: ${project}`);
+                }
+            });
+        }
+
+        function verifyConfigFileErrors({ allFiles, openFiles, expectedConfigFileDiagEvents }: VerifyScenario) {
+            it("verify config file errors", () => {
+                const host = createServerHost([...allFiles(), libFile]);
+                const { session, events } = createSessionWithEventTracking<server.ConfigFileDiagEvent>(host, server.ConfigFileDiagEvent);
+
+                for (const file of openFiles()) {
+                    session.executeCommandSeq<protocol.OpenRequest>({
+                        command: protocol.CommandTypes.Open,
+                        arguments: { file: file.path }
+                    });
+                }
+
+                assert.deepEqual(events, expectedConfigFileDiagEvents().map(data => ({
+                    eventName: server.ConfigFileDiagEvent,
+                    data
+                })));
+            });
+        }
+
+        interface GetErrDiagnostics {
+            file: File;
+            syntax: protocol.Diagnostic[];
+            semantic: protocol.Diagnostic[];
+            suggestion: protocol.Diagnostic[];
+        }
+        interface GetErrForProjectDiagnostics {
+            project: string;
+            errors: readonly GetErrDiagnostics[];
+        }
+        interface SyncDiagnostics extends GetErrDiagnostics {
+            project?: string;
+        }
+        interface VerifyScenario {
+            allFiles: () => readonly File[];
+            openFiles: () => readonly File[];
+            expectedGetErr: () => readonly GetErrDiagnostics[];
+            expectedGetErrForProject: () => readonly GetErrForProjectDiagnostics[];
+            expectedSyncDiagnostics: () => readonly SyncDiagnostics[];
+            expectedConfigFileDiagEvents: () => readonly server.ConfigFileDiagEvent["data"][];
+        }
+        function verifyScenario(scenario: VerifyScenario) {
+            verifyErrorsUsingGeterr(scenario);
+            verifyErrorsUsingGeterrForProject(scenario);
+            verifyErrorsUsingSyncMethods(scenario);
+            verifyConfigFileErrors(scenario);
+        }
+
+        function emptyDiagnostics(file: File): GetErrDiagnostics {
+            return {
+                file,
+                syntax: emptyArray,
+                semantic: emptyArray,
+                suggestion: emptyArray
+            };
+        }
+
+        function syncDiagnostics(diagnostics: GetErrDiagnostics, project: string): SyncDiagnostics {
+            return { project, ...diagnostics };
+        }
+
+        interface VerifyUsageAndDependency {
+            allFiles: readonly [File, File, File, File]; // dependencyTs, dependencyConfig, usageTs, usageConfig
+            usageDiagnostics(): GetErrDiagnostics;
+            dependencyDiagnostics(): GetErrDiagnostics;
+
+        }
+        function verifyUsageAndDependency({ allFiles, usageDiagnostics, dependencyDiagnostics }: VerifyUsageAndDependency) {
+            const [dependencyTs, dependencyConfig, usageTs, usageConfig] = allFiles;
+            function usageProjectDiagnostics(): GetErrForProjectDiagnostics {
+                return {
+                    project: usageTs.path,
+                    errors: [
+                        usageDiagnostics(),
+                        emptyDiagnostics(dependencyTs)
+                    ]
+                };
+            }
+
+            function dependencyProjectDiagnostics(): GetErrForProjectDiagnostics {
+                return {
+                    project: dependencyTs.path,
+                    errors: [
+                        dependencyDiagnostics()
+                    ]
+                };
+            }
+
+            function usageConfigDiag(): server.ConfigFileDiagEvent["data"] {
+                return {
+                    triggerFile: usageTs.path,
+                    configFileName: usageConfig.path,
+                    diagnostics: emptyArray
+                };
+            }
+
+            function dependencyConfigDiag(): server.ConfigFileDiagEvent["data"] {
+                return {
+                    triggerFile: dependencyTs.path,
+                    configFileName: dependencyConfig.path,
+                    diagnostics: emptyArray
+                };
+            }
+
+            describe("when dependency project is not open", () => {
+                verifyScenario({
+                    allFiles: () => allFiles,
+                    openFiles: () => [usageTs],
+                    expectedGetErr: () => [
+                        usageDiagnostics()
+                    ],
+                    expectedGetErrForProject: () => [
+                        usageProjectDiagnostics(),
+                        {
+                            project: dependencyTs.path,
+                            errors: [
+                                emptyDiagnostics(dependencyTs),
+                                usageDiagnostics()
+                            ]
+                        }
+                    ],
+                    expectedSyncDiagnostics: () => [
+                        // Without project
+                        usageDiagnostics(),
+                        emptyDiagnostics(dependencyTs),
+                        // With project
+                        syncDiagnostics(usageDiagnostics(), usageConfig.path),
+                        syncDiagnostics(emptyDiagnostics(dependencyTs), usageConfig.path),
+                    ],
+                    expectedConfigFileDiagEvents: () => [
+                        usageConfigDiag()
+                    ],
+                });
+            });
+
+            describe("when the depedency file is open", () => {
+                verifyScenario({
+                    allFiles: () => allFiles,
+                    openFiles: () => [usageTs, dependencyTs],
+                    expectedGetErr: () => [
+                        usageDiagnostics(),
+                        dependencyDiagnostics(),
+                    ],
+                    expectedGetErrForProject: () => [
+                        usageProjectDiagnostics(),
+                        dependencyProjectDiagnostics()
+                    ],
+                    expectedSyncDiagnostics: () => [
+                        // Without project
+                        usageDiagnostics(),
+                        dependencyDiagnostics(),
+                        // With project
+                        syncDiagnostics(usageDiagnostics(), usageConfig.path),
+                        syncDiagnostics(emptyDiagnostics(dependencyTs), usageConfig.path),
+                        syncDiagnostics(dependencyDiagnostics(), dependencyConfig.path),
+                    ],
+                    expectedConfigFileDiagEvents: () => [
+                        usageConfigDiag(),
+                        dependencyConfigDiag()
+                    ],
+                });
+            });
+        }
+
+        describe("with module scenario", () => {
+            const dependencyTs: File = {
+                path: `${dependecyLocation}/fns.ts`,
+                content: `export function fn1() { }
+export function fn2() { }
+// Introduce error for fnErr import in main
+// export function fnErr() { }
+// Error in dependency ts file
+export let x: string = 10;`
+            };
+            const dependencyConfig: File = {
+                path: `${dependecyLocation}/tsconfig.json`,
+                content: JSON.stringify({ compilerOptions: { composite: true, declarationDir: "../decls" } })
+            };
+            const usageTs: File = {
+                path: `${usageLocation}/usage.ts`,
+                content: `import {
+    fn1,
+    fn2,
+    fnErr
+} from '../decls/fns'
+fn1();
+fn2();
+fnErr();
+`
+            };
+            const usageConfig: File = {
+                path: `${usageLocation}/tsconfig.json`,
+                content: JSON.stringify({
+                    compilerOptions: { composite: true },
+                    references: [{ path: "../dependency" }]
+                })
+            };
+            function usageDiagnostics(): GetErrDiagnostics {
+                return {
+                    file: usageTs,
+                    syntax: emptyArray,
+                    semantic: [
+                        createDiagnostic(
+                            { line: 4, offset: 5 },
+                            { line: 4, offset: 10 },
+                            Diagnostics.Module_0_has_no_exported_member_1,
+                            [`"../dependency/fns"`, "fnErr"],
+                            "error",
+                        )
+                    ],
+                    suggestion: emptyArray
+                };
+            }
+
+            function dependencyDiagnostics(): GetErrDiagnostics {
+                return {
+                    file: dependencyTs,
+                    syntax: emptyArray,
+                    semantic: [
+                        createDiagnostic(
+                            { line: 6, offset: 12 },
+                            { line: 6, offset: 13 },
+                            Diagnostics.Type_0_is_not_assignable_to_type_1,
+                            ["10", "string"],
+                            "error",
+                        )
+                    ],
+                    suggestion: emptyArray
+                };
+            }
+
+            verifyUsageAndDependency({
+                allFiles: [dependencyTs, dependencyConfig, usageTs, usageConfig],
+                usageDiagnostics,
+                dependencyDiagnostics
+            });
+        });
+
+        describe("with non module --out", () => {
+            const dependencyTs: File = {
+                path: `${dependecyLocation}/fns.ts`,
+                content: `function fn1() { }
+function fn2() { }
+// Introduce error for fnErr import in main
+// function fnErr() { }
+// Error in dependency ts file
+let x: string = 10;`
+            };
+            const dependencyConfig: File = {
+                path: `${dependecyLocation}/tsconfig.json`,
+                content: JSON.stringify({ compilerOptions: { composite: true, outFile: "../dependency.js" } })
+            };
+            const usageTs: File = {
+                path: `${usageLocation}/usage.ts`,
+                content: `fn1();
+fn2();
+fnErr();
+`
+            };
+            const usageConfig: File = {
+                path: `${usageLocation}/tsconfig.json`,
+                content: JSON.stringify({
+                    compilerOptions: { composite: true, outFile: "../usage.js" },
+                    references: [{ path: "../dependency" }]
+                })
+            };
+            function usageDiagnostics(): GetErrDiagnostics {
+                return {
+                    file: usageTs,
+                    syntax: emptyArray,
+                    semantic: [
+                        createDiagnostic(
+                            { line: 3, offset: 1 },
+                            { line: 3, offset: 6 },
+                            Diagnostics.Cannot_find_name_0,
+                            ["fnErr"],
+                            "error",
+                        )
+                    ],
+                    suggestion: emptyArray
+                };
+            }
+
+            function dependencyDiagnostics(): GetErrDiagnostics {
+                return {
+                    file: dependencyTs,
+                    syntax: emptyArray,
+                    semantic: [
+                        createDiagnostic(
+                            { line: 6, offset: 5 },
+                            { line: 6, offset: 6 },
+                            Diagnostics.Type_0_is_not_assignable_to_type_1,
+                            ["10", "string"],
+                            "error",
+                        )
+                    ],
+                    suggestion: emptyArray
+                };
+            }
+
+            verifyUsageAndDependency({
+                allFiles: [dependencyTs, dependencyConfig, usageTs, usageConfig],
+                usageDiagnostics,
+                dependencyDiagnostics
+            });
+        });
+    });
+}
diff --git a/src/testRunner/unittests/tsserver/projectReferences.ts b/src/testRunner/unittests/tsserver/projectReferences.ts
index 7db9d755b26..2e886e2169e 100644
--- a/src/testRunner/unittests/tsserver/projectReferences.ts
+++ b/src/testRunner/unittests/tsserver/projectReferences.ts
@@ -85,8 +85,8 @@ namespace ts.projectSystem {
                 });
                 const { file: _, ...renameTextOfMyConstInLib } = locationOfMyConstInLib;
                 assert.deepEqual(response.locs, [
-                    { file: myConstFile, locs: [{ start: myConstStart, end: myConstEnd }] },
-                    { file: locationOfMyConstInLib.file, locs: [renameTextOfMyConstInLib] }
+                    { file: locationOfMyConstInLib.file, locs: [renameTextOfMyConstInLib] },
+                    { file: myConstFile, locs: [{ start: myConstStart, end: myConstEnd }] }
                 ]);
             });
         });
@@ -105,6 +105,7 @@ export function fn4() { }
 export function fn5() { }
 `
             };
+            const dependencyTsPath = dependencyTs.path.toLowerCase();
             const dependencyConfig: File = {
                 path: `${dependecyLocation}/tsconfig.json`,
                 content: JSON.stringify({ compilerOptions: { composite: true, declarationMap: true, declarationDir: "../decls" } })
@@ -150,59 +151,17 @@ fn5();
 
             const files = [dependencyTs, dependencyConfig, mainTs, mainConfig, libFile, randomFile, randomConfig];
 
-            function verifyScriptInfos(session: TestSession, host: TestServerHost, openInfos: readonly string[], closedInfos: readonly string[], otherWatchedFiles: readonly string[]) {
-                checkScriptInfos(session.getProjectService(), openInfos.concat(closedInfos));
-                checkWatchedFiles(host, closedInfos.concat(otherWatchedFiles).map(f => f.toLowerCase()));
+            function verifyScriptInfos(session: TestSession, host: TestServerHost, openInfos: readonly string[], closedInfos: readonly string[], otherWatchedFiles: readonly string[], additionalInfo: string) {
+                checkScriptInfos(session.getProjectService(), openInfos.concat(closedInfos), additionalInfo);
+                checkWatchedFiles(host, closedInfos.concat(otherWatchedFiles).map(f => f.toLowerCase()), additionalInfo);
             }
 
-            function verifyInfosWithRandom(session: TestSession, host: TestServerHost, openInfos: readonly string[], closedInfos: readonly string[], otherWatchedFiles: readonly string[]) {
-                verifyScriptInfos(session, host, openInfos.concat(randomFile.path), closedInfos, otherWatchedFiles.concat(randomConfig.path));
+            function verifyInfosWithRandom(session: TestSession, host: TestServerHost, openInfos: readonly string[], closedInfos: readonly string[], otherWatchedFiles: readonly string[], reqName: string) {
+                verifyScriptInfos(session, host, openInfos.concat(randomFile.path), closedInfos, otherWatchedFiles.concat(randomConfig.path), reqName);
             }
 
             function verifyOnlyRandomInfos(session: TestSession, host: TestServerHost) {
-                verifyScriptInfos(session, host, [randomFile.path], [libFile.path], [randomConfig.path]);
-            }
-
-            // Returns request and expected Response, expected response when no map file
-            interface SessionAction<Req = protocol.Request, Response = {}> {
-                reqName: string;
-                request: Partial<Req>;
-                expectedResponse: Response;
-                expectedResponseNoMap?: Response;
-                expectedResponseNoDts?: Response;
-            }
-            function gotoDefintinionFromMainTs(fn: number): SessionAction<protocol.DefinitionAndBoundSpanRequest, protocol.DefinitionInfoAndBoundSpan> {
-                const textSpan = usageSpan(fn);
-                const definition: protocol.FileSpan = { file: dependencyTs.path, ...declarationSpan(fn) };
-                const declareSpaceLength = "declare ".length;
-                return {
-                    reqName: "goToDef",
-                    request: {
-                        command: protocol.CommandTypes.DefinitionAndBoundSpan,
-                        arguments: { file: mainTs.path, ...textSpan.start }
-                    },
-                    expectedResponse: {
-                        // To dependency
-                        definitions: [definition],
-                        textSpan
-                    },
-                    expectedResponseNoMap: {
-                        // To the dts
-                        definitions: [{
-                            file: dtsPath,
-                            start: { line: fn, offset: definition.start.offset + declareSpaceLength },
-                            end: { line: fn, offset: definition.end.offset + declareSpaceLength },
-                            contextStart: { line: fn, offset: 1 },
-                            contextEnd: { line: fn, offset: 37 }
-                        }],
-                        textSpan
-                    },
-                    expectedResponseNoDts: {
-                        // To import declaration
-                        definitions: [{ file: mainTs.path, ...importSpan(fn) }],
-                        textSpan
-                    }
-                };
+                verifyScriptInfos(session, host, [randomFile.path], [libFile.path], [randomConfig.path], "Random");
             }
 
             function declarationSpan(fn: number): protocol.TextSpanWithContext {
@@ -225,7 +184,91 @@ fn5();
                 return { start: { line: fn + 8, offset: 1 }, end: { line: fn + 8, offset: 4 } };
             }
 
-            function renameFromDependencyTs(fn: number): SessionAction<protocol.RenameRequest, protocol.RenameResponseBody> {
+            function goToDefFromMainTs(fn: number): Action<protocol.DefinitionAndBoundSpanRequest, protocol.DefinitionInfoAndBoundSpan> {
+                const textSpan = usageSpan(fn);
+                const definition: protocol.FileSpan = { file: dependencyTs.path, ...declarationSpan(fn) };
+                return {
+                    reqName: "goToDef",
+                    request: {
+                        command: protocol.CommandTypes.DefinitionAndBoundSpan,
+                        arguments: { file: mainTs.path, ...textSpan.start }
+                    },
+                    expectedResponse: {
+                        // To dependency
+                        definitions: [definition],
+                        textSpan
+                    }
+                };
+            }
+
+            function goToDefFromMainTsWithNoMap(fn: number): Action<protocol.DefinitionAndBoundSpanRequest, protocol.DefinitionInfoAndBoundSpan> {
+                const textSpan = usageSpan(fn);
+                const definition = declarationSpan(fn);
+                const declareSpaceLength = "declare ".length;
+                return {
+                    reqName: "goToDef",
+                    request: {
+                        command: protocol.CommandTypes.DefinitionAndBoundSpan,
+                        arguments: { file: mainTs.path, ...textSpan.start }
+                    },
+                    expectedResponse: {
+                        // To the dts
+                        definitions: [{
+                            file: dtsPath,
+                            start: { line: fn, offset: definition.start.offset + declareSpaceLength },
+                            end: { line: fn, offset: definition.end.offset + declareSpaceLength },
+                            contextStart: { line: fn, offset: 1 },
+                            contextEnd: { line: fn, offset: 37 }
+                        }],
+                        textSpan
+                    }
+                };
+            }
+
+            function goToDefFromMainTsWithNoDts(fn: number): Action<protocol.DefinitionAndBoundSpanRequest, protocol.DefinitionInfoAndBoundSpan> {
+                const textSpan = usageSpan(fn);
+                return {
+                    reqName: "goToDef",
+                    request: {
+                        command: protocol.CommandTypes.DefinitionAndBoundSpan,
+                        arguments: { file: mainTs.path, ...textSpan.start }
+                    },
+                    expectedResponse: {
+                        // To import declaration
+                        definitions: [{ file: mainTs.path, ...importSpan(fn) }],
+                        textSpan
+                    }
+                };
+            }
+
+            function goToDefFromMainTsWithDependencyChange(fn: number): Action<protocol.DefinitionAndBoundSpanRequest, protocol.DefinitionInfoAndBoundSpan> {
+                const textSpan = usageSpan(fn);
+                return {
+                    reqName: "goToDef",
+                    request: {
+                        command: protocol.CommandTypes.DefinitionAndBoundSpan,
+                        arguments: { file: mainTs.path, ...textSpan.start }
+                    },
+                    expectedResponse: {
+                        // Definition on fn + 1 line
+                        definitions: [{ file: dependencyTs.path, ...declarationSpan(fn + 1) }],
+                        textSpan
+                    }
+                };
+            }
+
+            function goToDefFromMainTsProjectInfoVerifier(withRefs: boolean): ProjectInfoVerifier {
+                return {
+                    openFile: mainTs,
+                    openFileLastLine: 14,
+                    configFile: mainConfig,
+                    expectedProjectActualFiles: withRefs ?
+                        [mainTs.path, libFile.path, mainConfig.path, dependencyTs.path] :
+                        [mainTs.path, libFile.path, mainConfig.path, dtsPath]
+                };
+            }
+
+            function renameFromDependencyTs(fn: number): Action<protocol.RenameRequest, protocol.RenameResponseBody> {
                 const defSpan = declarationSpan(fn);
                 const { contextStart: _, contextEnd: _1, ...triggerSpan } = defSpan;
                 return {
@@ -251,7 +294,32 @@ fn5();
                 };
             }
 
-            function renameFromDependencyTsWithBothProjectsOpen(fn: number): SessionAction<protocol.RenameRequest, protocol.RenameResponseBody> {
+            function renameFromDependencyTsWithDependencyChange(fn: number): Action<protocol.RenameRequest, protocol.RenameResponseBody> {
+                const { expectedResponse: { info, locs }, ...rest } = renameFromDependencyTs(fn + 1);
+
+                return {
+                    ...rest,
+                    expectedResponse: {
+                        info: {
+                            ...info as protocol.RenameInfoSuccess,
+                            displayName: `fn${fn}`,
+                            fullDisplayName: `"${dependecyLocation}/FnS".fn${fn}`,
+                        },
+                        locs
+                    }
+                };
+            }
+
+            function renameFromDependencyTsProjectInfoVerifier(): ProjectInfoVerifier {
+                return {
+                    openFile: dependencyTs,
+                    openFileLastLine: 6,
+                    configFile: dependencyConfig,
+                    expectedProjectActualFiles: [dependencyTs.path, libFile.path, dependencyConfig.path]
+                };
+            }
+
+            function renameFromDependencyTsWithBothProjectsOpen(fn: number): Action<protocol.RenameRequest, protocol.RenameResponseBody> {
                 const { reqName, request, expectedResponse } = renameFromDependencyTs(fn);
                 const { info, locs } = expectedResponse;
                 return {
@@ -269,442 +337,846 @@ fn5();
                                 ]
                             }
                         ]
-                    },
-                    // Only dependency result
-                    expectedResponseNoMap: expectedResponse,
-                    expectedResponseNoDts: expectedResponse
+                    }
                 };
             }
 
-            // Returns request and expected Response
-            type SessionActionGetter<Req = protocol.Request, Response = {}> = (fn: number) => SessionAction<Req, Response>;
-            // Open File, expectedProjectActualFiles, actionGetter, openFileLastLine
-            interface DocumentPositionMapperVerifier {
-                openFile: File;
-                expectedProjectActualFiles: readonly string[];
-                actionGetter: SessionActionGetter;
-                openFileLastLine: number;
+            function renameFromDependencyTsWithBothProjectsOpenWithDependencyChange(fn: number): Action<protocol.RenameRequest, protocol.RenameResponseBody> {
+                const { reqName, request, expectedResponse, } = renameFromDependencyTsWithDependencyChange(fn);
+                const { info, locs } = expectedResponse;
+                return {
+                    reqName,
+                    request,
+                    expectedResponse: {
+                        info,
+                        locs: [
+                            locs[0],
+                            {
+                                file: mainTs.path,
+                                locs: [
+                                    importSpan(fn),
+                                    usageSpan(fn)
+                                ]
+                            }
+                        ]
+                    }
+                };
             }
-            function verifyDocumentPositionMapperUpdates(
-                mainScenario: string,
-                verifier: readonly DocumentPositionMapperVerifier[],
-                closedInfos: readonly string[],
-                withRefs: boolean) {
 
-                const openFiles = verifier.map(v => v.openFile);
-                const expectedProjectActualFiles = verifier.map(v => v.expectedProjectActualFiles);
-                const openFileLastLines = verifier.map(v => v.openFileLastLine);
+            function removePath(array: readonly string[], ...delPaths: string[]) {
+                return array.filter(a => {
+                    const aLower = a.toLowerCase();
+                    return delPaths.every(dPath => dPath !== aLower);
+                });
+            }
 
-                const configFiles = openFiles.map(openFile => `${getDirectoryPath(openFile.path)}/tsconfig.json`);
-                const openInfos = openFiles.map(f => f.path);
-                // When usage and dependency are used, dependency config is part of closedInfo so ignore
-                const otherWatchedFiles = withRefs && verifier.length > 1 ? [configFiles[0]] : configFiles;
-                function openTsFile(onHostCreate?: (host: TestServerHost) => void) {
-                    const host = createHost(files, [mainConfig.path]);
-                    if (!withRefs) {
-                        // Erase project reference
-                        host.writeFile(mainConfig.path, JSON.stringify({
-                            compilerOptions: { composite: true, declarationMap: true }
-                        }));
-                    }
-                    if (onHostCreate) {
-                        onHostCreate(host);
-                    }
-                    const session = createSession(host);
-                    openFilesForSession([...openFiles, randomFile], session);
-                    return { host, session };
+            interface Action<Req = protocol.Request, Response = {}> {
+                reqName: string;
+                request: Partial<Req>;
+                expectedResponse: Response;
+            }
+            interface ActionInfo<Req = protocol.Request, Response = {}> {
+                action: (fn: number) => Action<Req, Response>;
+                closedInfos: readonly string[];
+                otherWatchedFiles: readonly string[];
+                expectsDts: boolean;
+                expectsMap: boolean;
+                freshMapInfo?: boolean;
+                freshDocumentMapper?: boolean;
+                skipDtsMapCheck?: boolean;
+            }
+            type ActionKey = keyof ActionInfoVerifier;
+            type ActionInfoGetterFn<Req = protocol.Request, Response = {}> = () => ActionInfo<Req, Response>;
+            type ActionInfoSpreader<Req = protocol.Request, Response = {}> = [
+                ActionKey, // Key to get initial value and pass this value to spread function
+                (actionInfo: ActionInfo<Req, Response>) => Partial<ActionInfo<Req, Response>>
+            ];
+            type ActionInfoGetter<Req = protocol.Request, Response = {}> = ActionInfoGetterFn<Req, Response> | ActionKey | ActionInfoSpreader<Req, Response>;
+            interface ProjectInfoVerifier {
+                openFile: File;
+                openFileLastLine: number;
+                configFile: File;
+                expectedProjectActualFiles: readonly string[];
+            }
+            interface ActionInfoVerifier<Req = protocol.Request, Response = {}> {
+                main: ActionInfoGetter<Req, Response>;
+                change: ActionInfoGetter<Req, Response>;
+                dtsChange: ActionInfoGetter<Req, Response>;
+                mapChange: ActionInfoGetter<Req, Response>;
+                noMap: ActionInfoGetter<Req, Response>;
+                mapFileCreated: ActionInfoGetter<Req, Response>;
+                mapFileDeleted: ActionInfoGetter<Req, Response>;
+                noDts: ActionInfoGetter<Req, Response>;
+                dtsFileCreated: ActionInfoGetter<Req, Response>;
+                dtsFileDeleted: ActionInfoGetter<Req, Response>;
+                dependencyChange: ActionInfoGetter<Req, Response>;
+                noBuild: ActionInfoGetter<Req, Response>;
+            }
+            interface DocumentPositionMapperVerifier<Req = protocol.Request, Response = {}> extends ProjectInfoVerifier, ActionInfoVerifier<Req, Response> {
+            }
+
+            interface VerifierAndWithRefs {
+                withRefs: boolean;
+                disableSourceOfProjectReferenceRedirect?: true;
+                verifier: (withRefs: boolean) => readonly DocumentPositionMapperVerifier[];
+            }
+
+            function openFiles(verifiers: readonly DocumentPositionMapperVerifier[]) {
+                return verifiers.map(v => v.openFile);
+            }
+            interface OpenTsFile extends VerifierAndWithRefs {
+                onHostCreate?: (host: TestServerHost) => void;
+            }
+            function openTsFile({ withRefs, disableSourceOfProjectReferenceRedirect, verifier, onHostCreate }: OpenTsFile) {
+                const host = createHost(files, [mainConfig.path]);
+                if (!withRefs) {
+                    // Erase project reference
+                    host.writeFile(mainConfig.path, JSON.stringify({
+                        compilerOptions: { composite: true, declarationMap: true }
+                    }));
                 }
-
-                function checkProject(session: TestSession, noDts?: true) {
-                    const service = session.getProjectService();
-                    checkNumberOfProjects(service, { configuredProjects: 1 + verifier.length });
-                    configFiles.forEach((configFile, index) => {
-                        checkProjectActualFiles(
-                            service.configuredProjects.get(configFile)!,
-                            noDts ?
-                                expectedProjectActualFiles[index].filter(f => f.toLowerCase() !== dtsPath) :
-                                expectedProjectActualFiles[index]
-                        );
-                    });
+                else if (disableSourceOfProjectReferenceRedirect) {
+                    // Erase project reference
+                    host.writeFile(mainConfig.path, JSON.stringify({
+                        compilerOptions: {
+                            composite: true,
+                            declarationMap: true,
+                            disableSourceOfProjectReferenceRedirect: !!disableSourceOfProjectReferenceRedirect
+                        },
+                        references: [{ path: "../dependency" }]
+                    }));
                 }
-
-                function verifyInfos(session: TestSession, host: TestServerHost) {
-                    verifyInfosWithRandom(session, host, openInfos, closedInfos, otherWatchedFiles);
+                if (onHostCreate) {
+                    onHostCreate(host);
                 }
+                const session = createSession(host);
+                const verifiers = verifier(withRefs && !disableSourceOfProjectReferenceRedirect);
+                openFilesForSession([...openFiles(verifiers), randomFile], session);
+                return { host, session, verifiers };
+            }
 
-                function verifyInfosWhenNoMapFile(session: TestSession, host: TestServerHost, dependencyTsOK?: true) {
-                    const dtsMapClosedInfo = firstDefined(closedInfos, f => f.toLowerCase() === dtsMapPath ? f : undefined);
-                    verifyInfosWithRandom(
-                        session,
-                        host,
-                        openInfos,
-                        closedInfos.filter(f => f !== dtsMapClosedInfo && (dependencyTsOK || f !== dependencyTs.path)),
-                        dtsMapClosedInfo ? otherWatchedFiles.concat(dtsMapClosedInfo) : otherWatchedFiles
+            function checkProject(session: TestSession, verifiers: readonly DocumentPositionMapperVerifier[], noDts?: true) {
+                const service = session.getProjectService();
+                checkNumberOfProjects(service, { configuredProjects: 1 + verifiers.length });
+                verifiers.forEach(({ configFile, expectedProjectActualFiles }) => {
+                    checkProjectActualFiles(
+                        service.configuredProjects.get(configFile.path.toLowerCase())!,
+                        noDts ?
+                            expectedProjectActualFiles.filter(f => f.toLowerCase() !== dtsPath) :
+                            expectedProjectActualFiles
                     );
-                }
+                });
+            }
 
-                function verifyInfosWhenNoDtsFile(session: TestSession, host: TestServerHost, watchDts: boolean, dependencyTsAndMapOk?: true) {
-                    const dtsMapClosedInfo = firstDefined(closedInfos, f => f.toLowerCase() === dtsMapPath ? f : undefined);
-                    const dtsClosedInfo = firstDefined(closedInfos, f => f.toLowerCase() === dtsPath ? f : undefined);
-                    verifyInfosWithRandom(
-                        session,
-                        host,
-                        openInfos,
-                        closedInfos.filter(f => (dependencyTsAndMapOk || f !== dtsMapClosedInfo) && f !== dtsClosedInfo && (dependencyTsAndMapOk || f !== dependencyTs.path)),
-                        dtsClosedInfo && watchDts ?
-                            otherWatchedFiles.concat(dtsClosedInfo) :
-                            otherWatchedFiles
-                    );
+            function firstAction(session: TestSession, verifiers: readonly DocumentPositionMapperVerifier[]) {
+                for (const { action } of getActionInfo(verifiers, "main")) {
+                    const { request } = action(1);
+                    session.executeCommandSeq(request);
                 }
+            }
 
-                function verifyDocumentPositionMapper(session: TestSession, dependencyMap: server.ScriptInfo, documentPositionMapper: server.ScriptInfo["documentPositionMapper"], notEqual?: true) {
-                    assert.strictEqual(session.getProjectService().filenameToScriptInfo.get(dtsMapPath), dependencyMap);
-                    if (notEqual) {
-                        assert.notStrictEqual(dependencyMap.documentPositionMapper, documentPositionMapper);
+            function verifyAction(session: TestSession, { reqName, request, expectedResponse }: Action) {
+                const { response } = session.executeCommandSeq(request);
+                assert.deepEqual(response, expectedResponse, `Failed Request: ${reqName}`);
+            }
+
+            function verifyScriptInfoPresence(session: TestSession, path: string, expectedToBePresent: boolean, reqName: string) {
+                const info = session.getProjectService().filenameToScriptInfo.get(path);
+                if (expectedToBePresent) {
+                    assert.isDefined(info, `${reqName}:: ${path} expected to be present`);
+                }
+                else {
+                    assert.isUndefined(info, `${reqName}:: ${path} expected to be not present`);
+                }
+                return info;
+            }
+
+            interface VerifyDocumentPositionMapper {
+                session: TestSession;
+                dependencyMap: server.ScriptInfo | undefined;
+                documentPositionMapper: server.ScriptInfo["documentPositionMapper"];
+                equal: boolean;
+                debugInfo: string;
+            }
+            function verifyDocumentPositionMapper({ session, dependencyMap, documentPositionMapper, equal, debugInfo }: VerifyDocumentPositionMapper) {
+                assert.strictEqual(session.getProjectService().filenameToScriptInfo.get(dtsMapPath), dependencyMap, debugInfo);
+                if (dependencyMap) {
+                    if (equal) {
+                        assert.strictEqual(dependencyMap.documentPositionMapper, documentPositionMapper, debugInfo);
                     }
                     else {
-                        assert.strictEqual(dependencyMap.documentPositionMapper, documentPositionMapper);
+                        assert.notStrictEqual(dependencyMap.documentPositionMapper, documentPositionMapper, debugInfo);
                     }
                 }
+            }
 
-                function action(verifier: DocumentPositionMapperVerifier, fn: number, session: TestSession) {
-                    const { reqName, request, expectedResponse, expectedResponseNoMap, expectedResponseNoDts } = verifier.actionGetter(fn);
-                    const { response } = session.executeCommandSeq(request);
-                    return { reqName, response, expectedResponse, expectedResponseNoMap, expectedResponseNoDts, verifier };
+            function getActionInfoOfVerfier(verifier: DocumentPositionMapperVerifier, actionKey: ActionKey): ActionInfo {
+                const actionInfoGetter = verifier[actionKey];
+                if (isString(actionInfoGetter)) {
+                    return getActionInfoOfVerfier(verifier, actionInfoGetter);
                 }
 
-                function firstAction(session: TestSession) {
-                    verifier.forEach(v => action(v, 1, session));
+                if (isArray(actionInfoGetter)) {
+                    const initialValue = getActionInfoOfVerfier(verifier, actionInfoGetter[0]);
+                    return {
+                        ...initialValue,
+                        ...actionInfoGetter[1](initialValue)
+                    };
                 }
 
-                function verifyAllFnActionWorker(session: TestSession, verifyAction: (result: ReturnType<typeof action>, dtsInfo: server.ScriptInfo | undefined, isFirst: boolean) => void, dtsAbsent?: true) {
-                    // action
-                    let isFirst = true;
-                    for (const v of verifier) {
-                        for (let fn = 1; fn <= 5; fn++) {
-                            const result = action(v, fn, session);
-                            const dtsInfo = session.getProjectService().filenameToScriptInfo.get(dtsPath);
-                            if (dtsAbsent) {
-                                assert.isUndefined(dtsInfo);
-                            }
-                            else {
-                                assert.isDefined(dtsInfo);
-                            }
-                            verifyAction(result, dtsInfo, isFirst);
-                            isFirst = false;
-                        }
-                    }
-                }
+                return actionInfoGetter();
+            }
 
-                function verifyAllFnAction(
-                    session: TestSession,
-                    host: TestServerHost,
-                    firstDocumentPositionMapperNotEquals?: true,
-                    dependencyMap?: server.ScriptInfo,
-                    documentPositionMapper?: server.ScriptInfo["documentPositionMapper"]
-                ) {
-                    // action
-                    verifyAllFnActionWorker(session, ({ reqName, response, expectedResponse }, dtsInfo, isFirst) => {
-                        assert.deepEqual(response, expectedResponse, `Failed on ${reqName}`);
-                        verifyInfos(session, host);
-                        assert.equal(dtsInfo!.sourceMapFilePath, dtsMapPath);
-                        if (isFirst) {
-                            if (dependencyMap) {
-                                verifyDocumentPositionMapper(session, dependencyMap, documentPositionMapper, firstDocumentPositionMapperNotEquals);
-                                documentPositionMapper = dependencyMap.documentPositionMapper;
-                            }
-                            else {
-                                dependencyMap = session.getProjectService().filenameToScriptInfo.get(dtsMapPath)!;
-                                documentPositionMapper = dependencyMap.documentPositionMapper;
-                            }
-                        }
-                        else {
-                            verifyDocumentPositionMapper(session, dependencyMap!, documentPositionMapper);
-                        }
-                    });
-                    return { dependencyMap: dependencyMap!, documentPositionMapper };
-                }
+            function getActionInfo(verifiers: readonly DocumentPositionMapperVerifier[], actionKey: ActionKey): ActionInfo[] {
+                return verifiers.map(v => getActionInfoOfVerfier(v, actionKey));
+            }
 
-                function verifyAllFnActionWithNoMap(
-                    session: TestSession,
-                    host: TestServerHost,
-                    dependencyTsOK?: true
-                ) {
-                    let sourceMapFilePath: server.ScriptInfo["sourceMapFilePath"];
-                    // action
-                    verifyAllFnActionWorker(session, ({ reqName, response, expectedResponse, expectedResponseNoMap }, dtsInfo, isFirst) => {
-                        assert.deepEqual(response, expectedResponseNoMap || expectedResponse, `Failed on ${reqName}`);
-                        verifyInfosWhenNoMapFile(session, host, dependencyTsOK);
-                        assert.isUndefined(session.getProjectService().filenameToScriptInfo.get(dtsMapPath));
-                        if (isFirst) {
-                            assert.isNotString(dtsInfo!.sourceMapFilePath);
-                            assert.isNotFalse(dtsInfo!.sourceMapFilePath);
-                            assert.isDefined(dtsInfo!.sourceMapFilePath);
-                            sourceMapFilePath = dtsInfo!.sourceMapFilePath;
-                        }
-                        else {
-                            assert.equal(dtsInfo!.sourceMapFilePath, sourceMapFilePath);
-                        }
-                    });
-                    return sourceMapFilePath;
-                }
-
-                function verifyAllFnActionWithNoDts(
-                    session: TestSession,
-                    host: TestServerHost,
-                    dependencyTsAndMapOk?: true
-                ) {
-                    // action
-                    verifyAllFnActionWorker(session, ({ reqName, response, expectedResponse, expectedResponseNoDts, verifier }) => {
-                        assert.deepEqual(response, expectedResponseNoDts || expectedResponse, `Failed on ${reqName}`);
-                        verifyInfosWhenNoDtsFile(
+            interface VerifyAllFnAction {
+                session: TestSession;
+                host: TestServerHost;
+                verifiers: readonly DocumentPositionMapperVerifier[];
+                actionKey: ActionKey;
+                sourceMapPath?: server.ScriptInfo["sourceMapFilePath"];
+                dependencyMap?: server.ScriptInfo | undefined;
+                documentPositionMapper?: server.ScriptInfo["documentPositionMapper"];
+            }
+            interface VerifyAllFnActionResult {
+                actionInfos: readonly ActionInfo[];
+                actionKey: ActionKey;
+                dependencyMap: server.ScriptInfo | undefined;
+                documentPositionMapper: server.ScriptInfo["documentPositionMapper"] | undefined;
+            }
+            function verifyAllFnAction({
+                session,
+                host,
+                verifiers,
+                actionKey,
+                dependencyMap,
+                documentPositionMapper,
+            }: VerifyAllFnAction): VerifyAllFnActionResult {
+                const actionInfos = getActionInfo(verifiers, actionKey);
+                let sourceMapPath: server.ScriptInfo["sourceMapFilePath"] | undefined;
+                // action
+                let first = true;
+                for (const {
+                    action,
+                    closedInfos,
+                    otherWatchedFiles,
+                    expectsDts,
+                    expectsMap,
+                    freshMapInfo,
+                    freshDocumentMapper,
+                    skipDtsMapCheck
+                } of actionInfos) {
+                    for (let fn = 1; fn <= 5; fn++) {
+                        const fnAction = action(fn);
+                        verifyAction(session, fnAction);
+                        const debugInfo = `${actionKey}:: ${fnAction.reqName}:: ${fn}`;
+                        const dtsInfo = verifyScriptInfoPresence(session, dtsPath, expectsDts, debugInfo);
+                        const dtsMapInfo = verifyScriptInfoPresence(session, dtsMapPath, expectsMap, debugInfo);
+                        verifyInfosWithRandom(
                             session,
                             host,
-                            // Even when project actual file contains dts, its not watched because the dts is in another folder and module resolution just fails
-                            // instead of succeeding to source file and then mapping using project reference (When using usage location)
-                            // But watched if sourcemapper is in source project since we need to keep track of dts to update the source mapper for any potential usages
-                            verifier.expectedProjectActualFiles.every(f => f.toLowerCase() !== dtsPath),
-                            dependencyTsAndMapOk,
+                            openFiles(verifiers).map(f => f.path),
+                            closedInfos,
+                            otherWatchedFiles,
+                            debugInfo
                         );
-                    }, /*dtsAbsent*/ true);
+
+                        if (dtsInfo) {
+                            if (first || (fn === 1 && freshMapInfo)) {
+                                if (!skipDtsMapCheck) {
+                                    if (dtsMapInfo) {
+                                        assert.equal(dtsInfo.sourceMapFilePath, dtsMapPath, debugInfo);
+                                    }
+                                    else {
+                                        assert.isNotString(dtsInfo.sourceMapFilePath, debugInfo);
+                                        assert.isNotFalse(dtsInfo.sourceMapFilePath, debugInfo);
+                                        assert.isDefined(dtsInfo.sourceMapFilePath, debugInfo);
+                                    }
+                                }
+                            }
+                            else {
+                                assert.equal(dtsInfo.sourceMapFilePath, sourceMapPath, debugInfo);
+                            }
+                        }
+
+                        if (!first && (fn !== 1 || !freshMapInfo)) {
+                            verifyDocumentPositionMapper({
+                                session,
+                                dependencyMap,
+                                documentPositionMapper,
+                                equal: fn !== 1 || !freshDocumentMapper,
+                                debugInfo
+                            });
+                        }
+                        sourceMapPath = dtsInfo && dtsInfo.sourceMapFilePath;
+                        dependencyMap = dtsMapInfo;
+                        documentPositionMapper = dependencyMap && dependencyMap.documentPositionMapper;
+                        first = false;
+                    }
                 }
 
-                function verifyScenarioWithChangesWorker(
-                    change: (host: TestServerHost, session: TestSession) => void,
-                    afterActionDocumentPositionMapperNotEquals: true | undefined,
-                    timeoutBeforeAction: boolean
-                ) {
-                    const { host, session } = openTsFile();
+                return { actionInfos, actionKey, dependencyMap, documentPositionMapper };
+            }
+
+            function verifyScriptInfoCollection(
+                session: TestSession,
+                host: TestServerHost,
+                verifiers: readonly DocumentPositionMapperVerifier[],
+                { dependencyMap, documentPositionMapper, actionInfos, actionKey }: VerifyAllFnActionResult
+            ) {
+                // Collecting at this point retains dependency.d.ts and map
+                closeFilesForSession([randomFile], session);
+                openFilesForSession([randomFile], session);
+
+                const { closedInfos, otherWatchedFiles } = last(actionInfos);
+                const debugInfo = `${actionKey} Collection`;
+                verifyInfosWithRandom(
+                    session,
+                    host,
+                    openFiles(verifiers).map(f => f.path),
+                    closedInfos,
+                    otherWatchedFiles,
+                    debugInfo
+                );
+                verifyDocumentPositionMapper({
+                    session,
+                    dependencyMap,
+                    documentPositionMapper,
+                    equal: true,
+                    debugInfo
+                });
+
+                // Closing open file, removes dependencies too
+                closeFilesForSession([...openFiles(verifiers), randomFile], session);
+                openFilesForSession([randomFile], session);
+                verifyOnlyRandomInfos(session, host);
+            }
+
+            function verifyScenarioAndScriptInfoCollection(
+                session: TestSession,
+                host: TestServerHost,
+                verifiers: readonly DocumentPositionMapperVerifier[],
+                actionKey: ActionKey,
+                noDts?: true
+            ) {
+                // Main scenario action
+                const result = verifyAllFnAction({ session, host, verifiers, actionKey });
+                checkProject(session, verifiers, noDts);
+                verifyScriptInfoCollection(session, host, verifiers, result);
+            }
+
+            function verifyScenarioWithChangesWorker(
+                {
+                    scenarioName,
+                    verifier,
+                    withRefs,
+                    change,
+                    afterChangeActionKey
+                }: VerifyScenarioWithChanges,
+                timeoutBeforeAction: boolean,
+            ) {
+                it(scenarioName, () => {
+                    const { host, session, verifiers } = openTsFile({ verifier, withRefs });
 
                     // Create DocumentPositionMapper
-                    firstAction(session);
-                    const dependencyMap = session.getProjectService().filenameToScriptInfo.get(dtsMapPath)!;
-                    const documentPositionMapper = dependencyMap.documentPositionMapper;
+                    firstAction(session, verifiers);
+                    const dependencyMap = session.getProjectService().filenameToScriptInfo.get(dtsMapPath);
+                    const documentPositionMapper = dependencyMap && dependencyMap.documentPositionMapper;
 
                     // change
-                    change(host, session);
+                    change(host, session, verifiers);
                     if (timeoutBeforeAction) {
                         host.runQueuedTimeoutCallbacks();
-                        checkProject(session);
-                        verifyDocumentPositionMapper(session, dependencyMap, documentPositionMapper);
+                        checkProject(session, verifiers);
+                        verifyDocumentPositionMapper({
+                            session,
+                            dependencyMap,
+                            documentPositionMapper,
+                            equal: true,
+                            debugInfo: "After change timeout"
+                        });
                     }
 
                     // action
-                    verifyAllFnAction(session, host, afterActionDocumentPositionMapperNotEquals, dependencyMap, documentPositionMapper);
-                }
-
-                function verifyScenarioWithChanges(
-                    scenarioName: string,
-                    change: (host: TestServerHost, session: TestSession) => void,
-                    afterActionDocumentPositionMapperNotEquals?: true
-                ) {
-                    describe(scenarioName, () => {
-                        it("when timeout occurs before request", () => {
-                            verifyScenarioWithChangesWorker(change, afterActionDocumentPositionMapperNotEquals, /*timeoutBeforeAction*/ true);
-                        });
-
-                        it("when timeout does not occur before request", () => {
-                            verifyScenarioWithChangesWorker(change, afterActionDocumentPositionMapperNotEquals, /*timeoutBeforeAction*/ false);
-                        });
-                    });
-                }
-
-                function verifyMainScenarioAndScriptInfoCollection(session: TestSession, host: TestServerHost) {
-                    // Main scenario action
-                    const { dependencyMap, documentPositionMapper } = verifyAllFnAction(session, host);
-                    checkProject(session);
-                    verifyInfos(session, host);
-
-                    // Collecting at this point retains dependency.d.ts and map
-                    closeFilesForSession([randomFile], session);
-                    openFilesForSession([randomFile], session);
-                    verifyInfos(session, host);
-                    verifyDocumentPositionMapper(session, dependencyMap, documentPositionMapper);
-
-                    // Closing open file, removes dependencies too
-                    closeFilesForSession([...openFiles, randomFile], session);
-                    openFilesForSession([randomFile], session);
-                    verifyOnlyRandomInfos(session, host);
-                }
-
-                function verifyMainScenarioAndScriptInfoCollectionWithNoMap(session: TestSession, host: TestServerHost, dependencyTsOKInScenario?: true) {
-                    // Main scenario action
-                    verifyAllFnActionWithNoMap(session, host, dependencyTsOKInScenario);
-
-                    // Collecting at this point retains dependency.d.ts and map watcher
-                    closeFilesForSession([randomFile], session);
-                    openFilesForSession([randomFile], session);
-                    verifyInfosWhenNoMapFile(session, host);
-
-                    // Closing open file, removes dependencies too
-                    closeFilesForSession([...openFiles, randomFile], session);
-                    openFilesForSession([randomFile], session);
-                    verifyOnlyRandomInfos(session, host);
-                }
-
-                function verifyMainScenarioAndScriptInfoCollectionWithNoDts(session: TestSession, host: TestServerHost, dependencyTsAndMapOk?: true) {
-                    // Main scenario action
-                    verifyAllFnActionWithNoDts(session, host, dependencyTsAndMapOk);
-
-                    // Collecting at this point retains dependency.d.ts and map watcher
-                    closeFilesForSession([randomFile], session);
-                    openFilesForSession([randomFile], session);
-                    verifyInfosWhenNoDtsFile(
+                    verifyAllFnAction({
                         session,
                         host,
-                        !!forEach(verifier, v => v.expectedProjectActualFiles.every(f => f.toLowerCase() !== dtsPath))
-                    );
+                        verifiers,
+                        actionKey: afterChangeActionKey,
+                        dependencyMap,
+                        documentPositionMapper
+                    });
+                });
+            }
 
-                    // Closing open file, removes dependencies too
-                    closeFilesForSession([...openFiles, randomFile], session);
-                    openFilesForSession([randomFile], session);
-                    verifyOnlyRandomInfos(session, host);
-                }
+            interface VerifyScenarioWithChanges extends VerifierAndWithRefs {
+                scenarioName: string;
+                change: (host: TestServerHost, session: TestSession, verifiers: readonly DocumentPositionMapperVerifier[]) => void;
+                afterChangeActionKey: ActionKey;
+            }
+            function verifyScenarioWithChanges(verify: VerifyScenarioWithChanges) {
+                describe("when timeout occurs before request", () => {
+                    verifyScenarioWithChangesWorker(verify, /*timeoutBeforeAction*/ true);
+                });
 
-                function verifyScenarioWhenFileNotPresent(
-                    scenarioName: string,
-                    fileLocation: string,
-                    verifyScenarioAndScriptInfoCollection: (session: TestSession, host: TestServerHost, dependencyTsOk?: true) => void,
-                    noDts?: true
-                ) {
-                    describe(scenarioName, () => {
-                        it(mainScenario, () => {
-                            const { host, session } = openTsFile(host => host.deleteFile(fileLocation));
-                            checkProject(session, noDts);
+                describe("when timeout does not occur before request", () => {
+                    verifyScenarioWithChangesWorker(verify, /*timeoutBeforeAction*/ false);
+                });
+            }
 
-                            verifyScenarioAndScriptInfoCollection(session, host);
+            interface VerifyScenarioWhenFileNotPresent extends VerifierAndWithRefs {
+                scenarioName: string;
+                fileLocation: string;
+                fileNotPresentKey: ActionKey;
+                fileCreatedKey: ActionKey;
+                fileDeletedKey: ActionKey;
+                noDts?: true;
+            }
+            function verifyScenarioWhenFileNotPresent({
+                scenarioName,
+                verifier,
+                withRefs,
+                fileLocation,
+                fileNotPresentKey,
+                fileCreatedKey,
+                fileDeletedKey,
+                noDts
+            }: VerifyScenarioWhenFileNotPresent) {
+                describe(scenarioName, () => {
+                    it("when file is not present", () => {
+                        const { host, session, verifiers } = openTsFile({
+                            verifier,
+                            withRefs,
+                            onHostCreate: host => host.deleteFile(fileLocation)
                         });
+                        checkProject(session, verifiers, noDts);
 
-                        it("when file is created", () => {
-                            let fileContents: string | undefined;
-                            const { host, session } = openTsFile(host => {
+                        verifyScenarioAndScriptInfoCollection(session, host, verifiers, fileNotPresentKey, noDts);
+                    });
+
+                    it("when file is created after actions on projects", () => {
+                        let fileContents: string | undefined;
+                        const { host, session, verifiers } = openTsFile({
+                            verifier,
+                            withRefs,
+                            onHostCreate: host => {
                                 fileContents = host.readFile(fileLocation);
                                 host.deleteFile(fileLocation);
-                            });
-                            firstAction(session);
-
-                            host.writeFile(fileLocation, fileContents!);
-                            verifyMainScenarioAndScriptInfoCollection(session, host);
+                            }
                         });
+                        firstAction(session, verifiers);
 
-                        it("when file is deleted", () => {
-                            const { host, session } = openTsFile();
-                            firstAction(session);
-
-                            // The dependency file is deleted when orphan files are collected
-                            host.deleteFile(fileLocation);
-                            verifyScenarioAndScriptInfoCollection(session, host, /*dependencyTsOk*/ true);
-                        });
+                        host.writeFile(fileLocation, fileContents!);
+                        verifyScenarioAndScriptInfoCollection(session, host, verifiers, fileCreatedKey);
                     });
-                }
 
+                    it("when file is deleted after actions on the projects", () => {
+                        const { host, session, verifiers } = openTsFile({ verifier, withRefs });
+                        firstAction(session, verifiers);
+
+                        // The dependency file is deleted when orphan files are collected
+                        host.deleteFile(fileLocation);
+                        // Verify with deleted action key
+                        verifyAllFnAction({ session, host, verifiers, actionKey: fileDeletedKey });
+                        checkProject(session, verifiers, noDts);
+
+                        // Script info collection should behave as fileNotPresentKey
+                        verifyScriptInfoCollection(
+                            session,
+                            host,
+                            verifiers,
+                            {
+                                actionInfos: getActionInfo(verifiers, fileNotPresentKey),
+                                actionKey: fileNotPresentKey,
+                                dependencyMap: undefined,
+                                documentPositionMapper: undefined
+                            }
+                        );
+                    });
+                });
+            }
+
+            function verifyScenarioWorker({ mainScenario, verifier }: VerifyScenario, withRefs: boolean, disableSourceOfProjectReferenceRedirect?: true) {
                 it(mainScenario, () => {
-                    const { host, session } = openTsFile();
-                    checkProject(session);
-
-                    verifyMainScenarioAndScriptInfoCollection(session, host);
+                    const { host, session, verifiers } = openTsFile({ withRefs, disableSourceOfProjectReferenceRedirect, verifier });
+                    checkProject(session, verifiers);
+                    verifyScenarioAndScriptInfoCollection(session, host, verifiers, "main");
                 });
 
                 // Edit
-                verifyScenarioWithChanges(
-                    "when usage file changes, document position mapper doesnt change",
-                    (_host, session) => openFiles.forEach(
-                        (openFile, index) => session.executeCommandSeq<protocol.ChangeRequest>({
+                verifyScenarioWithChanges({
+                    scenarioName: "when usage file changes, document position mapper doesnt change",
+                    verifier,
+                    withRefs,
+                    disableSourceOfProjectReferenceRedirect,
+                    change: (_host, session, verifiers) => verifiers.forEach(
+                        verifier => session.executeCommandSeq<protocol.ChangeRequest>({
                             command: protocol.CommandTypes.Change,
-                            arguments: { file: openFile.path, line: openFileLastLines[index], offset: 1, endLine: openFileLastLines[index], endOffset: 1, insertString: "const x = 10;" }
+                            arguments: {
+                                file: verifier.openFile.path,
+                                line: verifier.openFileLastLine,
+                                offset: 1,
+                                endLine: verifier.openFileLastLine,
+                                endOffset: 1,
+                                insertString: "const x = 10;"
+                            }
                         })
-                    )
-                );
+                    ),
+                    afterChangeActionKey: "change"
+                });
 
                 // Edit dts to add new fn
-                verifyScenarioWithChanges(
-                    "when dependency .d.ts changes, document position mapper doesnt change",
-                    host => host.writeFile(
+                verifyScenarioWithChanges({
+                    scenarioName: "when dependency .d.ts changes, document position mapper doesnt change",
+                    verifier,
+                    withRefs,
+                    disableSourceOfProjectReferenceRedirect,
+                    change: host => host.writeFile(
                         dtsLocation,
                         host.readFile(dtsLocation)!.replace(
                             "//# sourceMappingURL=FnS.d.ts.map",
                             `export declare function fn6(): void;
 //# sourceMappingURL=FnS.d.ts.map`
                         )
-                    )
-                );
+                    ),
+                    afterChangeActionKey: "dtsChange"
+                });
 
                 // Edit map file to represent added new line
-                verifyScenarioWithChanges(
-                    "when dependency file's map changes",
-                    host => host.writeFile(
+                verifyScenarioWithChanges({
+                    scenarioName: "when dependency file's map changes",
+                    verifier,
+                    withRefs,
+                    disableSourceOfProjectReferenceRedirect,
+                    change: host => host.writeFile(
                         dtsMapLocation,
                         `{"version":3,"file":"FnS.d.ts","sourceRoot":"","sources":["../dependency/FnS.ts"],"names":[],"mappings":"AAAA,wBAAgB,GAAG,SAAM;AACzB,wBAAgB,GAAG,SAAM;AACzB,wBAAgB,GAAG,SAAM;AACzB,wBAAgB,GAAG,SAAM;AACzB,wBAAgB,GAAG,SAAM;AACzB,eAAO,MAAM,CAAC,KAAK,CAAC"}`
                     ),
-                    /*afterActionDocumentPositionMapperNotEquals*/ true
-                );
+                    afterChangeActionKey: "mapChange"
+                });
 
-                verifyScenarioWhenFileNotPresent(
-                    "when map file is not present",
-                    dtsMapLocation,
-                    verifyMainScenarioAndScriptInfoCollectionWithNoMap
-                );
+                verifyScenarioWhenFileNotPresent({
+                    scenarioName: "with depedency files map file",
+                    verifier,
+                    withRefs,
+                    disableSourceOfProjectReferenceRedirect,
+                    fileLocation: dtsMapLocation,
+                    fileNotPresentKey: "noMap",
+                    fileCreatedKey: "mapFileCreated",
+                    fileDeletedKey: "mapFileDeleted"
+                });
 
-                verifyScenarioWhenFileNotPresent(
-                    "when .d.ts file is not present",
-                    dtsLocation,
-                    verifyMainScenarioAndScriptInfoCollectionWithNoDts,
-                    /*noDts*/ true
-                );
+                verifyScenarioWhenFileNotPresent({
+                    scenarioName: "with depedency .d.ts file",
+                    verifier,
+                    withRefs,
+                    disableSourceOfProjectReferenceRedirect,
+                    fileLocation: dtsLocation,
+                    fileNotPresentKey: "noDts",
+                    fileCreatedKey: "dtsFileCreated",
+                    fileDeletedKey: "dtsFileDeleted",
+                    noDts: true
+                });
+
+                if (withRefs && !disableSourceOfProjectReferenceRedirect) {
+                    verifyScenarioWithChanges({
+                        scenarioName: "when defining project source changes",
+                        verifier,
+                        withRefs,
+                        change: (host, session, verifiers) => {
+                            // Make change, without rebuild of solution
+                            if (contains(openFiles(verifiers), dependencyTs)) {
+                                session.executeCommandSeq<protocol.ChangeRequest>({
+                                    command: protocol.CommandTypes.Change,
+                                    arguments: {
+                                        file: dependencyTs.path, line: 1, offset: 1, endLine: 1, endOffset: 1, insertString: `function fooBar() { }
+`}
+                                });
+                            }
+                            else {
+                                host.writeFile(dependencyTs.path, `function fooBar() { }
+${dependencyTs.content}`);
+                            }
+                        },
+                        afterChangeActionKey: "dependencyChange"
+                    });
+
+                    it("when projects are not built", () => {
+                        const host = createServerHost(files);
+                        const session = createSession(host);
+                        const verifiers = verifier(withRefs);
+                        openFilesForSession([...openFiles(verifiers), randomFile], session);
+                        verifyScenarioAndScriptInfoCollection(session, host, verifiers, "noBuild");
+                    });
+                }
             }
 
-            function verifyScenarios(withRefs: boolean) {
-                describe(withRefs ? "when main tsconfig has project reference" : "when main tsconfig doesnt have project reference", () => {
-                    const usageVerifier: DocumentPositionMapperVerifier = {
-                        openFile: mainTs,
-                        expectedProjectActualFiles: [mainTs.path, libFile.path, mainConfig.path, dtsPath],
-                        actionGetter: gotoDefintinionFromMainTs,
-                        openFileLastLine: 14
-                    };
-                    describe("from project that uses dependency", () => {
-                        const closedInfos = withRefs ?
-                            [dependencyTs.path, dependencyConfig.path, libFile.path, dtsPath, dtsMapLocation] :
-                            [dependencyTs.path, libFile.path, dtsPath, dtsMapLocation];
-                        verifyDocumentPositionMapperUpdates(
-                            "can go to definition correctly",
-                            [usageVerifier],
-                            closedInfos,
-                            withRefs
-                        );
-                    });
-
-                    const definingVerifier: DocumentPositionMapperVerifier = {
-                        openFile: dependencyTs,
-                        expectedProjectActualFiles: [dependencyTs.path, libFile.path, dependencyConfig.path],
-                        actionGetter: renameFromDependencyTs,
-                        openFileLastLine: 6,
-                    };
-                    describe("from defining project", () => {
-                        const closedInfos = [libFile.path, dtsLocation, dtsMapLocation];
-                        verifyDocumentPositionMapperUpdates(
-                            "rename locations from dependency",
-                            [definingVerifier],
-                            closedInfos,
-                            withRefs
-                        );
-                    });
-
-                    describe("when opening depedency and usage project", () => {
-                        const closedInfos = withRefs ?
-                            [libFile.path, dtsPath, dtsMapLocation, dependencyConfig.path] :
-                            [libFile.path, dtsPath, dtsMapLocation];
-                        verifyDocumentPositionMapperUpdates(
-                            "goto Definition in usage and rename locations from defining project",
-                            [usageVerifier, { ...definingVerifier, actionGetter: renameFromDependencyTsWithBothProjectsOpen }],
-                            closedInfos,
-                            withRefs
-                        );
-                    });
+            interface VerifyScenario {
+                mainScenario: string;
+                verifier: (withRefs: boolean) => readonly DocumentPositionMapperVerifier[];
+            }
+            function verifyScenario(scenario: VerifyScenario) {
+                describe("when main tsconfig doesnt have project reference", () => {
+                    verifyScenarioWorker(scenario, /*withRefs*/ false);
+                });
+                describe("when main tsconfig has project reference", () => {
+                    verifyScenarioWorker(scenario, /*withRefs*/ true);
+                });
+                describe("when main tsconfig has but has disableSourceOfProjectReferenceRedirect", () => {
+                    verifyScenarioWorker(scenario, /*withRefs*/ true);
                 });
             }
 
-            verifyScenarios(/*withRefs*/ false);
-            verifyScenarios(/*withRefs*/ true);
+            describe("from project that uses dependency", () => {
+                verifyScenario({
+                    mainScenario: "can go to definition correctly",
+                    verifier: withRefs => [
+                        {
+                            ...goToDefFromMainTsProjectInfoVerifier(withRefs),
+                            main: () => ({
+                                action: goToDefFromMainTs,
+                                closedInfos: withRefs ?
+                                    [dependencyTs.path, dependencyConfig.path, libFile.path] :
+                                    [dependencyTs.path, libFile.path, dtsPath, dtsMapLocation],
+                                otherWatchedFiles: [mainConfig.path],
+                                expectsDts: !withRefs, // Dts script info present only if no project reference
+                                expectsMap: !withRefs // Map script info present only if no project reference
+                            }),
+                            change: "main",
+                            dtsChange: "main",
+                            mapChange: ["main", () => ({
+                                freshDocumentMapper: true
+                            })],
+                            noMap: withRefs ?
+                                "main" :
+                                ["main", main => ({
+                                    action: goToDefFromMainTsWithNoMap,
+                                    // Because map is deleted, dts and dependency are released
+                                    closedInfos: removePath(main.closedInfos, dtsMapPath, dependencyTsPath),
+                                    // Watches deleted file
+                                    otherWatchedFiles: main.otherWatchedFiles.concat(dtsMapLocation),
+                                    expectsMap: false
+                                })],
+                            mapFileCreated: "main",
+                            mapFileDeleted: withRefs ?
+                                "main" :
+                                ["noMap", noMap => ({
+                                    // The script info for depedency is collected only after file open
+                                    closedInfos: noMap.closedInfos.concat(dependencyTs.path)
+                                })],
+                            noDts: withRefs ?
+                                "main" :
+                                ["main", main => ({
+                                    action: goToDefFromMainTsWithNoDts,
+                                    // No dts, no map, no dependency
+                                    closedInfos: removePath(main.closedInfos, dtsPath, dtsMapPath, dependencyTsPath),
+                                    expectsDts: false,
+                                    expectsMap: false
+                                })],
+                            dtsFileCreated: "main",
+                            dtsFileDeleted: withRefs ?
+                                "main" :
+                                ["noDts", noDts => ({
+                                    // The script info for map is collected only after file open
+                                    closedInfos: noDts.closedInfos.concat(dependencyTs.path, dtsMapLocation),
+                                    expectsMap: true
+                                })],
+                            dependencyChange: ["main", () => ({
+                                action: goToDefFromMainTsWithDependencyChange,
+                            })],
+                            noBuild: "noDts"
+                        }
+                    ]
+                });
+            });
+
+            describe("from defining project", () => {
+                verifyScenario({
+                    mainScenario: "rename locations from dependency",
+                    verifier: () => [
+                        {
+                            ...renameFromDependencyTsProjectInfoVerifier(),
+                            main: () => ({
+                                action: renameFromDependencyTs,
+                                closedInfos: [libFile.path, dtsLocation, dtsMapLocation],
+                                otherWatchedFiles: [dependencyConfig.path],
+                                expectsDts: true,
+                                expectsMap: true
+                            }),
+                            change: "main",
+                            dtsChange: "main",
+                            mapChange: ["main", () => ({
+                                freshDocumentMapper: true
+                            })],
+                            noMap: ["main", main => ({
+                                // No map
+                                closedInfos: removePath(main.closedInfos, dtsMapPath),
+                                // watch map
+                                otherWatchedFiles: [...main.otherWatchedFiles, dtsMapLocation],
+                                expectsMap: false
+                            })],
+                            mapFileCreated: "main",
+                            mapFileDeleted: "noMap",
+                            noDts: ["main", main => ({
+                                // no dts or map since dts itself doesnt exist
+                                closedInfos: removePath(main.closedInfos, dtsMapPath, dtsPath),
+                                // watch deleted file
+                                otherWatchedFiles: [...main.otherWatchedFiles, dtsLocation],
+                                expectsDts: false,
+                                expectsMap: false
+                            })],
+                            dtsFileCreated: "main",
+                            dtsFileDeleted: ["noDts", noDts => ({
+                                // Map is collected after file open
+                                closedInfos: noDts.closedInfos.concat(dtsMapLocation),
+                                expectsMap: true
+                            })],
+                            dependencyChange: ["main", () => ({
+                                action: renameFromDependencyTsWithDependencyChange
+                            })],
+                            noBuild: "noDts"
+                        }
+                    ]
+                });
+            });
+
+            describe("when opening depedency and usage project", () => {
+                verifyScenario({
+                    mainScenario: "goto Definition in usage and rename locations from defining project",
+                    verifier: withRefs => [
+                        {
+                            ...goToDefFromMainTsProjectInfoVerifier(withRefs),
+                            main: () => ({
+                                action: goToDefFromMainTs,
+                                // DependencyTs is open, so omit it from closed infos
+                                closedInfos: withRefs ?
+                                    [dependencyConfig.path, libFile.path] :
+                                    [libFile.path, dtsPath, dtsMapLocation],
+                                otherWatchedFiles: withRefs ?
+                                    [mainConfig.path] : // Its in closed info
+                                    [mainConfig.path, dependencyConfig.path],
+                                expectsDts: !withRefs, // Dts script info present only if no project reference
+                                expectsMap: !withRefs // Map script info present only if no project reference
+                            }),
+                            change: withRefs ?
+                                ["main", main => ({
+                                    // Because before this rename is done the closed info remains same as rename's main operation
+                                    closedInfos: main.closedInfos.concat(dtsLocation, dtsMapLocation),
+                                    expectsDts: true,
+                                    expectsMap: true
+                                })] :
+                                "main",
+                            dtsChange: "change",
+                            mapChange: "change",
+                            noMap: withRefs ?
+                                "main" :
+                                ["main", main => ({
+                                    action: goToDefFromMainTsWithNoMap,
+                                    closedInfos: removePath(main.closedInfos, dtsMapPath),
+                                    otherWatchedFiles: main.otherWatchedFiles.concat(dtsMapLocation),
+                                    expectsMap: false
+                                })],
+                            mapFileCreated: withRefs ?
+                                ["main", main => ({
+                                    // Because before this rename is done the closed info remains same as rename's main
+                                    closedInfos: main.closedInfos.concat(dtsLocation),
+                                    expectsDts: true,
+                                    // This operation doesnt need map so the map info path in dts is not refreshed
+                                    skipDtsMapCheck: withRefs
+                                })] :
+                                "main",
+                            mapFileDeleted: withRefs ?
+                                ["noMap", noMap => ({
+                                    // Because before this rename is done the closed info remains same as rename's noMap operation
+                                    closedInfos: noMap.closedInfos.concat(dtsLocation),
+                                    expectsDts: true,
+                                    // This operation doesnt need map so the map info path in dts is not refreshed
+                                    skipDtsMapCheck: true
+                                })] :
+                                "noMap",
+                            noDts: withRefs ?
+                                "main" :
+                                ["main", main => ({
+                                    action: goToDefFromMainTsWithNoDts,
+                                    closedInfos: removePath(main.closedInfos, dtsMapPath, dtsPath),
+                                    expectsDts: false,
+                                    expectsMap: false
+                                })],
+                            dtsFileCreated: withRefs ?
+                                ["main", main => ({
+                                    // Since the project for dependency is not updated, the watcher from rename for dts still there
+                                    otherWatchedFiles: main.otherWatchedFiles.concat(dtsLocation)
+                                })] :
+                                "main",
+                            dtsFileDeleted: ["noDts", noDts => ({
+                                // Map collection after file open
+                                closedInfos: noDts.closedInfos.concat(dtsMapLocation),
+                                expectsMap: true
+                            })],
+                            dependencyChange: ["change", () => ({
+                                action: goToDefFromMainTsWithDependencyChange,
+                            })],
+                            noBuild: "noDts"
+                        },
+                        {
+                            ...renameFromDependencyTsProjectInfoVerifier(),
+                            main: () => ({
+                                action: renameFromDependencyTsWithBothProjectsOpen,
+                                // DependencyTs is open, so omit it from closed infos
+                                closedInfos: withRefs ?
+                                    [dependencyConfig.path, libFile.path, dtsLocation, dtsMapLocation] :
+                                    [libFile.path, dtsPath, dtsMapLocation],
+                                otherWatchedFiles: withRefs ?
+                                    [mainConfig.path] : // Its in closed info
+                                    [mainConfig.path, dependencyConfig.path],
+                                expectsDts: true,
+                                expectsMap: true,
+                                freshMapInfo: withRefs
+                            }),
+                            change: ["main", () => ({
+                                freshMapInfo: false
+                            })],
+                            dtsChange: "change",
+                            mapChange: ["main", () => ({
+                                freshMapInfo: false,
+                                freshDocumentMapper: withRefs
+                            })],
+                            noMap: ["main", main => ({
+                                action: withRefs ?
+                                    renameFromDependencyTsWithBothProjectsOpen :
+                                    renameFromDependencyTs,
+                                closedInfos: removePath(main.closedInfos, dtsMapPath),
+                                otherWatchedFiles: main.otherWatchedFiles.concat(dtsMapLocation),
+                                expectsMap: false,
+                                freshDocumentMapper: withRefs
+                            })],
+                            mapFileCreated: "main",
+                            mapFileDeleted: "noMap",
+                            noDts: ["change", change => ({
+                                action: withRefs ?
+                                    renameFromDependencyTsWithBothProjectsOpen :
+                                    renameFromDependencyTs,
+                                closedInfos: removePath(change.closedInfos, dtsPath, dtsMapPath),
+                                otherWatchedFiles: change.otherWatchedFiles.concat(dtsLocation),
+                                expectsDts: false,
+                                expectsMap: false
+                            })],
+                            dtsFileCreated: "main",
+                            dtsFileDeleted: ["noDts", noDts => ({
+                                // Map collection after file open
+                                closedInfos: noDts.closedInfos.concat(dtsMapLocation) ,
+                                expectsMap: true
+                            })],
+                            dependencyChange: ["change", () => ({
+                                action: renameFromDependencyTsWithBothProjectsOpenWithDependencyChange
+                            })],
+                            noBuild: "noDts"
+                        }
+                    ]
+                });
+            });
         });
 
         it("reusing d.ts files from composite and non composite projects", () => {
@@ -774,7 +1246,7 @@ fn5();
             service.openClientFile(cTs.path);
             service.checkNumberOfProjects({ configuredProjects: 2 });
             const projectC = service.configuredProjects.get(configC.path)!;
-            checkProjectActualFiles(projectC, [cTs.path, bDts.path, libFile.path, configC.path]);
+            checkProjectActualFiles(projectC, [cTs.path, bTs.path, libFile.path, configC.path]);
 
             // Now new project for project A tries to reuse b but there is no filesByName mapping for b's source location
             host.writeFile(a2Ts.path, `${a2Ts.content}export const y = 30;`);
diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts
index 79450ca83c9..f7a65687f3b 100644
--- a/tests/baselines/reference/api/tsserverlibrary.d.ts
+++ b/tests/baselines/reference/api/tsserverlibrary.d.ts
@@ -73,7 +73,7 @@ declare namespace ts {
         end: number;
     }
     export type JSDocSyntaxKind = SyntaxKind.EndOfFileToken | SyntaxKind.WhitespaceTrivia | SyntaxKind.AtToken | SyntaxKind.NewLineTrivia | SyntaxKind.AsteriskToken | SyntaxKind.OpenBraceToken | SyntaxKind.CloseBraceToken | SyntaxKind.LessThanToken | SyntaxKind.GreaterThanToken | SyntaxKind.OpenBracketToken | SyntaxKind.CloseBracketToken | SyntaxKind.EqualsToken | SyntaxKind.CommaToken | SyntaxKind.DotToken | SyntaxKind.Identifier | SyntaxKind.BacktickToken | SyntaxKind.Unknown | KeywordSyntaxKind;
-    export type KeywordSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AnyKeyword | SyntaxKind.AsKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.BreakKeyword | SyntaxKind.CaseKeyword | SyntaxKind.CatchKeyword | SyntaxKind.ClassKeyword | SyntaxKind.ContinueKeyword | SyntaxKind.ConstKeyword | SyntaxKind.ConstructorKeyword | SyntaxKind.DebuggerKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.DeleteKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword | SyntaxKind.EnumKeyword | SyntaxKind.ExportKeyword | SyntaxKind.ExtendsKeyword | SyntaxKind.FalseKeyword | SyntaxKind.FinallyKeyword | SyntaxKind.ForKeyword | SyntaxKind.FromKeyword | SyntaxKind.FunctionKeyword | SyntaxKind.GetKeyword | SyntaxKind.IfKeyword | SyntaxKind.ImplementsKeyword | SyntaxKind.ImportKeyword | SyntaxKind.InKeyword | SyntaxKind.InferKeyword | SyntaxKind.InstanceOfKeyword | SyntaxKind.InterfaceKeyword | SyntaxKind.IsKeyword | SyntaxKind.KeyOfKeyword | SyntaxKind.LetKeyword | SyntaxKind.ModuleKeyword | SyntaxKind.NamespaceKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NewKeyword | SyntaxKind.NullKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.PackageKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.RequireKeyword | SyntaxKind.GlobalKeyword | SyntaxKind.ReturnKeyword | SyntaxKind.SetKeyword | SyntaxKind.StaticKeyword | SyntaxKind.StringKeyword | SyntaxKind.SuperKeyword | SyntaxKind.SwitchKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.ThisKeyword | SyntaxKind.ThrowKeyword | SyntaxKind.TrueKeyword | SyntaxKind.TryKeyword | SyntaxKind.TypeKeyword | SyntaxKind.TypeOfKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VarKeyword | SyntaxKind.VoidKeyword | SyntaxKind.WhileKeyword | SyntaxKind.WithKeyword | SyntaxKind.YieldKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.AwaitKeyword | SyntaxKind.OfKeyword;
+    export type KeywordSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AnyKeyword | SyntaxKind.AsKeyword | SyntaxKind.AssertsKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.BreakKeyword | SyntaxKind.CaseKeyword | SyntaxKind.CatchKeyword | SyntaxKind.ClassKeyword | SyntaxKind.ContinueKeyword | SyntaxKind.ConstKeyword | SyntaxKind.ConstructorKeyword | SyntaxKind.DebuggerKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.DeleteKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword | SyntaxKind.EnumKeyword | SyntaxKind.ExportKeyword | SyntaxKind.ExtendsKeyword | SyntaxKind.FalseKeyword | SyntaxKind.FinallyKeyword | SyntaxKind.ForKeyword | SyntaxKind.FromKeyword | SyntaxKind.FunctionKeyword | SyntaxKind.GetKeyword | SyntaxKind.IfKeyword | SyntaxKind.ImplementsKeyword | SyntaxKind.ImportKeyword | SyntaxKind.InKeyword | SyntaxKind.InferKeyword | SyntaxKind.InstanceOfKeyword | SyntaxKind.InterfaceKeyword | SyntaxKind.IsKeyword | SyntaxKind.KeyOfKeyword | SyntaxKind.LetKeyword | SyntaxKind.ModuleKeyword | SyntaxKind.NamespaceKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NewKeyword | SyntaxKind.NullKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.PackageKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.RequireKeyword | SyntaxKind.GlobalKeyword | SyntaxKind.ReturnKeyword | SyntaxKind.SetKeyword | SyntaxKind.StaticKeyword | SyntaxKind.StringKeyword | SyntaxKind.SuperKeyword | SyntaxKind.SwitchKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.ThisKeyword | SyntaxKind.ThrowKeyword | SyntaxKind.TrueKeyword | SyntaxKind.TryKeyword | SyntaxKind.TypeKeyword | SyntaxKind.TypeOfKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VarKeyword | SyntaxKind.VoidKeyword | SyntaxKind.WhileKeyword | SyntaxKind.WithKeyword | SyntaxKind.YieldKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.AwaitKeyword | SyntaxKind.OfKeyword;
     export type JsxTokenSyntaxKind = SyntaxKind.LessThanSlashToken | SyntaxKind.EndOfFileToken | SyntaxKind.ConflictMarkerTrivia | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.OpenBraceToken | SyntaxKind.LessThanToken;
     export enum SyntaxKind {
         Unknown = 0,
@@ -198,206 +198,207 @@ declare namespace ts {
         YieldKeyword = 118,
         AbstractKeyword = 119,
         AsKeyword = 120,
-        AnyKeyword = 121,
-        AsyncKeyword = 122,
-        AwaitKeyword = 123,
-        BooleanKeyword = 124,
-        ConstructorKeyword = 125,
-        DeclareKeyword = 126,
-        GetKeyword = 127,
-        InferKeyword = 128,
-        IsKeyword = 129,
-        KeyOfKeyword = 130,
-        ModuleKeyword = 131,
-        NamespaceKeyword = 132,
-        NeverKeyword = 133,
-        ReadonlyKeyword = 134,
-        RequireKeyword = 135,
-        NumberKeyword = 136,
-        ObjectKeyword = 137,
-        SetKeyword = 138,
-        StringKeyword = 139,
-        SymbolKeyword = 140,
-        TypeKeyword = 141,
-        UndefinedKeyword = 142,
-        UniqueKeyword = 143,
-        UnknownKeyword = 144,
-        FromKeyword = 145,
-        GlobalKeyword = 146,
-        BigIntKeyword = 147,
-        OfKeyword = 148,
-        QualifiedName = 149,
-        ComputedPropertyName = 150,
-        TypeParameter = 151,
-        Parameter = 152,
-        Decorator = 153,
-        PropertySignature = 154,
-        PropertyDeclaration = 155,
-        MethodSignature = 156,
-        MethodDeclaration = 157,
-        Constructor = 158,
-        GetAccessor = 159,
-        SetAccessor = 160,
-        CallSignature = 161,
-        ConstructSignature = 162,
-        IndexSignature = 163,
-        TypePredicate = 164,
-        TypeReference = 165,
-        FunctionType = 166,
-        ConstructorType = 167,
-        TypeQuery = 168,
-        TypeLiteral = 169,
-        ArrayType = 170,
-        TupleType = 171,
-        OptionalType = 172,
-        RestType = 173,
-        UnionType = 174,
-        IntersectionType = 175,
-        ConditionalType = 176,
-        InferType = 177,
-        ParenthesizedType = 178,
-        ThisType = 179,
-        TypeOperator = 180,
-        IndexedAccessType = 181,
-        MappedType = 182,
-        LiteralType = 183,
-        ImportType = 184,
-        ObjectBindingPattern = 185,
-        ArrayBindingPattern = 186,
-        BindingElement = 187,
-        ArrayLiteralExpression = 188,
-        ObjectLiteralExpression = 189,
-        PropertyAccessExpression = 190,
-        ElementAccessExpression = 191,
-        CallExpression = 192,
-        NewExpression = 193,
-        TaggedTemplateExpression = 194,
-        TypeAssertionExpression = 195,
-        ParenthesizedExpression = 196,
-        FunctionExpression = 197,
-        ArrowFunction = 198,
-        DeleteExpression = 199,
-        TypeOfExpression = 200,
-        VoidExpression = 201,
-        AwaitExpression = 202,
-        PrefixUnaryExpression = 203,
-        PostfixUnaryExpression = 204,
-        BinaryExpression = 205,
-        ConditionalExpression = 206,
-        TemplateExpression = 207,
-        YieldExpression = 208,
-        SpreadElement = 209,
-        ClassExpression = 210,
-        OmittedExpression = 211,
-        ExpressionWithTypeArguments = 212,
-        AsExpression = 213,
-        NonNullExpression = 214,
-        MetaProperty = 215,
-        SyntheticExpression = 216,
-        TemplateSpan = 217,
-        SemicolonClassElement = 218,
-        Block = 219,
-        VariableStatement = 220,
+        AssertsKeyword = 121,
+        AnyKeyword = 122,
+        AsyncKeyword = 123,
+        AwaitKeyword = 124,
+        BooleanKeyword = 125,
+        ConstructorKeyword = 126,
+        DeclareKeyword = 127,
+        GetKeyword = 128,
+        InferKeyword = 129,
+        IsKeyword = 130,
+        KeyOfKeyword = 131,
+        ModuleKeyword = 132,
+        NamespaceKeyword = 133,
+        NeverKeyword = 134,
+        ReadonlyKeyword = 135,
+        RequireKeyword = 136,
+        NumberKeyword = 137,
+        ObjectKeyword = 138,
+        SetKeyword = 139,
+        StringKeyword = 140,
+        SymbolKeyword = 141,
+        TypeKeyword = 142,
+        UndefinedKeyword = 143,
+        UniqueKeyword = 144,
+        UnknownKeyword = 145,
+        FromKeyword = 146,
+        GlobalKeyword = 147,
+        BigIntKeyword = 148,
+        OfKeyword = 149,
+        QualifiedName = 150,
+        ComputedPropertyName = 151,
+        TypeParameter = 152,
+        Parameter = 153,
+        Decorator = 154,
+        PropertySignature = 155,
+        PropertyDeclaration = 156,
+        MethodSignature = 157,
+        MethodDeclaration = 158,
+        Constructor = 159,
+        GetAccessor = 160,
+        SetAccessor = 161,
+        CallSignature = 162,
+        ConstructSignature = 163,
+        IndexSignature = 164,
+        TypePredicate = 165,
+        TypeReference = 166,
+        FunctionType = 167,
+        ConstructorType = 168,
+        TypeQuery = 169,
+        TypeLiteral = 170,
+        ArrayType = 171,
+        TupleType = 172,
+        OptionalType = 173,
+        RestType = 174,
+        UnionType = 175,
+        IntersectionType = 176,
+        ConditionalType = 177,
+        InferType = 178,
+        ParenthesizedType = 179,
+        ThisType = 180,
+        TypeOperator = 181,
+        IndexedAccessType = 182,
+        MappedType = 183,
+        LiteralType = 184,
+        ImportType = 185,
+        ObjectBindingPattern = 186,
+        ArrayBindingPattern = 187,
+        BindingElement = 188,
+        ArrayLiteralExpression = 189,
+        ObjectLiteralExpression = 190,
+        PropertyAccessExpression = 191,
+        ElementAccessExpression = 192,
+        CallExpression = 193,
+        NewExpression = 194,
+        TaggedTemplateExpression = 195,
+        TypeAssertionExpression = 196,
+        ParenthesizedExpression = 197,
+        FunctionExpression = 198,
+        ArrowFunction = 199,
+        DeleteExpression = 200,
+        TypeOfExpression = 201,
+        VoidExpression = 202,
+        AwaitExpression = 203,
+        PrefixUnaryExpression = 204,
+        PostfixUnaryExpression = 205,
+        BinaryExpression = 206,
+        ConditionalExpression = 207,
+        TemplateExpression = 208,
+        YieldExpression = 209,
+        SpreadElement = 210,
+        ClassExpression = 211,
+        OmittedExpression = 212,
+        ExpressionWithTypeArguments = 213,
+        AsExpression = 214,
+        NonNullExpression = 215,
+        MetaProperty = 216,
+        SyntheticExpression = 217,
+        TemplateSpan = 218,
+        SemicolonClassElement = 219,
+        Block = 220,
         EmptyStatement = 221,
-        ExpressionStatement = 222,
-        IfStatement = 223,
-        DoStatement = 224,
-        WhileStatement = 225,
-        ForStatement = 226,
-        ForInStatement = 227,
-        ForOfStatement = 228,
-        ContinueStatement = 229,
-        BreakStatement = 230,
-        ReturnStatement = 231,
-        WithStatement = 232,
-        SwitchStatement = 233,
-        LabeledStatement = 234,
-        ThrowStatement = 235,
-        TryStatement = 236,
-        DebuggerStatement = 237,
-        VariableDeclaration = 238,
-        VariableDeclarationList = 239,
-        FunctionDeclaration = 240,
-        ClassDeclaration = 241,
-        InterfaceDeclaration = 242,
-        TypeAliasDeclaration = 243,
-        EnumDeclaration = 244,
-        ModuleDeclaration = 245,
-        ModuleBlock = 246,
-        CaseBlock = 247,
-        NamespaceExportDeclaration = 248,
-        ImportEqualsDeclaration = 249,
-        ImportDeclaration = 250,
-        ImportClause = 251,
-        NamespaceImport = 252,
-        NamedImports = 253,
-        ImportSpecifier = 254,
-        ExportAssignment = 255,
-        ExportDeclaration = 256,
-        NamedExports = 257,
-        ExportSpecifier = 258,
-        MissingDeclaration = 259,
-        ExternalModuleReference = 260,
-        JsxElement = 261,
-        JsxSelfClosingElement = 262,
-        JsxOpeningElement = 263,
-        JsxClosingElement = 264,
-        JsxFragment = 265,
-        JsxOpeningFragment = 266,
-        JsxClosingFragment = 267,
-        JsxAttribute = 268,
-        JsxAttributes = 269,
-        JsxSpreadAttribute = 270,
-        JsxExpression = 271,
-        CaseClause = 272,
-        DefaultClause = 273,
-        HeritageClause = 274,
-        CatchClause = 275,
-        PropertyAssignment = 276,
-        ShorthandPropertyAssignment = 277,
-        SpreadAssignment = 278,
-        EnumMember = 279,
-        UnparsedPrologue = 280,
-        UnparsedPrepend = 281,
-        UnparsedText = 282,
-        UnparsedInternalText = 283,
-        UnparsedSyntheticReference = 284,
-        SourceFile = 285,
-        Bundle = 286,
-        UnparsedSource = 287,
-        InputFiles = 288,
-        JSDocTypeExpression = 289,
-        JSDocAllType = 290,
-        JSDocUnknownType = 291,
-        JSDocNullableType = 292,
-        JSDocNonNullableType = 293,
-        JSDocOptionalType = 294,
-        JSDocFunctionType = 295,
-        JSDocVariadicType = 296,
-        JSDocNamepathType = 297,
-        JSDocComment = 298,
-        JSDocTypeLiteral = 299,
-        JSDocSignature = 300,
-        JSDocTag = 301,
-        JSDocAugmentsTag = 302,
-        JSDocAuthorTag = 303,
-        JSDocClassTag = 304,
-        JSDocCallbackTag = 305,
-        JSDocEnumTag = 306,
-        JSDocParameterTag = 307,
-        JSDocReturnTag = 308,
-        JSDocThisTag = 309,
-        JSDocTypeTag = 310,
-        JSDocTemplateTag = 311,
-        JSDocTypedefTag = 312,
-        JSDocPropertyTag = 313,
-        SyntaxList = 314,
-        NotEmittedStatement = 315,
-        PartiallyEmittedExpression = 316,
-        CommaListExpression = 317,
-        MergeDeclarationMarker = 318,
-        EndOfDeclarationMarker = 319,
-        Count = 320,
+        VariableStatement = 222,
+        ExpressionStatement = 223,
+        IfStatement = 224,
+        DoStatement = 225,
+        WhileStatement = 226,
+        ForStatement = 227,
+        ForInStatement = 228,
+        ForOfStatement = 229,
+        ContinueStatement = 230,
+        BreakStatement = 231,
+        ReturnStatement = 232,
+        WithStatement = 233,
+        SwitchStatement = 234,
+        LabeledStatement = 235,
+        ThrowStatement = 236,
+        TryStatement = 237,
+        DebuggerStatement = 238,
+        VariableDeclaration = 239,
+        VariableDeclarationList = 240,
+        FunctionDeclaration = 241,
+        ClassDeclaration = 242,
+        InterfaceDeclaration = 243,
+        TypeAliasDeclaration = 244,
+        EnumDeclaration = 245,
+        ModuleDeclaration = 246,
+        ModuleBlock = 247,
+        CaseBlock = 248,
+        NamespaceExportDeclaration = 249,
+        ImportEqualsDeclaration = 250,
+        ImportDeclaration = 251,
+        ImportClause = 252,
+        NamespaceImport = 253,
+        NamedImports = 254,
+        ImportSpecifier = 255,
+        ExportAssignment = 256,
+        ExportDeclaration = 257,
+        NamedExports = 258,
+        ExportSpecifier = 259,
+        MissingDeclaration = 260,
+        ExternalModuleReference = 261,
+        JsxElement = 262,
+        JsxSelfClosingElement = 263,
+        JsxOpeningElement = 264,
+        JsxClosingElement = 265,
+        JsxFragment = 266,
+        JsxOpeningFragment = 267,
+        JsxClosingFragment = 268,
+        JsxAttribute = 269,
+        JsxAttributes = 270,
+        JsxSpreadAttribute = 271,
+        JsxExpression = 272,
+        CaseClause = 273,
+        DefaultClause = 274,
+        HeritageClause = 275,
+        CatchClause = 276,
+        PropertyAssignment = 277,
+        ShorthandPropertyAssignment = 278,
+        SpreadAssignment = 279,
+        EnumMember = 280,
+        UnparsedPrologue = 281,
+        UnparsedPrepend = 282,
+        UnparsedText = 283,
+        UnparsedInternalText = 284,
+        UnparsedSyntheticReference = 285,
+        SourceFile = 286,
+        Bundle = 287,
+        UnparsedSource = 288,
+        InputFiles = 289,
+        JSDocTypeExpression = 290,
+        JSDocAllType = 291,
+        JSDocUnknownType = 292,
+        JSDocNullableType = 293,
+        JSDocNonNullableType = 294,
+        JSDocOptionalType = 295,
+        JSDocFunctionType = 296,
+        JSDocVariadicType = 297,
+        JSDocNamepathType = 298,
+        JSDocComment = 299,
+        JSDocTypeLiteral = 300,
+        JSDocSignature = 301,
+        JSDocTag = 302,
+        JSDocAugmentsTag = 303,
+        JSDocAuthorTag = 304,
+        JSDocClassTag = 305,
+        JSDocCallbackTag = 306,
+        JSDocEnumTag = 307,
+        JSDocParameterTag = 308,
+        JSDocReturnTag = 309,
+        JSDocThisTag = 310,
+        JSDocTypeTag = 311,
+        JSDocTemplateTag = 312,
+        JSDocTypedefTag = 313,
+        JSDocPropertyTag = 314,
+        SyntaxList = 315,
+        NotEmittedStatement = 316,
+        PartiallyEmittedExpression = 317,
+        CommaListExpression = 318,
+        MergeDeclarationMarker = 319,
+        EndOfDeclarationMarker = 320,
+        Count = 321,
         FirstAssignment = 60,
         LastAssignment = 72,
         FirstCompoundAssignment = 61,
@@ -405,15 +406,15 @@ declare namespace ts {
         FirstReservedWord = 74,
         LastReservedWord = 109,
         FirstKeyword = 74,
-        LastKeyword = 148,
+        LastKeyword = 149,
         FirstFutureReservedWord = 110,
         LastFutureReservedWord = 118,
-        FirstTypeNode = 164,
-        LastTypeNode = 184,
+        FirstTypeNode = 165,
+        LastTypeNode = 185,
         FirstPunctuation = 18,
         LastPunctuation = 72,
         FirstToken = 0,
-        LastToken = 148,
+        LastToken = 149,
         FirstTriviaToken = 2,
         LastTriviaToken = 7,
         FirstLiteralToken = 8,
@@ -422,11 +423,13 @@ declare namespace ts {
         LastTemplateToken = 17,
         FirstBinaryOperator = 28,
         LastBinaryOperator = 72,
-        FirstNode = 149,
-        FirstJSDocNode = 289,
-        LastJSDocNode = 313,
-        FirstJSDocTagNode = 301,
-        LastJSDocTagNode = 313,
+        FirstStatement = 222,
+        LastStatement = 238,
+        FirstNode = 150,
+        FirstJSDocNode = 290,
+        LastJSDocNode = 314,
+        FirstJSDocTagNode = 302,
+        LastJSDocTagNode = 314,
     }
     export enum NodeFlags {
         None = 0,
@@ -517,6 +520,7 @@ declare namespace ts {
     export type AwaitKeywordToken = Token<SyntaxKind.AwaitKeyword>;
     export type PlusToken = Token<SyntaxKind.PlusToken>;
     export type MinusToken = Token<SyntaxKind.MinusToken>;
+    export type AssertsToken = Token<SyntaxKind.AssertsKeyword>;
     export type Modifier = Token<SyntaxKind.AbstractKeyword> | Token<SyntaxKind.AsyncKeyword> | Token<SyntaxKind.ConstKeyword> | Token<SyntaxKind.DeclareKeyword> | Token<SyntaxKind.DefaultKeyword> | Token<SyntaxKind.ExportKeyword> | Token<SyntaxKind.PublicKeyword> | Token<SyntaxKind.PrivateKeyword> | Token<SyntaxKind.ProtectedKeyword> | Token<SyntaxKind.ReadonlyKeyword> | Token<SyntaxKind.StaticKeyword>;
     export type ModifiersArray = NodeArray<Modifier>;
     export interface Identifier extends PrimaryExpression, Declaration {
@@ -770,8 +774,9 @@ declare namespace ts {
     export interface TypePredicateNode extends TypeNode {
         kind: SyntaxKind.TypePredicate;
         parent: SignatureDeclaration | JSDocTypeExpression;
+        assertsModifier?: AssertsToken;
         parameterName: Identifier | ThisTypeNode;
-        type: TypeNode;
+        type?: TypeNode;
     }
     export interface TypeQueryNode extends TypeNode {
         kind: SyntaxKind.TypeQuery;
@@ -1669,13 +1674,19 @@ declare namespace ts {
         FalseCondition = 64,
         SwitchClause = 128,
         ArrayMutation = 256,
-        Referenced = 512,
-        Shared = 1024,
-        PreFinally = 2048,
-        AfterFinally = 4096,
+        Call = 512,
+        Referenced = 1024,
+        Shared = 2048,
+        PreFinally = 4096,
+        AfterFinally = 8192,
         Label = 12,
         Condition = 96
     }
+    export type FlowNode = AfterFinallyFlow | PreFinallyFlow | FlowStart | FlowLabel | FlowAssignment | FlowCall | FlowCondition | FlowSwitchClause | FlowArrayMutation;
+    export interface FlowNodeBase {
+        flags: FlowFlags;
+        id?: number;
+    }
     export interface FlowLock {
         locked?: boolean;
     }
@@ -1686,13 +1697,8 @@ declare namespace ts {
         antecedent: FlowNode;
         lock: FlowLock;
     }
-    export type FlowNode = AfterFinallyFlow | PreFinallyFlow | FlowStart | FlowLabel | FlowAssignment | FlowCondition | FlowSwitchClause | FlowArrayMutation;
-    export interface FlowNodeBase {
-        flags: FlowFlags;
-        id?: number;
-    }
     export interface FlowStart extends FlowNodeBase {
-        container?: FunctionExpression | ArrowFunction | MethodDeclaration;
+        node?: FunctionExpression | ArrowFunction | MethodDeclaration;
     }
     export interface FlowLabel extends FlowNodeBase {
         antecedents: FlowNode[] | undefined;
@@ -1701,8 +1707,12 @@ declare namespace ts {
         node: Expression | VariableDeclaration | BindingElement;
         antecedent: FlowNode;
     }
+    export interface FlowCall extends FlowNodeBase {
+        node: CallExpression;
+        antecedent: FlowNode;
+    }
     export interface FlowCondition extends FlowNodeBase {
-        expression: Expression;
+        node: Expression;
         antecedent: FlowNode;
     }
     export interface FlowSwitchClause extends FlowNodeBase {
@@ -2098,21 +2108,39 @@ declare namespace ts {
     }
     export enum TypePredicateKind {
         This = 0,
-        Identifier = 1
+        Identifier = 1,
+        AssertsThis = 2,
+        AssertsIdentifier = 3
     }
     export interface TypePredicateBase {
         kind: TypePredicateKind;
-        type: Type;
+        type: Type | undefined;
     }
     export interface ThisTypePredicate extends TypePredicateBase {
         kind: TypePredicateKind.This;
+        parameterName: undefined;
+        parameterIndex: undefined;
+        type: Type;
     }
     export interface IdentifierTypePredicate extends TypePredicateBase {
         kind: TypePredicateKind.Identifier;
         parameterName: string;
         parameterIndex: number;
+        type: Type;
     }
-    export type TypePredicate = IdentifierTypePredicate | ThisTypePredicate;
+    export interface AssertsThisTypePredicate extends TypePredicateBase {
+        kind: TypePredicateKind.AssertsThis;
+        parameterName: undefined;
+        parameterIndex: undefined;
+        type: Type | undefined;
+    }
+    export interface AssertsIdentifierTypePredicate extends TypePredicateBase {
+        kind: TypePredicateKind.AssertsIdentifier;
+        parameterName: string;
+        parameterIndex: number;
+        type: Type | undefined;
+    }
+    export type TypePredicate = ThisTypePredicate | IdentifierTypePredicate | AssertsThisTypePredicate | AssertsIdentifierTypePredicate;
     export enum SymbolFlags {
         None = 0,
         FunctionScopedVariable = 1,
@@ -2340,7 +2368,7 @@ declare namespace ts {
         localTypeParameters: TypeParameter[] | undefined;
         thisType: TypeParameter | undefined;
     }
-    export type BaseType = ObjectType | IntersectionType;
+    export type BaseType = ObjectType | IntersectionType | TypeVariable;
     export interface InterfaceTypeWithDeclaredMembers extends InterfaceType {
         declaredProperties: Symbol[];
         declaredCallSignatures: Signature[];
@@ -2539,6 +2567,7 @@ declare namespace ts {
         emitDeclarationOnly?: boolean;
         declarationDir?: string;
         disableSizeLimit?: boolean;
+        disableSourceOfProjectReferenceRedirect?: boolean;
         downlevelIteration?: boolean;
         emitBOM?: boolean;
         emitDecoratorMetadata?: boolean;
@@ -3845,7 +3874,9 @@ declare namespace ts {
     function updateIndexSignature(node: IndexSignatureDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration;
     function createKeywordTypeNode(kind: KeywordTypeNode["kind"]): KeywordTypeNode;
     function createTypePredicateNode(parameterName: Identifier | ThisTypeNode | string, type: TypeNode): TypePredicateNode;
+    function createTypePredicateNodeWithModifier(assertsModifier: AssertsToken | undefined, parameterName: Identifier | ThisTypeNode | string, type: TypeNode | undefined): TypePredicateNode;
     function updateTypePredicateNode(node: TypePredicateNode, parameterName: Identifier | ThisTypeNode, type: TypeNode): TypePredicateNode;
+    function updateTypePredicateNodeWithModifier(node: TypePredicateNode, assertsModifier: AssertsToken | undefined, parameterName: Identifier | ThisTypeNode, type: TypeNode | undefined): TypePredicateNode;
     function createTypeReferenceNode(typeName: string | EntityName, typeArguments: readonly TypeNode[] | undefined): TypeReferenceNode;
     function updateTypeReferenceNode(node: TypeReferenceNode, typeName: EntityName, typeArguments: NodeArray<TypeNode> | undefined): TypeReferenceNode;
     function createFunctionTypeNode(typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined): FunctionTypeNode;
@@ -8499,7 +8530,6 @@ declare namespace ts.server {
         getGlobalProjectErrors(): readonly Diagnostic[];
         getAllProjectErrors(): readonly Diagnostic[];
         getLanguageService(ensureSynchronized?: boolean): LanguageService;
-        private shouldEmitFile;
         getCompileOnSaveAffectedFileList(scriptInfo: ScriptInfo): string[];
         /**
          * Returns true if emit was conducted
@@ -8580,11 +8610,25 @@ declare namespace ts.server {
         private typeAcquisition;
         private directoriesWatchedForWildcards;
         readonly canonicalConfigFilePath: NormalizedPath;
+        private projectReferenceCallbacks;
+        private mapOfDeclarationDirectories;
         /** Ref count to the project when opened from external project */
         private externalProjectRefCount;
         private projectErrors;
         private projectReferences;
         protected isInitialLoadPending: () => boolean;
+        /**
+         * This implementation of fileExists checks if the file being requested is
+         * .d.ts file for the referenced Project.
+         * If it is it returns true irrespective of whether that file exists on host
+         */
+        fileExists(file: string): boolean;
+        /**
+         * This implementation of directoryExists checks if the directory being requested is
+         * directory of .d.ts file for the referenced Project.
+         * If it is it returns true irrespective of whether that directory exists on host
+         */
+        directoryExists(path: string): boolean;
         /**
          * If the project has reload from disk pending, it reloads (and then updates graph as part of that) instead of just updating the graph
          * @returns: true if set of files in the project stays the same and false - otherwise.
diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts
index f0ae718d570..23fd01a86c1 100644
--- a/tests/baselines/reference/api/typescript.d.ts
+++ b/tests/baselines/reference/api/typescript.d.ts
@@ -73,7 +73,7 @@ declare namespace ts {
         end: number;
     }
     export type JSDocSyntaxKind = SyntaxKind.EndOfFileToken | SyntaxKind.WhitespaceTrivia | SyntaxKind.AtToken | SyntaxKind.NewLineTrivia | SyntaxKind.AsteriskToken | SyntaxKind.OpenBraceToken | SyntaxKind.CloseBraceToken | SyntaxKind.LessThanToken | SyntaxKind.GreaterThanToken | SyntaxKind.OpenBracketToken | SyntaxKind.CloseBracketToken | SyntaxKind.EqualsToken | SyntaxKind.CommaToken | SyntaxKind.DotToken | SyntaxKind.Identifier | SyntaxKind.BacktickToken | SyntaxKind.Unknown | KeywordSyntaxKind;
-    export type KeywordSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AnyKeyword | SyntaxKind.AsKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.BreakKeyword | SyntaxKind.CaseKeyword | SyntaxKind.CatchKeyword | SyntaxKind.ClassKeyword | SyntaxKind.ContinueKeyword | SyntaxKind.ConstKeyword | SyntaxKind.ConstructorKeyword | SyntaxKind.DebuggerKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.DeleteKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword | SyntaxKind.EnumKeyword | SyntaxKind.ExportKeyword | SyntaxKind.ExtendsKeyword | SyntaxKind.FalseKeyword | SyntaxKind.FinallyKeyword | SyntaxKind.ForKeyword | SyntaxKind.FromKeyword | SyntaxKind.FunctionKeyword | SyntaxKind.GetKeyword | SyntaxKind.IfKeyword | SyntaxKind.ImplementsKeyword | SyntaxKind.ImportKeyword | SyntaxKind.InKeyword | SyntaxKind.InferKeyword | SyntaxKind.InstanceOfKeyword | SyntaxKind.InterfaceKeyword | SyntaxKind.IsKeyword | SyntaxKind.KeyOfKeyword | SyntaxKind.LetKeyword | SyntaxKind.ModuleKeyword | SyntaxKind.NamespaceKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NewKeyword | SyntaxKind.NullKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.PackageKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.RequireKeyword | SyntaxKind.GlobalKeyword | SyntaxKind.ReturnKeyword | SyntaxKind.SetKeyword | SyntaxKind.StaticKeyword | SyntaxKind.StringKeyword | SyntaxKind.SuperKeyword | SyntaxKind.SwitchKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.ThisKeyword | SyntaxKind.ThrowKeyword | SyntaxKind.TrueKeyword | SyntaxKind.TryKeyword | SyntaxKind.TypeKeyword | SyntaxKind.TypeOfKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VarKeyword | SyntaxKind.VoidKeyword | SyntaxKind.WhileKeyword | SyntaxKind.WithKeyword | SyntaxKind.YieldKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.AwaitKeyword | SyntaxKind.OfKeyword;
+    export type KeywordSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AnyKeyword | SyntaxKind.AsKeyword | SyntaxKind.AssertsKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.BreakKeyword | SyntaxKind.CaseKeyword | SyntaxKind.CatchKeyword | SyntaxKind.ClassKeyword | SyntaxKind.ContinueKeyword | SyntaxKind.ConstKeyword | SyntaxKind.ConstructorKeyword | SyntaxKind.DebuggerKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.DeleteKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword | SyntaxKind.EnumKeyword | SyntaxKind.ExportKeyword | SyntaxKind.ExtendsKeyword | SyntaxKind.FalseKeyword | SyntaxKind.FinallyKeyword | SyntaxKind.ForKeyword | SyntaxKind.FromKeyword | SyntaxKind.FunctionKeyword | SyntaxKind.GetKeyword | SyntaxKind.IfKeyword | SyntaxKind.ImplementsKeyword | SyntaxKind.ImportKeyword | SyntaxKind.InKeyword | SyntaxKind.InferKeyword | SyntaxKind.InstanceOfKeyword | SyntaxKind.InterfaceKeyword | SyntaxKind.IsKeyword | SyntaxKind.KeyOfKeyword | SyntaxKind.LetKeyword | SyntaxKind.ModuleKeyword | SyntaxKind.NamespaceKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NewKeyword | SyntaxKind.NullKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.PackageKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.RequireKeyword | SyntaxKind.GlobalKeyword | SyntaxKind.ReturnKeyword | SyntaxKind.SetKeyword | SyntaxKind.StaticKeyword | SyntaxKind.StringKeyword | SyntaxKind.SuperKeyword | SyntaxKind.SwitchKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.ThisKeyword | SyntaxKind.ThrowKeyword | SyntaxKind.TrueKeyword | SyntaxKind.TryKeyword | SyntaxKind.TypeKeyword | SyntaxKind.TypeOfKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VarKeyword | SyntaxKind.VoidKeyword | SyntaxKind.WhileKeyword | SyntaxKind.WithKeyword | SyntaxKind.YieldKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.AwaitKeyword | SyntaxKind.OfKeyword;
     export type JsxTokenSyntaxKind = SyntaxKind.LessThanSlashToken | SyntaxKind.EndOfFileToken | SyntaxKind.ConflictMarkerTrivia | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.OpenBraceToken | SyntaxKind.LessThanToken;
     export enum SyntaxKind {
         Unknown = 0,
@@ -198,206 +198,207 @@ declare namespace ts {
         YieldKeyword = 118,
         AbstractKeyword = 119,
         AsKeyword = 120,
-        AnyKeyword = 121,
-        AsyncKeyword = 122,
-        AwaitKeyword = 123,
-        BooleanKeyword = 124,
-        ConstructorKeyword = 125,
-        DeclareKeyword = 126,
-        GetKeyword = 127,
-        InferKeyword = 128,
-        IsKeyword = 129,
-        KeyOfKeyword = 130,
-        ModuleKeyword = 131,
-        NamespaceKeyword = 132,
-        NeverKeyword = 133,
-        ReadonlyKeyword = 134,
-        RequireKeyword = 135,
-        NumberKeyword = 136,
-        ObjectKeyword = 137,
-        SetKeyword = 138,
-        StringKeyword = 139,
-        SymbolKeyword = 140,
-        TypeKeyword = 141,
-        UndefinedKeyword = 142,
-        UniqueKeyword = 143,
-        UnknownKeyword = 144,
-        FromKeyword = 145,
-        GlobalKeyword = 146,
-        BigIntKeyword = 147,
-        OfKeyword = 148,
-        QualifiedName = 149,
-        ComputedPropertyName = 150,
-        TypeParameter = 151,
-        Parameter = 152,
-        Decorator = 153,
-        PropertySignature = 154,
-        PropertyDeclaration = 155,
-        MethodSignature = 156,
-        MethodDeclaration = 157,
-        Constructor = 158,
-        GetAccessor = 159,
-        SetAccessor = 160,
-        CallSignature = 161,
-        ConstructSignature = 162,
-        IndexSignature = 163,
-        TypePredicate = 164,
-        TypeReference = 165,
-        FunctionType = 166,
-        ConstructorType = 167,
-        TypeQuery = 168,
-        TypeLiteral = 169,
-        ArrayType = 170,
-        TupleType = 171,
-        OptionalType = 172,
-        RestType = 173,
-        UnionType = 174,
-        IntersectionType = 175,
-        ConditionalType = 176,
-        InferType = 177,
-        ParenthesizedType = 178,
-        ThisType = 179,
-        TypeOperator = 180,
-        IndexedAccessType = 181,
-        MappedType = 182,
-        LiteralType = 183,
-        ImportType = 184,
-        ObjectBindingPattern = 185,
-        ArrayBindingPattern = 186,
-        BindingElement = 187,
-        ArrayLiteralExpression = 188,
-        ObjectLiteralExpression = 189,
-        PropertyAccessExpression = 190,
-        ElementAccessExpression = 191,
-        CallExpression = 192,
-        NewExpression = 193,
-        TaggedTemplateExpression = 194,
-        TypeAssertionExpression = 195,
-        ParenthesizedExpression = 196,
-        FunctionExpression = 197,
-        ArrowFunction = 198,
-        DeleteExpression = 199,
-        TypeOfExpression = 200,
-        VoidExpression = 201,
-        AwaitExpression = 202,
-        PrefixUnaryExpression = 203,
-        PostfixUnaryExpression = 204,
-        BinaryExpression = 205,
-        ConditionalExpression = 206,
-        TemplateExpression = 207,
-        YieldExpression = 208,
-        SpreadElement = 209,
-        ClassExpression = 210,
-        OmittedExpression = 211,
-        ExpressionWithTypeArguments = 212,
-        AsExpression = 213,
-        NonNullExpression = 214,
-        MetaProperty = 215,
-        SyntheticExpression = 216,
-        TemplateSpan = 217,
-        SemicolonClassElement = 218,
-        Block = 219,
-        VariableStatement = 220,
+        AssertsKeyword = 121,
+        AnyKeyword = 122,
+        AsyncKeyword = 123,
+        AwaitKeyword = 124,
+        BooleanKeyword = 125,
+        ConstructorKeyword = 126,
+        DeclareKeyword = 127,
+        GetKeyword = 128,
+        InferKeyword = 129,
+        IsKeyword = 130,
+        KeyOfKeyword = 131,
+        ModuleKeyword = 132,
+        NamespaceKeyword = 133,
+        NeverKeyword = 134,
+        ReadonlyKeyword = 135,
+        RequireKeyword = 136,
+        NumberKeyword = 137,
+        ObjectKeyword = 138,
+        SetKeyword = 139,
+        StringKeyword = 140,
+        SymbolKeyword = 141,
+        TypeKeyword = 142,
+        UndefinedKeyword = 143,
+        UniqueKeyword = 144,
+        UnknownKeyword = 145,
+        FromKeyword = 146,
+        GlobalKeyword = 147,
+        BigIntKeyword = 148,
+        OfKeyword = 149,
+        QualifiedName = 150,
+        ComputedPropertyName = 151,
+        TypeParameter = 152,
+        Parameter = 153,
+        Decorator = 154,
+        PropertySignature = 155,
+        PropertyDeclaration = 156,
+        MethodSignature = 157,
+        MethodDeclaration = 158,
+        Constructor = 159,
+        GetAccessor = 160,
+        SetAccessor = 161,
+        CallSignature = 162,
+        ConstructSignature = 163,
+        IndexSignature = 164,
+        TypePredicate = 165,
+        TypeReference = 166,
+        FunctionType = 167,
+        ConstructorType = 168,
+        TypeQuery = 169,
+        TypeLiteral = 170,
+        ArrayType = 171,
+        TupleType = 172,
+        OptionalType = 173,
+        RestType = 174,
+        UnionType = 175,
+        IntersectionType = 176,
+        ConditionalType = 177,
+        InferType = 178,
+        ParenthesizedType = 179,
+        ThisType = 180,
+        TypeOperator = 181,
+        IndexedAccessType = 182,
+        MappedType = 183,
+        LiteralType = 184,
+        ImportType = 185,
+        ObjectBindingPattern = 186,
+        ArrayBindingPattern = 187,
+        BindingElement = 188,
+        ArrayLiteralExpression = 189,
+        ObjectLiteralExpression = 190,
+        PropertyAccessExpression = 191,
+        ElementAccessExpression = 192,
+        CallExpression = 193,
+        NewExpression = 194,
+        TaggedTemplateExpression = 195,
+        TypeAssertionExpression = 196,
+        ParenthesizedExpression = 197,
+        FunctionExpression = 198,
+        ArrowFunction = 199,
+        DeleteExpression = 200,
+        TypeOfExpression = 201,
+        VoidExpression = 202,
+        AwaitExpression = 203,
+        PrefixUnaryExpression = 204,
+        PostfixUnaryExpression = 205,
+        BinaryExpression = 206,
+        ConditionalExpression = 207,
+        TemplateExpression = 208,
+        YieldExpression = 209,
+        SpreadElement = 210,
+        ClassExpression = 211,
+        OmittedExpression = 212,
+        ExpressionWithTypeArguments = 213,
+        AsExpression = 214,
+        NonNullExpression = 215,
+        MetaProperty = 216,
+        SyntheticExpression = 217,
+        TemplateSpan = 218,
+        SemicolonClassElement = 219,
+        Block = 220,
         EmptyStatement = 221,
-        ExpressionStatement = 222,
-        IfStatement = 223,
-        DoStatement = 224,
-        WhileStatement = 225,
-        ForStatement = 226,
-        ForInStatement = 227,
-        ForOfStatement = 228,
-        ContinueStatement = 229,
-        BreakStatement = 230,
-        ReturnStatement = 231,
-        WithStatement = 232,
-        SwitchStatement = 233,
-        LabeledStatement = 234,
-        ThrowStatement = 235,
-        TryStatement = 236,
-        DebuggerStatement = 237,
-        VariableDeclaration = 238,
-        VariableDeclarationList = 239,
-        FunctionDeclaration = 240,
-        ClassDeclaration = 241,
-        InterfaceDeclaration = 242,
-        TypeAliasDeclaration = 243,
-        EnumDeclaration = 244,
-        ModuleDeclaration = 245,
-        ModuleBlock = 246,
-        CaseBlock = 247,
-        NamespaceExportDeclaration = 248,
-        ImportEqualsDeclaration = 249,
-        ImportDeclaration = 250,
-        ImportClause = 251,
-        NamespaceImport = 252,
-        NamedImports = 253,
-        ImportSpecifier = 254,
-        ExportAssignment = 255,
-        ExportDeclaration = 256,
-        NamedExports = 257,
-        ExportSpecifier = 258,
-        MissingDeclaration = 259,
-        ExternalModuleReference = 260,
-        JsxElement = 261,
-        JsxSelfClosingElement = 262,
-        JsxOpeningElement = 263,
-        JsxClosingElement = 264,
-        JsxFragment = 265,
-        JsxOpeningFragment = 266,
-        JsxClosingFragment = 267,
-        JsxAttribute = 268,
-        JsxAttributes = 269,
-        JsxSpreadAttribute = 270,
-        JsxExpression = 271,
-        CaseClause = 272,
-        DefaultClause = 273,
-        HeritageClause = 274,
-        CatchClause = 275,
-        PropertyAssignment = 276,
-        ShorthandPropertyAssignment = 277,
-        SpreadAssignment = 278,
-        EnumMember = 279,
-        UnparsedPrologue = 280,
-        UnparsedPrepend = 281,
-        UnparsedText = 282,
-        UnparsedInternalText = 283,
-        UnparsedSyntheticReference = 284,
-        SourceFile = 285,
-        Bundle = 286,
-        UnparsedSource = 287,
-        InputFiles = 288,
-        JSDocTypeExpression = 289,
-        JSDocAllType = 290,
-        JSDocUnknownType = 291,
-        JSDocNullableType = 292,
-        JSDocNonNullableType = 293,
-        JSDocOptionalType = 294,
-        JSDocFunctionType = 295,
-        JSDocVariadicType = 296,
-        JSDocNamepathType = 297,
-        JSDocComment = 298,
-        JSDocTypeLiteral = 299,
-        JSDocSignature = 300,
-        JSDocTag = 301,
-        JSDocAugmentsTag = 302,
-        JSDocAuthorTag = 303,
-        JSDocClassTag = 304,
-        JSDocCallbackTag = 305,
-        JSDocEnumTag = 306,
-        JSDocParameterTag = 307,
-        JSDocReturnTag = 308,
-        JSDocThisTag = 309,
-        JSDocTypeTag = 310,
-        JSDocTemplateTag = 311,
-        JSDocTypedefTag = 312,
-        JSDocPropertyTag = 313,
-        SyntaxList = 314,
-        NotEmittedStatement = 315,
-        PartiallyEmittedExpression = 316,
-        CommaListExpression = 317,
-        MergeDeclarationMarker = 318,
-        EndOfDeclarationMarker = 319,
-        Count = 320,
+        VariableStatement = 222,
+        ExpressionStatement = 223,
+        IfStatement = 224,
+        DoStatement = 225,
+        WhileStatement = 226,
+        ForStatement = 227,
+        ForInStatement = 228,
+        ForOfStatement = 229,
+        ContinueStatement = 230,
+        BreakStatement = 231,
+        ReturnStatement = 232,
+        WithStatement = 233,
+        SwitchStatement = 234,
+        LabeledStatement = 235,
+        ThrowStatement = 236,
+        TryStatement = 237,
+        DebuggerStatement = 238,
+        VariableDeclaration = 239,
+        VariableDeclarationList = 240,
+        FunctionDeclaration = 241,
+        ClassDeclaration = 242,
+        InterfaceDeclaration = 243,
+        TypeAliasDeclaration = 244,
+        EnumDeclaration = 245,
+        ModuleDeclaration = 246,
+        ModuleBlock = 247,
+        CaseBlock = 248,
+        NamespaceExportDeclaration = 249,
+        ImportEqualsDeclaration = 250,
+        ImportDeclaration = 251,
+        ImportClause = 252,
+        NamespaceImport = 253,
+        NamedImports = 254,
+        ImportSpecifier = 255,
+        ExportAssignment = 256,
+        ExportDeclaration = 257,
+        NamedExports = 258,
+        ExportSpecifier = 259,
+        MissingDeclaration = 260,
+        ExternalModuleReference = 261,
+        JsxElement = 262,
+        JsxSelfClosingElement = 263,
+        JsxOpeningElement = 264,
+        JsxClosingElement = 265,
+        JsxFragment = 266,
+        JsxOpeningFragment = 267,
+        JsxClosingFragment = 268,
+        JsxAttribute = 269,
+        JsxAttributes = 270,
+        JsxSpreadAttribute = 271,
+        JsxExpression = 272,
+        CaseClause = 273,
+        DefaultClause = 274,
+        HeritageClause = 275,
+        CatchClause = 276,
+        PropertyAssignment = 277,
+        ShorthandPropertyAssignment = 278,
+        SpreadAssignment = 279,
+        EnumMember = 280,
+        UnparsedPrologue = 281,
+        UnparsedPrepend = 282,
+        UnparsedText = 283,
+        UnparsedInternalText = 284,
+        UnparsedSyntheticReference = 285,
+        SourceFile = 286,
+        Bundle = 287,
+        UnparsedSource = 288,
+        InputFiles = 289,
+        JSDocTypeExpression = 290,
+        JSDocAllType = 291,
+        JSDocUnknownType = 292,
+        JSDocNullableType = 293,
+        JSDocNonNullableType = 294,
+        JSDocOptionalType = 295,
+        JSDocFunctionType = 296,
+        JSDocVariadicType = 297,
+        JSDocNamepathType = 298,
+        JSDocComment = 299,
+        JSDocTypeLiteral = 300,
+        JSDocSignature = 301,
+        JSDocTag = 302,
+        JSDocAugmentsTag = 303,
+        JSDocAuthorTag = 304,
+        JSDocClassTag = 305,
+        JSDocCallbackTag = 306,
+        JSDocEnumTag = 307,
+        JSDocParameterTag = 308,
+        JSDocReturnTag = 309,
+        JSDocThisTag = 310,
+        JSDocTypeTag = 311,
+        JSDocTemplateTag = 312,
+        JSDocTypedefTag = 313,
+        JSDocPropertyTag = 314,
+        SyntaxList = 315,
+        NotEmittedStatement = 316,
+        PartiallyEmittedExpression = 317,
+        CommaListExpression = 318,
+        MergeDeclarationMarker = 319,
+        EndOfDeclarationMarker = 320,
+        Count = 321,
         FirstAssignment = 60,
         LastAssignment = 72,
         FirstCompoundAssignment = 61,
@@ -405,15 +406,15 @@ declare namespace ts {
         FirstReservedWord = 74,
         LastReservedWord = 109,
         FirstKeyword = 74,
-        LastKeyword = 148,
+        LastKeyword = 149,
         FirstFutureReservedWord = 110,
         LastFutureReservedWord = 118,
-        FirstTypeNode = 164,
-        LastTypeNode = 184,
+        FirstTypeNode = 165,
+        LastTypeNode = 185,
         FirstPunctuation = 18,
         LastPunctuation = 72,
         FirstToken = 0,
-        LastToken = 148,
+        LastToken = 149,
         FirstTriviaToken = 2,
         LastTriviaToken = 7,
         FirstLiteralToken = 8,
@@ -422,11 +423,13 @@ declare namespace ts {
         LastTemplateToken = 17,
         FirstBinaryOperator = 28,
         LastBinaryOperator = 72,
-        FirstNode = 149,
-        FirstJSDocNode = 289,
-        LastJSDocNode = 313,
-        FirstJSDocTagNode = 301,
-        LastJSDocTagNode = 313,
+        FirstStatement = 222,
+        LastStatement = 238,
+        FirstNode = 150,
+        FirstJSDocNode = 290,
+        LastJSDocNode = 314,
+        FirstJSDocTagNode = 302,
+        LastJSDocTagNode = 314,
     }
     export enum NodeFlags {
         None = 0,
@@ -517,6 +520,7 @@ declare namespace ts {
     export type AwaitKeywordToken = Token<SyntaxKind.AwaitKeyword>;
     export type PlusToken = Token<SyntaxKind.PlusToken>;
     export type MinusToken = Token<SyntaxKind.MinusToken>;
+    export type AssertsToken = Token<SyntaxKind.AssertsKeyword>;
     export type Modifier = Token<SyntaxKind.AbstractKeyword> | Token<SyntaxKind.AsyncKeyword> | Token<SyntaxKind.ConstKeyword> | Token<SyntaxKind.DeclareKeyword> | Token<SyntaxKind.DefaultKeyword> | Token<SyntaxKind.ExportKeyword> | Token<SyntaxKind.PublicKeyword> | Token<SyntaxKind.PrivateKeyword> | Token<SyntaxKind.ProtectedKeyword> | Token<SyntaxKind.ReadonlyKeyword> | Token<SyntaxKind.StaticKeyword>;
     export type ModifiersArray = NodeArray<Modifier>;
     export interface Identifier extends PrimaryExpression, Declaration {
@@ -770,8 +774,9 @@ declare namespace ts {
     export interface TypePredicateNode extends TypeNode {
         kind: SyntaxKind.TypePredicate;
         parent: SignatureDeclaration | JSDocTypeExpression;
+        assertsModifier?: AssertsToken;
         parameterName: Identifier | ThisTypeNode;
-        type: TypeNode;
+        type?: TypeNode;
     }
     export interface TypeQueryNode extends TypeNode {
         kind: SyntaxKind.TypeQuery;
@@ -1669,13 +1674,19 @@ declare namespace ts {
         FalseCondition = 64,
         SwitchClause = 128,
         ArrayMutation = 256,
-        Referenced = 512,
-        Shared = 1024,
-        PreFinally = 2048,
-        AfterFinally = 4096,
+        Call = 512,
+        Referenced = 1024,
+        Shared = 2048,
+        PreFinally = 4096,
+        AfterFinally = 8192,
         Label = 12,
         Condition = 96
     }
+    export type FlowNode = AfterFinallyFlow | PreFinallyFlow | FlowStart | FlowLabel | FlowAssignment | FlowCall | FlowCondition | FlowSwitchClause | FlowArrayMutation;
+    export interface FlowNodeBase {
+        flags: FlowFlags;
+        id?: number;
+    }
     export interface FlowLock {
         locked?: boolean;
     }
@@ -1686,13 +1697,8 @@ declare namespace ts {
         antecedent: FlowNode;
         lock: FlowLock;
     }
-    export type FlowNode = AfterFinallyFlow | PreFinallyFlow | FlowStart | FlowLabel | FlowAssignment | FlowCondition | FlowSwitchClause | FlowArrayMutation;
-    export interface FlowNodeBase {
-        flags: FlowFlags;
-        id?: number;
-    }
     export interface FlowStart extends FlowNodeBase {
-        container?: FunctionExpression | ArrowFunction | MethodDeclaration;
+        node?: FunctionExpression | ArrowFunction | MethodDeclaration;
     }
     export interface FlowLabel extends FlowNodeBase {
         antecedents: FlowNode[] | undefined;
@@ -1701,8 +1707,12 @@ declare namespace ts {
         node: Expression | VariableDeclaration | BindingElement;
         antecedent: FlowNode;
     }
+    export interface FlowCall extends FlowNodeBase {
+        node: CallExpression;
+        antecedent: FlowNode;
+    }
     export interface FlowCondition extends FlowNodeBase {
-        expression: Expression;
+        node: Expression;
         antecedent: FlowNode;
     }
     export interface FlowSwitchClause extends FlowNodeBase {
@@ -2098,21 +2108,39 @@ declare namespace ts {
     }
     export enum TypePredicateKind {
         This = 0,
-        Identifier = 1
+        Identifier = 1,
+        AssertsThis = 2,
+        AssertsIdentifier = 3
     }
     export interface TypePredicateBase {
         kind: TypePredicateKind;
-        type: Type;
+        type: Type | undefined;
     }
     export interface ThisTypePredicate extends TypePredicateBase {
         kind: TypePredicateKind.This;
+        parameterName: undefined;
+        parameterIndex: undefined;
+        type: Type;
     }
     export interface IdentifierTypePredicate extends TypePredicateBase {
         kind: TypePredicateKind.Identifier;
         parameterName: string;
         parameterIndex: number;
+        type: Type;
     }
-    export type TypePredicate = IdentifierTypePredicate | ThisTypePredicate;
+    export interface AssertsThisTypePredicate extends TypePredicateBase {
+        kind: TypePredicateKind.AssertsThis;
+        parameterName: undefined;
+        parameterIndex: undefined;
+        type: Type | undefined;
+    }
+    export interface AssertsIdentifierTypePredicate extends TypePredicateBase {
+        kind: TypePredicateKind.AssertsIdentifier;
+        parameterName: string;
+        parameterIndex: number;
+        type: Type | undefined;
+    }
+    export type TypePredicate = ThisTypePredicate | IdentifierTypePredicate | AssertsThisTypePredicate | AssertsIdentifierTypePredicate;
     export enum SymbolFlags {
         None = 0,
         FunctionScopedVariable = 1,
@@ -2340,7 +2368,7 @@ declare namespace ts {
         localTypeParameters: TypeParameter[] | undefined;
         thisType: TypeParameter | undefined;
     }
-    export type BaseType = ObjectType | IntersectionType;
+    export type BaseType = ObjectType | IntersectionType | TypeVariable;
     export interface InterfaceTypeWithDeclaredMembers extends InterfaceType {
         declaredProperties: Symbol[];
         declaredCallSignatures: Signature[];
@@ -2539,6 +2567,7 @@ declare namespace ts {
         emitDeclarationOnly?: boolean;
         declarationDir?: string;
         disableSizeLimit?: boolean;
+        disableSourceOfProjectReferenceRedirect?: boolean;
         downlevelIteration?: boolean;
         emitBOM?: boolean;
         emitDecoratorMetadata?: boolean;
@@ -3845,7 +3874,9 @@ declare namespace ts {
     function updateIndexSignature(node: IndexSignatureDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration;
     function createKeywordTypeNode(kind: KeywordTypeNode["kind"]): KeywordTypeNode;
     function createTypePredicateNode(parameterName: Identifier | ThisTypeNode | string, type: TypeNode): TypePredicateNode;
+    function createTypePredicateNodeWithModifier(assertsModifier: AssertsToken | undefined, parameterName: Identifier | ThisTypeNode | string, type: TypeNode | undefined): TypePredicateNode;
     function updateTypePredicateNode(node: TypePredicateNode, parameterName: Identifier | ThisTypeNode, type: TypeNode): TypePredicateNode;
+    function updateTypePredicateNodeWithModifier(node: TypePredicateNode, assertsModifier: AssertsToken | undefined, parameterName: Identifier | ThisTypeNode, type: TypeNode | undefined): TypePredicateNode;
     function createTypeReferenceNode(typeName: string | EntityName, typeArguments: readonly TypeNode[] | undefined): TypeReferenceNode;
     function updateTypeReferenceNode(node: TypeReferenceNode, typeName: EntityName, typeArguments: NodeArray<TypeNode> | undefined): TypeReferenceNode;
     function createFunctionTypeNode(typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined): FunctionTypeNode;
diff --git a/tests/baselines/reference/arrayLiterals3.errors.txt b/tests/baselines/reference/arrayLiterals3.errors.txt
index 4d398978c96..5f592b74f3e 100644
--- a/tests/baselines/reference/arrayLiterals3.errors.txt
+++ b/tests/baselines/reference/arrayLiterals3.errors.txt
@@ -8,10 +8,9 @@ tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts(17,5): error
 tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts(32,5): error TS2739: Type '(number[] | string[])[]' is missing the following properties from type 'tup': 0, 1
 tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts(33,5): error TS2739: Type 'number[]' is missing the following properties from type '[number, number, number]': 0, 1, 2
 tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts(34,5): error TS2322: Type '(string | number)[]' is not assignable to type 'myArray'.
-  Types of property 'pop' are incompatible.
-    Type '() => string | number' is not assignable to type '() => Number'.
-      Type 'string | number' is not assignable to type 'Number'.
-        Type 'string' is not assignable to type 'Number'.
+  The types returned by 'pop()' are incompatible between these types.
+    Type 'string | number' is not assignable to type 'Number'.
+      Type 'string' is not assignable to type 'Number'.
 
 
 ==== tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts (8 errors) ====
@@ -67,8 +66,7 @@ tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts(34,5): error
     var c2: myArray = [...temp1, ...temp];            // Error cannot assign (number|string)[] to number[]
         ~~
 !!! error TS2322: Type '(string | number)[]' is not assignable to type 'myArray'.
-!!! error TS2322:   Types of property 'pop' are incompatible.
-!!! error TS2322:     Type '() => string | number' is not assignable to type '() => Number'.
-!!! error TS2322:       Type 'string | number' is not assignable to type 'Number'.
-!!! error TS2322:         Type 'string' is not assignable to type 'Number'.
+!!! error TS2322:   The types returned by 'pop()' are incompatible between these types.
+!!! error TS2322:     Type 'string | number' is not assignable to type 'Number'.
+!!! error TS2322:       Type 'string' is not assignable to type 'Number'.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.errors.txt b/tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.errors.txt
index 63d3a6f7b64..66b3c2c8691 100644
--- a/tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.errors.txt
+++ b/tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.errors.txt
@@ -1,10 +1,9 @@
 tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts(13,1): error TS2322: Type 'A[]' is not assignable to type 'readonly B[]'.
   Property 'b' is missing in type 'A' but required in type 'B'.
 tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts(18,1): error TS2322: Type 'C<A>' is not assignable to type 'readonly B[]'.
-  Types of property 'concat' are incompatible.
-    Type '{ (...items: ConcatArray<A>[]): A[]; (...items: (A | ConcatArray<A>)[]): A[]; }' is not assignable to type '{ (...items: ConcatArray<B>[]): B[]; (...items: (B | ConcatArray<B>)[]): B[]; }'.
-      Type 'A[]' is not assignable to type 'B[]'.
-        Type 'A' is not assignable to type 'B'.
+  The types returned by 'concat(...)' are incompatible between these types.
+    Type 'A[]' is not assignable to type 'B[]'.
+      Type 'A' is not assignable to type 'B'.
 
 
 ==== tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts (2 errors) ====
@@ -32,8 +31,7 @@ tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts(18,1): error T
     rrb = cra; // error: 'A' is not assignable to 'B'
     ~~~
 !!! error TS2322: Type 'C<A>' is not assignable to type 'readonly B[]'.
-!!! error TS2322:   Types of property 'concat' are incompatible.
-!!! error TS2322:     Type '{ (...items: ConcatArray<A>[]): A[]; (...items: (A | ConcatArray<A>)[]): A[]; }' is not assignable to type '{ (...items: ConcatArray<B>[]): B[]; (...items: (B | ConcatArray<B>)[]): B[]; }'.
-!!! error TS2322:       Type 'A[]' is not assignable to type 'B[]'.
-!!! error TS2322:         Type 'A' is not assignable to type 'B'.
+!!! error TS2322:   The types returned by 'concat(...)' are incompatible between these types.
+!!! error TS2322:     Type 'A[]' is not assignable to type 'B[]'.
+!!! error TS2322:       Type 'A' is not assignable to type 'B'.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/assertionTypePredicates1.errors.txt b/tests/baselines/reference/assertionTypePredicates1.errors.txt
new file mode 100644
index 00000000000..91d2e869bd2
--- /dev/null
+++ b/tests/baselines/reference/assertionTypePredicates1.errors.txt
@@ -0,0 +1,150 @@
+tests/cases/conformance/controlFlow/assertionTypePredicates1.ts(116,37): error TS1228: A type predicate is only allowed in return type position for functions and methods.
+tests/cases/conformance/controlFlow/assertionTypePredicates1.ts(117,37): error TS1228: A type predicate is only allowed in return type position for functions and methods.
+tests/cases/conformance/controlFlow/assertionTypePredicates1.ts(118,37): error TS1228: A type predicate is only allowed in return type position for functions and methods.
+tests/cases/conformance/controlFlow/assertionTypePredicates1.ts(121,15): error TS1228: A type predicate is only allowed in return type position for functions and methods.
+tests/cases/conformance/controlFlow/assertionTypePredicates1.ts(122,15): error TS1228: A type predicate is only allowed in return type position for functions and methods.
+tests/cases/conformance/controlFlow/assertionTypePredicates1.ts(123,15): error TS1228: A type predicate is only allowed in return type position for functions and methods.
+tests/cases/conformance/controlFlow/assertionTypePredicates1.ts(124,15): error TS1228: A type predicate is only allowed in return type position for functions and methods.
+
+
+==== tests/cases/conformance/controlFlow/assertionTypePredicates1.ts (7 errors) ====
+    declare function isString(value: unknown): value is string;
+    declare function isArrayOfStrings(value: unknown): value is string[];
+    
+    const assert: (value: unknown) => asserts value = value => {}
+    
+    declare function assertIsString(value: unknown): asserts value is string;
+    declare function assertIsArrayOfStrings(value: unknown): asserts value is string[];
+    declare function assertDefined<T>(value: T): asserts value is NonNullable<T>;
+    
+    function f01(x: unknown) {
+        if (!!true) {
+            assert(typeof x === "string");
+            x.length;
+        }
+        if (!!true) {
+            assert(x instanceof Error);
+            x.message;
+        }
+        if (!!true) {
+            assert(typeof x === "boolean" || typeof x === "number");
+            x.toLocaleString;
+        }
+        if (!!true) {
+            assert(isArrayOfStrings(x));
+            x[0].length;
+        }
+        if (!!true) {
+            assertIsArrayOfStrings(x);
+            x[0].length;
+        }
+        if (!!true) {
+            assert(x === undefined || typeof x === "string");
+            x;  // string | undefined
+            assertDefined(x);
+            x;  // string
+        }
+    }
+    
+    function f02(x: string | undefined) {
+        if (!!true) {
+            assert(x);
+            x.length;
+        }
+        if (!!true) {
+            assert(x !== undefined);
+            x.length;
+        }
+        if (!!true) {
+            assertDefined(x);
+            x.length;
+        }
+    }
+    
+    function f03(x: string | undefined, assert: (value: unknown) => asserts value) {
+        assert(x);
+        x.length;
+    }
+    
+    namespace Debug {
+        export declare function assert(value: unknown, message?: string): asserts value;
+        export declare function assertDefined<T>(value: T): asserts value is NonNullable<T>;
+    }
+    
+    function f10(x: string | undefined) {
+        if (!!true) {
+            Debug.assert(x);
+            x.length;
+        }
+        if (!!true) {
+            Debug.assert(x !== undefined);
+            x.length;
+        }
+        if (!!true) {
+            Debug.assertDefined(x);
+            x.length;
+        }
+    }
+    
+    class Test {
+        assert(value: unknown): asserts value {
+            if (value) return;
+            throw new Error();
+        }
+        isTest2(): this is Test2 {
+            return this instanceof Test2;
+        }
+        assertIsTest2(): asserts this is Test2 {
+            if (this instanceof Test2) return;
+            throw new Error();
+        }
+        assertThis(): asserts this {
+            if (!this) return;
+            throw new Error();
+        }
+        bar() {
+            this.assertThis();
+            this;
+        }
+        foo(x: unknown) {
+            this.assert(typeof x === "string");
+            x.length;
+            if (this.isTest2()) {
+                this.z;
+            }
+            this.assertIsTest2();
+            this.z;
+        }
+    }
+    
+    class Test2 extends Test {
+        z = 0;
+    }
+    
+    // Invalid constructs
+    
+    declare let Q1: new (x: unknown) => x is string;
+                                        ~~~~~~~~~~~
+!!! error TS1228: A type predicate is only allowed in return type position for functions and methods.
+    declare let Q2: new (x: boolean) => asserts x;
+                                        ~~~~~~~~~
+!!! error TS1228: A type predicate is only allowed in return type position for functions and methods.
+    declare let Q3: new (x: unknown) => asserts x is string;
+                                        ~~~~~~~~~~~~~~~~~~~
+!!! error TS1228: A type predicate is only allowed in return type position for functions and methods.
+    
+    declare class Wat {
+        get p1(): this is string;
+                  ~~~~~~~~~~~~~~
+!!! error TS1228: A type predicate is only allowed in return type position for functions and methods.
+        set p1(x: this is string);
+                  ~~~~~~~~~~~~~~
+!!! error TS1228: A type predicate is only allowed in return type position for functions and methods.
+        get p2(): asserts this is string;
+                  ~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1228: A type predicate is only allowed in return type position for functions and methods.
+        set p2(x: asserts this is string);
+                  ~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1228: A type predicate is only allowed in return type position for functions and methods.
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/assertionTypePredicates1.js b/tests/baselines/reference/assertionTypePredicates1.js
new file mode 100644
index 00000000000..ad21d116b73
--- /dev/null
+++ b/tests/baselines/reference/assertionTypePredicates1.js
@@ -0,0 +1,289 @@
+//// [assertionTypePredicates1.ts]
+declare function isString(value: unknown): value is string;
+declare function isArrayOfStrings(value: unknown): value is string[];
+
+const assert: (value: unknown) => asserts value = value => {}
+
+declare function assertIsString(value: unknown): asserts value is string;
+declare function assertIsArrayOfStrings(value: unknown): asserts value is string[];
+declare function assertDefined<T>(value: T): asserts value is NonNullable<T>;
+
+function f01(x: unknown) {
+    if (!!true) {
+        assert(typeof x === "string");
+        x.length;
+    }
+    if (!!true) {
+        assert(x instanceof Error);
+        x.message;
+    }
+    if (!!true) {
+        assert(typeof x === "boolean" || typeof x === "number");
+        x.toLocaleString;
+    }
+    if (!!true) {
+        assert(isArrayOfStrings(x));
+        x[0].length;
+    }
+    if (!!true) {
+        assertIsArrayOfStrings(x);
+        x[0].length;
+    }
+    if (!!true) {
+        assert(x === undefined || typeof x === "string");
+        x;  // string | undefined
+        assertDefined(x);
+        x;  // string
+    }
+}
+
+function f02(x: string | undefined) {
+    if (!!true) {
+        assert(x);
+        x.length;
+    }
+    if (!!true) {
+        assert(x !== undefined);
+        x.length;
+    }
+    if (!!true) {
+        assertDefined(x);
+        x.length;
+    }
+}
+
+function f03(x: string | undefined, assert: (value: unknown) => asserts value) {
+    assert(x);
+    x.length;
+}
+
+namespace Debug {
+    export declare function assert(value: unknown, message?: string): asserts value;
+    export declare function assertDefined<T>(value: T): asserts value is NonNullable<T>;
+}
+
+function f10(x: string | undefined) {
+    if (!!true) {
+        Debug.assert(x);
+        x.length;
+    }
+    if (!!true) {
+        Debug.assert(x !== undefined);
+        x.length;
+    }
+    if (!!true) {
+        Debug.assertDefined(x);
+        x.length;
+    }
+}
+
+class Test {
+    assert(value: unknown): asserts value {
+        if (value) return;
+        throw new Error();
+    }
+    isTest2(): this is Test2 {
+        return this instanceof Test2;
+    }
+    assertIsTest2(): asserts this is Test2 {
+        if (this instanceof Test2) return;
+        throw new Error();
+    }
+    assertThis(): asserts this {
+        if (!this) return;
+        throw new Error();
+    }
+    bar() {
+        this.assertThis();
+        this;
+    }
+    foo(x: unknown) {
+        this.assert(typeof x === "string");
+        x.length;
+        if (this.isTest2()) {
+            this.z;
+        }
+        this.assertIsTest2();
+        this.z;
+    }
+}
+
+class Test2 extends Test {
+    z = 0;
+}
+
+// Invalid constructs
+
+declare let Q1: new (x: unknown) => x is string;
+declare let Q2: new (x: boolean) => asserts x;
+declare let Q3: new (x: unknown) => asserts x is string;
+
+declare class Wat {
+    get p1(): this is string;
+    set p1(x: this is string);
+    get p2(): asserts this is string;
+    set p2(x: asserts this is string);
+}
+
+
+//// [assertionTypePredicates1.js]
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var assert = function (value) { };
+function f01(x) {
+    if (!!true) {
+        assert(typeof x === "string");
+        x.length;
+    }
+    if (!!true) {
+        assert(x instanceof Error);
+        x.message;
+    }
+    if (!!true) {
+        assert(typeof x === "boolean" || typeof x === "number");
+        x.toLocaleString;
+    }
+    if (!!true) {
+        assert(isArrayOfStrings(x));
+        x[0].length;
+    }
+    if (!!true) {
+        assertIsArrayOfStrings(x);
+        x[0].length;
+    }
+    if (!!true) {
+        assert(x === undefined || typeof x === "string");
+        x; // string | undefined
+        assertDefined(x);
+        x; // string
+    }
+}
+function f02(x) {
+    if (!!true) {
+        assert(x);
+        x.length;
+    }
+    if (!!true) {
+        assert(x !== undefined);
+        x.length;
+    }
+    if (!!true) {
+        assertDefined(x);
+        x.length;
+    }
+}
+function f03(x, assert) {
+    assert(x);
+    x.length;
+}
+var Debug;
+(function (Debug) {
+})(Debug || (Debug = {}));
+function f10(x) {
+    if (!!true) {
+        Debug.assert(x);
+        x.length;
+    }
+    if (!!true) {
+        Debug.assert(x !== undefined);
+        x.length;
+    }
+    if (!!true) {
+        Debug.assertDefined(x);
+        x.length;
+    }
+}
+var Test = /** @class */ (function () {
+    function Test() {
+    }
+    Test.prototype.assert = function (value) {
+        if (value)
+            return;
+        throw new Error();
+    };
+    Test.prototype.isTest2 = function () {
+        return this instanceof Test2;
+    };
+    Test.prototype.assertIsTest2 = function () {
+        if (this instanceof Test2)
+            return;
+        throw new Error();
+    };
+    Test.prototype.assertThis = function () {
+        if (!this)
+            return;
+        throw new Error();
+    };
+    Test.prototype.bar = function () {
+        this.assertThis();
+        this;
+    };
+    Test.prototype.foo = function (x) {
+        this.assert(typeof x === "string");
+        x.length;
+        if (this.isTest2()) {
+            this.z;
+        }
+        this.assertIsTest2();
+        this.z;
+    };
+    return Test;
+}());
+var Test2 = /** @class */ (function (_super) {
+    __extends(Test2, _super);
+    function Test2() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.z = 0;
+        return _this;
+    }
+    return Test2;
+}(Test));
+
+
+//// [assertionTypePredicates1.d.ts]
+declare function isString(value: unknown): value is string;
+declare function isArrayOfStrings(value: unknown): value is string[];
+declare const assert: (value: unknown) => asserts value;
+declare function assertIsString(value: unknown): asserts value is string;
+declare function assertIsArrayOfStrings(value: unknown): asserts value is string[];
+declare function assertDefined<T>(value: T): asserts value is NonNullable<T>;
+declare function f01(x: unknown): void;
+declare function f02(x: string | undefined): void;
+declare function f03(x: string | undefined, assert: (value: unknown) => asserts value): void;
+declare namespace Debug {
+    function assert(value: unknown, message?: string): asserts value;
+    function assertDefined<T>(value: T): asserts value is NonNullable<T>;
+}
+declare function f10(x: string | undefined): void;
+declare class Test {
+    assert(value: unknown): asserts value;
+    isTest2(): this is Test2;
+    assertIsTest2(): asserts this is Test2;
+    assertThis(): asserts this;
+    bar(): void;
+    foo(x: unknown): void;
+}
+declare class Test2 extends Test {
+    z: number;
+}
+declare let Q1: new (x: unknown) => x is string;
+declare let Q2: new (x: boolean) => asserts x;
+declare let Q3: new (x: unknown) => asserts x is string;
+declare class Wat {
+    get p1(): this is string;
+    set p1(x: this is string);
+    get p2(): asserts this is string;
+    set p2(x: asserts this is string);
+}
diff --git a/tests/baselines/reference/assertionTypePredicates1.symbols b/tests/baselines/reference/assertionTypePredicates1.symbols
new file mode 100644
index 00000000000..c68a1926aff
--- /dev/null
+++ b/tests/baselines/reference/assertionTypePredicates1.symbols
@@ -0,0 +1,359 @@
+=== tests/cases/conformance/controlFlow/assertionTypePredicates1.ts ===
+declare function isString(value: unknown): value is string;
+>isString : Symbol(isString, Decl(assertionTypePredicates1.ts, 0, 0))
+>value : Symbol(value, Decl(assertionTypePredicates1.ts, 0, 26))
+>value : Symbol(value, Decl(assertionTypePredicates1.ts, 0, 26))
+
+declare function isArrayOfStrings(value: unknown): value is string[];
+>isArrayOfStrings : Symbol(isArrayOfStrings, Decl(assertionTypePredicates1.ts, 0, 59))
+>value : Symbol(value, Decl(assertionTypePredicates1.ts, 1, 34))
+>value : Symbol(value, Decl(assertionTypePredicates1.ts, 1, 34))
+
+const assert: (value: unknown) => asserts value = value => {}
+>assert : Symbol(assert, Decl(assertionTypePredicates1.ts, 3, 5))
+>value : Symbol(value, Decl(assertionTypePredicates1.ts, 3, 15))
+>value : Symbol(value, Decl(assertionTypePredicates1.ts, 3, 15))
+>value : Symbol(value, Decl(assertionTypePredicates1.ts, 3, 49))
+
+declare function assertIsString(value: unknown): asserts value is string;
+>assertIsString : Symbol(assertIsString, Decl(assertionTypePredicates1.ts, 3, 61))
+>value : Symbol(value, Decl(assertionTypePredicates1.ts, 5, 32))
+>value : Symbol(value, Decl(assertionTypePredicates1.ts, 5, 32))
+
+declare function assertIsArrayOfStrings(value: unknown): asserts value is string[];
+>assertIsArrayOfStrings : Symbol(assertIsArrayOfStrings, Decl(assertionTypePredicates1.ts, 5, 73))
+>value : Symbol(value, Decl(assertionTypePredicates1.ts, 6, 40))
+>value : Symbol(value, Decl(assertionTypePredicates1.ts, 6, 40))
+
+declare function assertDefined<T>(value: T): asserts value is NonNullable<T>;
+>assertDefined : Symbol(assertDefined, Decl(assertionTypePredicates1.ts, 6, 83))
+>T : Symbol(T, Decl(assertionTypePredicates1.ts, 7, 31))
+>value : Symbol(value, Decl(assertionTypePredicates1.ts, 7, 34))
+>T : Symbol(T, Decl(assertionTypePredicates1.ts, 7, 31))
+>value : Symbol(value, Decl(assertionTypePredicates1.ts, 7, 34))
+>NonNullable : Symbol(NonNullable, Decl(lib.es5.d.ts, --, --))
+>T : Symbol(T, Decl(assertionTypePredicates1.ts, 7, 31))
+
+function f01(x: unknown) {
+>f01 : Symbol(f01, Decl(assertionTypePredicates1.ts, 7, 77))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 9, 13))
+
+    if (!!true) {
+        assert(typeof x === "string");
+>assert : Symbol(assert, Decl(assertionTypePredicates1.ts, 3, 5))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 9, 13))
+
+        x.length;
+>x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 9, 13))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+    }
+    if (!!true) {
+        assert(x instanceof Error);
+>assert : Symbol(assert, Decl(assertionTypePredicates1.ts, 3, 5))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 9, 13))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+
+        x.message;
+>x.message : Symbol(Error.message, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 9, 13))
+>message : Symbol(Error.message, Decl(lib.es5.d.ts, --, --))
+    }
+    if (!!true) {
+        assert(typeof x === "boolean" || typeof x === "number");
+>assert : Symbol(assert, Decl(assertionTypePredicates1.ts, 3, 5))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 9, 13))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 9, 13))
+
+        x.toLocaleString;
+>x.toLocaleString : Symbol(toLocaleString, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 9, 13))
+>toLocaleString : Symbol(toLocaleString, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+    }
+    if (!!true) {
+        assert(isArrayOfStrings(x));
+>assert : Symbol(assert, Decl(assertionTypePredicates1.ts, 3, 5))
+>isArrayOfStrings : Symbol(isArrayOfStrings, Decl(assertionTypePredicates1.ts, 0, 59))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 9, 13))
+
+        x[0].length;
+>x[0].length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 9, 13))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+    }
+    if (!!true) {
+        assertIsArrayOfStrings(x);
+>assertIsArrayOfStrings : Symbol(assertIsArrayOfStrings, Decl(assertionTypePredicates1.ts, 5, 73))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 9, 13))
+
+        x[0].length;
+>x[0].length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 9, 13))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+    }
+    if (!!true) {
+        assert(x === undefined || typeof x === "string");
+>assert : Symbol(assert, Decl(assertionTypePredicates1.ts, 3, 5))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 9, 13))
+>undefined : Symbol(undefined)
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 9, 13))
+
+        x;  // string | undefined
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 9, 13))
+
+        assertDefined(x);
+>assertDefined : Symbol(assertDefined, Decl(assertionTypePredicates1.ts, 6, 83))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 9, 13))
+
+        x;  // string
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 9, 13))
+    }
+}
+
+function f02(x: string | undefined) {
+>f02 : Symbol(f02, Decl(assertionTypePredicates1.ts, 36, 1))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 38, 13))
+
+    if (!!true) {
+        assert(x);
+>assert : Symbol(assert, Decl(assertionTypePredicates1.ts, 3, 5))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 38, 13))
+
+        x.length;
+>x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 38, 13))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+    }
+    if (!!true) {
+        assert(x !== undefined);
+>assert : Symbol(assert, Decl(assertionTypePredicates1.ts, 3, 5))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 38, 13))
+>undefined : Symbol(undefined)
+
+        x.length;
+>x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 38, 13))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+    }
+    if (!!true) {
+        assertDefined(x);
+>assertDefined : Symbol(assertDefined, Decl(assertionTypePredicates1.ts, 6, 83))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 38, 13))
+
+        x.length;
+>x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 38, 13))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+    }
+}
+
+function f03(x: string | undefined, assert: (value: unknown) => asserts value) {
+>f03 : Symbol(f03, Decl(assertionTypePredicates1.ts, 51, 1))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 53, 13))
+>assert : Symbol(assert, Decl(assertionTypePredicates1.ts, 53, 35))
+>value : Symbol(value, Decl(assertionTypePredicates1.ts, 53, 45))
+>value : Symbol(value, Decl(assertionTypePredicates1.ts, 53, 45))
+
+    assert(x);
+>assert : Symbol(assert, Decl(assertionTypePredicates1.ts, 53, 35))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 53, 13))
+
+    x.length;
+>x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 53, 13))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+}
+
+namespace Debug {
+>Debug : Symbol(Debug, Decl(assertionTypePredicates1.ts, 56, 1))
+
+    export declare function assert(value: unknown, message?: string): asserts value;
+>assert : Symbol(assert, Decl(assertionTypePredicates1.ts, 58, 17))
+>value : Symbol(value, Decl(assertionTypePredicates1.ts, 59, 35))
+>message : Symbol(message, Decl(assertionTypePredicates1.ts, 59, 50))
+>value : Symbol(value, Decl(assertionTypePredicates1.ts, 59, 35))
+
+    export declare function assertDefined<T>(value: T): asserts value is NonNullable<T>;
+>assertDefined : Symbol(assertDefined, Decl(assertionTypePredicates1.ts, 59, 84))
+>T : Symbol(T, Decl(assertionTypePredicates1.ts, 60, 42))
+>value : Symbol(value, Decl(assertionTypePredicates1.ts, 60, 45))
+>T : Symbol(T, Decl(assertionTypePredicates1.ts, 60, 42))
+>value : Symbol(value, Decl(assertionTypePredicates1.ts, 60, 45))
+>NonNullable : Symbol(NonNullable, Decl(lib.es5.d.ts, --, --))
+>T : Symbol(T, Decl(assertionTypePredicates1.ts, 60, 42))
+}
+
+function f10(x: string | undefined) {
+>f10 : Symbol(f10, Decl(assertionTypePredicates1.ts, 61, 1))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 63, 13))
+
+    if (!!true) {
+        Debug.assert(x);
+>Debug.assert : Symbol(Debug.assert, Decl(assertionTypePredicates1.ts, 58, 17))
+>Debug : Symbol(Debug, Decl(assertionTypePredicates1.ts, 56, 1))
+>assert : Symbol(Debug.assert, Decl(assertionTypePredicates1.ts, 58, 17))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 63, 13))
+
+        x.length;
+>x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 63, 13))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+    }
+    if (!!true) {
+        Debug.assert(x !== undefined);
+>Debug.assert : Symbol(Debug.assert, Decl(assertionTypePredicates1.ts, 58, 17))
+>Debug : Symbol(Debug, Decl(assertionTypePredicates1.ts, 56, 1))
+>assert : Symbol(Debug.assert, Decl(assertionTypePredicates1.ts, 58, 17))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 63, 13))
+>undefined : Symbol(undefined)
+
+        x.length;
+>x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 63, 13))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+    }
+    if (!!true) {
+        Debug.assertDefined(x);
+>Debug.assertDefined : Symbol(Debug.assertDefined, Decl(assertionTypePredicates1.ts, 59, 84))
+>Debug : Symbol(Debug, Decl(assertionTypePredicates1.ts, 56, 1))
+>assertDefined : Symbol(Debug.assertDefined, Decl(assertionTypePredicates1.ts, 59, 84))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 63, 13))
+
+        x.length;
+>x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 63, 13))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+    }
+}
+
+class Test {
+>Test : Symbol(Test, Decl(assertionTypePredicates1.ts, 76, 1))
+
+    assert(value: unknown): asserts value {
+>assert : Symbol(Test.assert, Decl(assertionTypePredicates1.ts, 78, 12))
+>value : Symbol(value, Decl(assertionTypePredicates1.ts, 79, 11))
+>value : Symbol(value, Decl(assertionTypePredicates1.ts, 79, 11))
+
+        if (value) return;
+>value : Symbol(value, Decl(assertionTypePredicates1.ts, 79, 11))
+
+        throw new Error();
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+    }
+    isTest2(): this is Test2 {
+>isTest2 : Symbol(Test.isTest2, Decl(assertionTypePredicates1.ts, 82, 5))
+>Test2 : Symbol(Test2, Decl(assertionTypePredicates1.ts, 107, 1))
+
+        return this instanceof Test2;
+>this : Symbol(Test, Decl(assertionTypePredicates1.ts, 76, 1))
+>Test2 : Symbol(Test2, Decl(assertionTypePredicates1.ts, 107, 1))
+    }
+    assertIsTest2(): asserts this is Test2 {
+>assertIsTest2 : Symbol(Test.assertIsTest2, Decl(assertionTypePredicates1.ts, 85, 5))
+>Test2 : Symbol(Test2, Decl(assertionTypePredicates1.ts, 107, 1))
+
+        if (this instanceof Test2) return;
+>this : Symbol(Test, Decl(assertionTypePredicates1.ts, 76, 1))
+>Test2 : Symbol(Test2, Decl(assertionTypePredicates1.ts, 107, 1))
+
+        throw new Error();
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+    }
+    assertThis(): asserts this {
+>assertThis : Symbol(Test.assertThis, Decl(assertionTypePredicates1.ts, 89, 5))
+
+        if (!this) return;
+>this : Symbol(Test, Decl(assertionTypePredicates1.ts, 76, 1))
+
+        throw new Error();
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+    }
+    bar() {
+>bar : Symbol(Test.bar, Decl(assertionTypePredicates1.ts, 93, 5))
+
+        this.assertThis();
+>this.assertThis : Symbol(Test.assertThis, Decl(assertionTypePredicates1.ts, 89, 5))
+>this : Symbol(Test, Decl(assertionTypePredicates1.ts, 76, 1))
+>assertThis : Symbol(Test.assertThis, Decl(assertionTypePredicates1.ts, 89, 5))
+
+        this;
+>this : Symbol(Test, Decl(assertionTypePredicates1.ts, 76, 1))
+    }
+    foo(x: unknown) {
+>foo : Symbol(Test.foo, Decl(assertionTypePredicates1.ts, 97, 5))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 98, 8))
+
+        this.assert(typeof x === "string");
+>this.assert : Symbol(Test.assert, Decl(assertionTypePredicates1.ts, 78, 12))
+>this : Symbol(Test, Decl(assertionTypePredicates1.ts, 76, 1))
+>assert : Symbol(Test.assert, Decl(assertionTypePredicates1.ts, 78, 12))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 98, 8))
+
+        x.length;
+>x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 98, 8))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+
+        if (this.isTest2()) {
+>this.isTest2 : Symbol(Test.isTest2, Decl(assertionTypePredicates1.ts, 82, 5))
+>this : Symbol(Test, Decl(assertionTypePredicates1.ts, 76, 1))
+>isTest2 : Symbol(Test.isTest2, Decl(assertionTypePredicates1.ts, 82, 5))
+
+            this.z;
+>this.z : Symbol(Test2.z, Decl(assertionTypePredicates1.ts, 109, 26))
+>z : Symbol(Test2.z, Decl(assertionTypePredicates1.ts, 109, 26))
+        }
+        this.assertIsTest2();
+>this.assertIsTest2 : Symbol(Test.assertIsTest2, Decl(assertionTypePredicates1.ts, 85, 5))
+>this : Symbol(Test, Decl(assertionTypePredicates1.ts, 76, 1))
+>assertIsTest2 : Symbol(Test.assertIsTest2, Decl(assertionTypePredicates1.ts, 85, 5))
+
+        this.z;
+>this.z : Symbol(Test2.z, Decl(assertionTypePredicates1.ts, 109, 26))
+>z : Symbol(Test2.z, Decl(assertionTypePredicates1.ts, 109, 26))
+    }
+}
+
+class Test2 extends Test {
+>Test2 : Symbol(Test2, Decl(assertionTypePredicates1.ts, 107, 1))
+>Test : Symbol(Test, Decl(assertionTypePredicates1.ts, 76, 1))
+
+    z = 0;
+>z : Symbol(Test2.z, Decl(assertionTypePredicates1.ts, 109, 26))
+}
+
+// Invalid constructs
+
+declare let Q1: new (x: unknown) => x is string;
+>Q1 : Symbol(Q1, Decl(assertionTypePredicates1.ts, 115, 11))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 115, 21))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 115, 21))
+
+declare let Q2: new (x: boolean) => asserts x;
+>Q2 : Symbol(Q2, Decl(assertionTypePredicates1.ts, 116, 11))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 116, 21))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 116, 21))
+
+declare let Q3: new (x: unknown) => asserts x is string;
+>Q3 : Symbol(Q3, Decl(assertionTypePredicates1.ts, 117, 11))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 117, 21))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 117, 21))
+
+declare class Wat {
+>Wat : Symbol(Wat, Decl(assertionTypePredicates1.ts, 117, 56))
+
+    get p1(): this is string;
+>p1 : Symbol(Wat.p1, Decl(assertionTypePredicates1.ts, 119, 19), Decl(assertionTypePredicates1.ts, 120, 29))
+
+    set p1(x: this is string);
+>p1 : Symbol(Wat.p1, Decl(assertionTypePredicates1.ts, 119, 19), Decl(assertionTypePredicates1.ts, 120, 29))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 121, 11))
+
+    get p2(): asserts this is string;
+>p2 : Symbol(Wat.p2, Decl(assertionTypePredicates1.ts, 121, 30), Decl(assertionTypePredicates1.ts, 122, 37))
+
+    set p2(x: asserts this is string);
+>p2 : Symbol(Wat.p2, Decl(assertionTypePredicates1.ts, 121, 30), Decl(assertionTypePredicates1.ts, 122, 37))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 123, 11))
+}
+
diff --git a/tests/baselines/reference/assertionTypePredicates1.types b/tests/baselines/reference/assertionTypePredicates1.types
new file mode 100644
index 00000000000..f72ec641013
--- /dev/null
+++ b/tests/baselines/reference/assertionTypePredicates1.types
@@ -0,0 +1,438 @@
+=== tests/cases/conformance/controlFlow/assertionTypePredicates1.ts ===
+declare function isString(value: unknown): value is string;
+>isString : (value: unknown) => value is string
+>value : unknown
+
+declare function isArrayOfStrings(value: unknown): value is string[];
+>isArrayOfStrings : (value: unknown) => value is string[]
+>value : unknown
+
+const assert: (value: unknown) => asserts value = value => {}
+>assert : (value: unknown) => asserts value
+>value : unknown
+>value => {} : (value: unknown) => void
+>value : unknown
+
+declare function assertIsString(value: unknown): asserts value is string;
+>assertIsString : (value: unknown) => asserts value is string
+>value : unknown
+
+declare function assertIsArrayOfStrings(value: unknown): asserts value is string[];
+>assertIsArrayOfStrings : (value: unknown) => asserts value is string[]
+>value : unknown
+
+declare function assertDefined<T>(value: T): asserts value is NonNullable<T>;
+>assertDefined : <T>(value: T) => asserts value is NonNullable<T>
+>value : T
+
+function f01(x: unknown) {
+>f01 : (x: unknown) => void
+>x : unknown
+
+    if (!!true) {
+>!!true : true
+>!true : false
+>true : true
+
+        assert(typeof x === "string");
+>assert(typeof x === "string") : void
+>assert : (value: unknown) => asserts value
+>typeof x === "string" : boolean
+>typeof x : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
+>x : unknown
+>"string" : "string"
+
+        x.length;
+>x.length : number
+>x : string
+>length : number
+    }
+    if (!!true) {
+>!!true : true
+>!true : false
+>true : true
+
+        assert(x instanceof Error);
+>assert(x instanceof Error) : void
+>assert : (value: unknown) => asserts value
+>x instanceof Error : boolean
+>x : unknown
+>Error : ErrorConstructor
+
+        x.message;
+>x.message : string
+>x : Error
+>message : string
+    }
+    if (!!true) {
+>!!true : true
+>!true : false
+>true : true
+
+        assert(typeof x === "boolean" || typeof x === "number");
+>assert(typeof x === "boolean" || typeof x === "number") : void
+>assert : (value: unknown) => asserts value
+>typeof x === "boolean" || typeof x === "number" : boolean
+>typeof x === "boolean" : boolean
+>typeof x : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
+>x : unknown
+>"boolean" : "boolean"
+>typeof x === "number" : boolean
+>typeof x : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
+>x : unknown
+>"number" : "number"
+
+        x.toLocaleString;
+>x.toLocaleString : ((locales?: string | string[] | undefined, options?: Intl.NumberFormatOptions | undefined) => string) | (() => string)
+>x : number | boolean
+>toLocaleString : ((locales?: string | string[] | undefined, options?: Intl.NumberFormatOptions | undefined) => string) | (() => string)
+    }
+    if (!!true) {
+>!!true : true
+>!true : false
+>true : true
+
+        assert(isArrayOfStrings(x));
+>assert(isArrayOfStrings(x)) : void
+>assert : (value: unknown) => asserts value
+>isArrayOfStrings(x) : boolean
+>isArrayOfStrings : (value: unknown) => value is string[]
+>x : unknown
+
+        x[0].length;
+>x[0].length : number
+>x[0] : string
+>x : string[]
+>0 : 0
+>length : number
+    }
+    if (!!true) {
+>!!true : true
+>!true : false
+>true : true
+
+        assertIsArrayOfStrings(x);
+>assertIsArrayOfStrings(x) : void
+>assertIsArrayOfStrings : (value: unknown) => asserts value is string[]
+>x : unknown
+
+        x[0].length;
+>x[0].length : number
+>x[0] : string
+>x : string[]
+>0 : 0
+>length : number
+    }
+    if (!!true) {
+>!!true : true
+>!true : false
+>true : true
+
+        assert(x === undefined || typeof x === "string");
+>assert(x === undefined || typeof x === "string") : void
+>assert : (value: unknown) => asserts value
+>x === undefined || typeof x === "string" : boolean
+>x === undefined : boolean
+>x : unknown
+>undefined : undefined
+>typeof x === "string" : boolean
+>typeof x : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
+>x : unknown
+>"string" : "string"
+
+        x;  // string | undefined
+>x : string | undefined
+
+        assertDefined(x);
+>assertDefined(x) : void
+>assertDefined : <T>(value: T) => asserts value is NonNullable<T>
+>x : string | undefined
+
+        x;  // string
+>x : string
+    }
+}
+
+function f02(x: string | undefined) {
+>f02 : (x: string | undefined) => void
+>x : string | undefined
+
+    if (!!true) {
+>!!true : true
+>!true : false
+>true : true
+
+        assert(x);
+>assert(x) : void
+>assert : (value: unknown) => asserts value
+>x : string | undefined
+
+        x.length;
+>x.length : number
+>x : string
+>length : number
+    }
+    if (!!true) {
+>!!true : true
+>!true : false
+>true : true
+
+        assert(x !== undefined);
+>assert(x !== undefined) : void
+>assert : (value: unknown) => asserts value
+>x !== undefined : boolean
+>x : string | undefined
+>undefined : undefined
+
+        x.length;
+>x.length : number
+>x : string
+>length : number
+    }
+    if (!!true) {
+>!!true : true
+>!true : false
+>true : true
+
+        assertDefined(x);
+>assertDefined(x) : void
+>assertDefined : <T>(value: T) => asserts value is NonNullable<T>
+>x : string | undefined
+
+        x.length;
+>x.length : number
+>x : string
+>length : number
+    }
+}
+
+function f03(x: string | undefined, assert: (value: unknown) => asserts value) {
+>f03 : (x: string | undefined, assert: (value: unknown) => asserts value) => void
+>x : string | undefined
+>assert : (value: unknown) => asserts value
+>value : unknown
+
+    assert(x);
+>assert(x) : void
+>assert : (value: unknown) => asserts value
+>x : string | undefined
+
+    x.length;
+>x.length : number
+>x : string
+>length : number
+}
+
+namespace Debug {
+>Debug : typeof Debug
+
+    export declare function assert(value: unknown, message?: string): asserts value;
+>assert : (value: unknown, message?: string | undefined) => asserts value
+>value : unknown
+>message : string | undefined
+
+    export declare function assertDefined<T>(value: T): asserts value is NonNullable<T>;
+>assertDefined : <T>(value: T) => asserts value is NonNullable<T>
+>value : T
+}
+
+function f10(x: string | undefined) {
+>f10 : (x: string | undefined) => void
+>x : string | undefined
+
+    if (!!true) {
+>!!true : true
+>!true : false
+>true : true
+
+        Debug.assert(x);
+>Debug.assert(x) : void
+>Debug.assert : (value: unknown, message?: string | undefined) => asserts value
+>Debug : typeof Debug
+>assert : (value: unknown, message?: string | undefined) => asserts value
+>x : string | undefined
+
+        x.length;
+>x.length : number
+>x : string
+>length : number
+    }
+    if (!!true) {
+>!!true : true
+>!true : false
+>true : true
+
+        Debug.assert(x !== undefined);
+>Debug.assert(x !== undefined) : void
+>Debug.assert : (value: unknown, message?: string | undefined) => asserts value
+>Debug : typeof Debug
+>assert : (value: unknown, message?: string | undefined) => asserts value
+>x !== undefined : boolean
+>x : string | undefined
+>undefined : undefined
+
+        x.length;
+>x.length : number
+>x : string
+>length : number
+    }
+    if (!!true) {
+>!!true : true
+>!true : false
+>true : true
+
+        Debug.assertDefined(x);
+>Debug.assertDefined(x) : void
+>Debug.assertDefined : <T>(value: T) => asserts value is NonNullable<T>
+>Debug : typeof Debug
+>assertDefined : <T>(value: T) => asserts value is NonNullable<T>
+>x : string | undefined
+
+        x.length;
+>x.length : number
+>x : string
+>length : number
+    }
+}
+
+class Test {
+>Test : Test
+
+    assert(value: unknown): asserts value {
+>assert : (value: unknown) => asserts value
+>value : unknown
+
+        if (value) return;
+>value : unknown
+
+        throw new Error();
+>new Error() : Error
+>Error : ErrorConstructor
+    }
+    isTest2(): this is Test2 {
+>isTest2 : () => this is Test2
+
+        return this instanceof Test2;
+>this instanceof Test2 : boolean
+>this : this
+>Test2 : typeof Test2
+    }
+    assertIsTest2(): asserts this is Test2 {
+>assertIsTest2 : () => asserts this is Test2
+
+        if (this instanceof Test2) return;
+>this instanceof Test2 : boolean
+>this : this
+>Test2 : typeof Test2
+
+        throw new Error();
+>new Error() : Error
+>Error : ErrorConstructor
+    }
+    assertThis(): asserts this {
+>assertThis : () => asserts this
+
+        if (!this) return;
+>!this : false
+>this : this
+
+        throw new Error();
+>new Error() : Error
+>Error : ErrorConstructor
+    }
+    bar() {
+>bar : () => void
+
+        this.assertThis();
+>this.assertThis() : void
+>this.assertThis : () => asserts this
+>this : this
+>assertThis : () => asserts this
+
+        this;
+>this : this
+    }
+    foo(x: unknown) {
+>foo : (x: unknown) => void
+>x : unknown
+
+        this.assert(typeof x === "string");
+>this.assert(typeof x === "string") : void
+>this.assert : (value: unknown) => asserts value
+>this : this
+>assert : (value: unknown) => asserts value
+>typeof x === "string" : boolean
+>typeof x : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
+>x : unknown
+>"string" : "string"
+
+        x.length;
+>x.length : number
+>x : string
+>length : number
+
+        if (this.isTest2()) {
+>this.isTest2() : boolean
+>this.isTest2 : () => this is Test2
+>this : this
+>isTest2 : () => this is Test2
+
+            this.z;
+>this.z : number
+>this : this & Test2
+>z : number
+        }
+        this.assertIsTest2();
+>this.assertIsTest2() : void
+>this.assertIsTest2 : () => asserts this is Test2
+>this : this
+>assertIsTest2 : () => asserts this is Test2
+
+        this.z;
+>this.z : number
+>this : this & Test2
+>z : number
+    }
+}
+
+class Test2 extends Test {
+>Test2 : Test2
+>Test : Test
+
+    z = 0;
+>z : number
+>0 : 0
+}
+
+// Invalid constructs
+
+declare let Q1: new (x: unknown) => x is string;
+>Q1 : new (x: unknown) => x is string
+>x : unknown
+
+declare let Q2: new (x: boolean) => asserts x;
+>Q2 : new (x: boolean) => asserts x
+>x : boolean
+
+declare let Q3: new (x: unknown) => asserts x is string;
+>Q3 : new (x: unknown) => asserts x is string
+>x : unknown
+
+declare class Wat {
+>Wat : Wat
+
+    get p1(): this is string;
+>p1 : boolean
+
+    set p1(x: this is string);
+>p1 : boolean
+>x : boolean
+
+    get p2(): asserts this is string;
+>p2 : void
+
+    set p2(x: asserts this is string);
+>p2 : void
+>x : void
+}
+
diff --git a/tests/baselines/reference/assertionsAndNonReturningFunctions.errors.txt b/tests/baselines/reference/assertionsAndNonReturningFunctions.errors.txt
new file mode 100644
index 00000000000..e1648d7643d
--- /dev/null
+++ b/tests/baselines/reference/assertionsAndNonReturningFunctions.errors.txt
@@ -0,0 +1,69 @@
+tests/cases/conformance/jsdoc/assertionsAndNonReturningFunctions.js(46,9): error TS7027: Unreachable code detected.
+tests/cases/conformance/jsdoc/assertionsAndNonReturningFunctions.js(58,5): error TS7027: Unreachable code detected.
+
+
+==== tests/cases/conformance/jsdoc/assertionsAndNonReturningFunctions.js (2 errors) ====
+    /** @typedef {(check: boolean) => asserts check} AssertFunc */
+    
+    /** @type {AssertFunc} */
+    const assert = check => {
+        if (!check) throw new Error();
+    }
+    
+    /** @type {(x: unknown) => asserts x is string } */
+    function assertIsString(x) {
+        if (!(typeof x === "string")) throw new Error();
+    }
+    
+    /**
+     * @param {boolean} check
+     * @returns {asserts check}
+    */
+    function assert2(check) {
+        if (!check) throw new Error();
+    }
+    
+    /**
+     * @returns {never}
+     */
+    function fail() {
+        throw new Error();
+    }
+    
+    /**
+     * @param {*} x 
+     */
+    function f1(x) {
+        if (!!true) {
+            assert(typeof x === "string");
+            x.length;
+        }
+        if (!!true) {
+            assert2(typeof x === "string");
+            x.length;
+        }
+        if (!!true) {
+            assertIsString(x);
+            x.length;
+        }
+        if (!!true) {
+            fail();
+            x;  // Unreachable
+            ~~
+!!! error TS7027: Unreachable code detected.
+        }
+    }
+    
+    /**
+     * @param {boolean} b 
+     */
+    function f2(b) {
+        switch (b) {
+            case true: return 1;
+            case false: return 0;
+        }
+        b;  // Unreachable
+        ~~
+!!! error TS7027: Unreachable code detected.
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/assertionsAndNonReturningFunctions.symbols b/tests/baselines/reference/assertionsAndNonReturningFunctions.symbols
new file mode 100644
index 00000000000..88931cffbd8
--- /dev/null
+++ b/tests/baselines/reference/assertionsAndNonReturningFunctions.symbols
@@ -0,0 +1,109 @@
+=== tests/cases/conformance/jsdoc/assertionsAndNonReturningFunctions.js ===
+/** @typedef {(check: boolean) => asserts check} AssertFunc */
+
+/** @type {AssertFunc} */
+const assert = check => {
+>assert : Symbol(assert, Decl(assertionsAndNonReturningFunctions.js, 3, 5))
+>check : Symbol(check, Decl(assertionsAndNonReturningFunctions.js, 3, 14))
+
+    if (!check) throw new Error();
+>check : Symbol(check, Decl(assertionsAndNonReturningFunctions.js, 3, 14))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+}
+
+/** @type {(x: unknown) => asserts x is string } */
+function assertIsString(x) {
+>assertIsString : Symbol(assertIsString, Decl(assertionsAndNonReturningFunctions.js, 5, 1))
+>x : Symbol(x, Decl(assertionsAndNonReturningFunctions.js, 8, 24))
+
+    if (!(typeof x === "string")) throw new Error();
+>x : Symbol(x, Decl(assertionsAndNonReturningFunctions.js, 8, 24))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+}
+
+/**
+ * @param {boolean} check
+ * @returns {asserts check}
+*/
+function assert2(check) {
+>assert2 : Symbol(assert2, Decl(assertionsAndNonReturningFunctions.js, 10, 1))
+>check : Symbol(check, Decl(assertionsAndNonReturningFunctions.js, 16, 17))
+
+    if (!check) throw new Error();
+>check : Symbol(check, Decl(assertionsAndNonReturningFunctions.js, 16, 17))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+}
+
+/**
+ * @returns {never}
+ */
+function fail() {
+>fail : Symbol(fail, Decl(assertionsAndNonReturningFunctions.js, 18, 1))
+
+    throw new Error();
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+}
+
+/**
+ * @param {*} x 
+ */
+function f1(x) {
+>f1 : Symbol(f1, Decl(assertionsAndNonReturningFunctions.js, 25, 1))
+>x : Symbol(x, Decl(assertionsAndNonReturningFunctions.js, 30, 12))
+
+    if (!!true) {
+        assert(typeof x === "string");
+>assert : Symbol(assert, Decl(assertionsAndNonReturningFunctions.js, 3, 5))
+>x : Symbol(x, Decl(assertionsAndNonReturningFunctions.js, 30, 12))
+
+        x.length;
+>x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(assertionsAndNonReturningFunctions.js, 30, 12))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+    }
+    if (!!true) {
+        assert2(typeof x === "string");
+>assert2 : Symbol(assert2, Decl(assertionsAndNonReturningFunctions.js, 10, 1))
+>x : Symbol(x, Decl(assertionsAndNonReturningFunctions.js, 30, 12))
+
+        x.length;
+>x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(assertionsAndNonReturningFunctions.js, 30, 12))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+    }
+    if (!!true) {
+        assertIsString(x);
+>assertIsString : Symbol(assertIsString, Decl(assertionsAndNonReturningFunctions.js, 5, 1))
+>x : Symbol(x, Decl(assertionsAndNonReturningFunctions.js, 30, 12))
+
+        x.length;
+>x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(assertionsAndNonReturningFunctions.js, 30, 12))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+    }
+    if (!!true) {
+        fail();
+>fail : Symbol(fail, Decl(assertionsAndNonReturningFunctions.js, 18, 1))
+
+        x;  // Unreachable
+>x : Symbol(x, Decl(assertionsAndNonReturningFunctions.js, 30, 12))
+    }
+}
+
+/**
+ * @param {boolean} b 
+ */
+function f2(b) {
+>f2 : Symbol(f2, Decl(assertionsAndNonReturningFunctions.js, 47, 1))
+>b : Symbol(b, Decl(assertionsAndNonReturningFunctions.js, 52, 12))
+
+    switch (b) {
+>b : Symbol(b, Decl(assertionsAndNonReturningFunctions.js, 52, 12))
+
+        case true: return 1;
+        case false: return 0;
+    }
+    b;  // Unreachable
+>b : Symbol(b, Decl(assertionsAndNonReturningFunctions.js, 52, 12))
+}
+
diff --git a/tests/baselines/reference/assertionsAndNonReturningFunctions.types b/tests/baselines/reference/assertionsAndNonReturningFunctions.types
new file mode 100644
index 00000000000..32100b6c3d2
--- /dev/null
+++ b/tests/baselines/reference/assertionsAndNonReturningFunctions.types
@@ -0,0 +1,152 @@
+=== tests/cases/conformance/jsdoc/assertionsAndNonReturningFunctions.js ===
+/** @typedef {(check: boolean) => asserts check} AssertFunc */
+
+/** @type {AssertFunc} */
+const assert = check => {
+>assert : (check: boolean) => asserts check
+>check => {    if (!check) throw new Error();} : (check: boolean) => asserts check
+>check : boolean
+
+    if (!check) throw new Error();
+>!check : boolean
+>check : boolean
+>new Error() : Error
+>Error : ErrorConstructor
+}
+
+/** @type {(x: unknown) => asserts x is string } */
+function assertIsString(x) {
+>assertIsString : (x: unknown) => asserts x is string
+>x : unknown
+
+    if (!(typeof x === "string")) throw new Error();
+>!(typeof x === "string") : boolean
+>(typeof x === "string") : boolean
+>typeof x === "string" : boolean
+>typeof x : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
+>x : unknown
+>"string" : "string"
+>new Error() : Error
+>Error : ErrorConstructor
+}
+
+/**
+ * @param {boolean} check
+ * @returns {asserts check}
+*/
+function assert2(check) {
+>assert2 : (check: boolean) => asserts check
+>check : boolean
+
+    if (!check) throw new Error();
+>!check : boolean
+>check : boolean
+>new Error() : Error
+>Error : ErrorConstructor
+}
+
+/**
+ * @returns {never}
+ */
+function fail() {
+>fail : () => never
+
+    throw new Error();
+>new Error() : Error
+>Error : ErrorConstructor
+}
+
+/**
+ * @param {*} x 
+ */
+function f1(x) {
+>f1 : (x: any) => void
+>x : any
+
+    if (!!true) {
+>!!true : boolean
+>!true : boolean
+>true : true
+
+        assert(typeof x === "string");
+>assert(typeof x === "string") : void
+>assert : (check: boolean) => asserts check
+>typeof x === "string" : boolean
+>typeof x : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
+>x : any
+>"string" : "string"
+
+        x.length;
+>x.length : number
+>x : string
+>length : number
+    }
+    if (!!true) {
+>!!true : boolean
+>!true : boolean
+>true : true
+
+        assert2(typeof x === "string");
+>assert2(typeof x === "string") : void
+>assert2 : (check: boolean) => asserts check
+>typeof x === "string" : boolean
+>typeof x : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
+>x : any
+>"string" : "string"
+
+        x.length;
+>x.length : number
+>x : string
+>length : number
+    }
+    if (!!true) {
+>!!true : boolean
+>!true : boolean
+>true : true
+
+        assertIsString(x);
+>assertIsString(x) : void
+>assertIsString : (x: unknown) => asserts x is string
+>x : any
+
+        x.length;
+>x.length : number
+>x : string
+>length : number
+    }
+    if (!!true) {
+>!!true : boolean
+>!true : boolean
+>true : true
+
+        fail();
+>fail() : never
+>fail : () => never
+
+        x;  // Unreachable
+>x : any
+    }
+}
+
+/**
+ * @param {boolean} b 
+ */
+function f2(b) {
+>f2 : (b: boolean) => 1 | 0
+>b : boolean
+
+    switch (b) {
+>b : boolean
+
+        case true: return 1;
+>true : true
+>1 : 1
+
+        case false: return 0;
+>false : false
+>0 : 0
+    }
+    b;  // Unreachable
+>b : never
+}
+
diff --git a/tests/baselines/reference/assignFromBooleanInterface2.errors.txt b/tests/baselines/reference/assignFromBooleanInterface2.errors.txt
index 6c7ebbe5ee8..ba8b2f5a9c9 100644
--- a/tests/baselines/reference/assignFromBooleanInterface2.errors.txt
+++ b/tests/baselines/reference/assignFromBooleanInterface2.errors.txt
@@ -1,7 +1,6 @@
 tests/cases/conformance/types/primitives/boolean/assignFromBooleanInterface2.ts(14,1): error TS2322: Type 'NotBoolean' is not assignable to type 'Boolean'.
-  Types of property 'valueOf' are incompatible.
-    Type '() => Object' is not assignable to type '() => boolean'.
-      Type 'Object' is not assignable to type 'boolean'.
+  The types returned by 'valueOf()' are incompatible between these types.
+    Type 'Object' is not assignable to type 'boolean'.
 tests/cases/conformance/types/primitives/boolean/assignFromBooleanInterface2.ts(19,1): error TS2322: Type 'Boolean' is not assignable to type 'boolean'.
   'boolean' is a primitive, but 'Boolean' is a wrapper object. Prefer using 'boolean' when possible.
 tests/cases/conformance/types/primitives/boolean/assignFromBooleanInterface2.ts(20,1): error TS2322: Type 'NotBoolean' is not assignable to type 'boolean'.
@@ -24,9 +23,8 @@ tests/cases/conformance/types/primitives/boolean/assignFromBooleanInterface2.ts(
     a = b;
     ~
 !!! error TS2322: Type 'NotBoolean' is not assignable to type 'Boolean'.
-!!! error TS2322:   Types of property 'valueOf' are incompatible.
-!!! error TS2322:     Type '() => Object' is not assignable to type '() => boolean'.
-!!! error TS2322:       Type 'Object' is not assignable to type 'boolean'.
+!!! error TS2322:   The types returned by 'valueOf()' are incompatible between these types.
+!!! error TS2322:     Type 'Object' is not assignable to type 'boolean'.
     
     b = a;
     b = x;
diff --git a/tests/baselines/reference/asyncFunctionDeclaration15_es5.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration15_es5.errors.txt
index 6b4b0a71c6f..7e3595ec6f4 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration15_es5.errors.txt
+++ b/tests/baselines/reference/asyncFunctionDeclaration15_es5.errors.txt
@@ -5,10 +5,9 @@ tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration1
 tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration15_es5.ts(8,23): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
 tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration15_es5.ts(9,23): error TS1055: Type 'PromiseLike' is not a valid async function return type in ES5/ES3 because it does not refer to a Promise-compatible constructor value.
 tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration15_es5.ts(10,23): error TS1055: Type 'typeof Thenable' is not a valid async function return type in ES5/ES3 because it does not refer to a Promise-compatible constructor value.
-  Type 'Thenable' is not assignable to type 'PromiseLike<T>'.
-    Types of property 'then' are incompatible.
-      Type '() => void' is not assignable to type '<TResult1 = T, TResult2 = never>(onfulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => PromiseLike<TResult1 | TResult2>'.
-        Type 'void' is not assignable to type 'PromiseLike<TResult1 | TResult2>'.
+  Construct signature return types 'Thenable' and 'PromiseLike<T>' are incompatible.
+    The types returned by 'then(...)' are incompatible between these types.
+      Type 'void' is not assignable to type 'PromiseLike<TResult1 | TResult2>'.
 tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration15_es5.ts(17,16): error TS1058: The return type of an async function must either be a valid promise or must not contain a callable 'then' member.
 tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration15_es5.ts(23,25): error TS1320: Type of 'await' operand must either be a valid promise or must not contain a callable 'then' member.
 
@@ -38,10 +37,9 @@ tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration1
     async function fn6(): Thenable { } // error
                           ~~~~~~~~
 !!! error TS1055: Type 'typeof Thenable' is not a valid async function return type in ES5/ES3 because it does not refer to a Promise-compatible constructor value.
-!!! error TS1055:   Type 'Thenable' is not assignable to type 'PromiseLike<T>'.
-!!! error TS1055:     Types of property 'then' are incompatible.
-!!! error TS1055:       Type '() => void' is not assignable to type '<TResult1 = T, TResult2 = never>(onfulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => PromiseLike<TResult1 | TResult2>'.
-!!! error TS1055:         Type 'void' is not assignable to type 'PromiseLike<TResult1 | TResult2>'.
+!!! error TS1055:   Construct signature return types 'Thenable' and 'PromiseLike<T>' are incompatible.
+!!! error TS1055:     The types returned by 'then(...)' are incompatible between these types.
+!!! error TS1055:       Type 'void' is not assignable to type 'PromiseLike<TResult1 | TResult2>'.
     async function fn7() { return; } // valid: Promise<void>
     async function fn8() { return 1; } // valid: Promise<number>
     async function fn9() { return null; } // valid: Promise<any>
diff --git a/tests/baselines/reference/baseConstraintOfDecorator.errors.txt b/tests/baselines/reference/baseConstraintOfDecorator.errors.txt
index 8317e5c55c6..8aad9f6fead 100644
--- a/tests/baselines/reference/baseConstraintOfDecorator.errors.txt
+++ b/tests/baselines/reference/baseConstraintOfDecorator.errors.txt
@@ -1,11 +1,10 @@
 tests/cases/compiler/baseConstraintOfDecorator.ts(2,5): error TS2322: Type 'typeof decoratorFunc' is not assignable to type 'TFunction'.
   'typeof decoratorFunc' is assignable to the constraint of type 'TFunction', but 'TFunction' could be instantiated with a different subtype of constraint '{}'.
 tests/cases/compiler/baseConstraintOfDecorator.ts(2,40): error TS2507: Type 'TFunction' is not a constructor function type.
-tests/cases/compiler/baseConstraintOfDecorator.ts(12,5): error TS2322: Type 'typeof decoratorFunc' is not assignable to type 'TFunction'.
-tests/cases/compiler/baseConstraintOfDecorator.ts(12,40): error TS2507: Type 'TFunction' is not a constructor function type.
+tests/cases/compiler/baseConstraintOfDecorator.ts(12,18): error TS2545: A mixin class must have a constructor with a single rest parameter of type 'any[]'.
 
 
-==== tests/cases/compiler/baseConstraintOfDecorator.ts (4 errors) ====
+==== tests/cases/compiler/baseConstraintOfDecorator.ts (3 errors) ====
     export function classExtender<TFunction>(superClass: TFunction, _instanceModifier: (instance: any, args: any[]) => void): TFunction {
         return class decoratorFunc extends superClass {
         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -29,20 +28,12 @@ tests/cases/compiler/baseConstraintOfDecorator.ts(12,40): error TS2507: Type 'TF
     class MyClass { private x; }
     export function classExtender2<TFunction extends new (...args: string[]) => MyClass>(superClass: TFunction, _instanceModifier: (instance: any, args: any[]) => void): TFunction {
         return class decoratorFunc extends superClass {
-        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-                                           ~~~~~~~~~~
-!!! error TS2507: Type 'TFunction' is not a constructor function type.
-!!! related TS2735 tests/cases/compiler/baseConstraintOfDecorator.ts:11:32: Did you mean for 'TFunction' to be constrained to type 'new (...args: any[]) => MyClass'?
+                     ~~~~~~~~~~~~~
+!!! error TS2545: A mixin class must have a constructor with a single rest parameter of type 'any[]'.
             constructor(...args: any[]) {
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                 super(...args);
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~
                 _instanceModifier(this, args);
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
             }
-    ~~~~~~~~~
         };
-    ~~~~~~
-!!! error TS2322: Type 'typeof decoratorFunc' is not assignable to type 'TFunction'.
     }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/baseConstraintOfDecorator.symbols b/tests/baselines/reference/baseConstraintOfDecorator.symbols
index 9048d7ed568..0a1dad239af 100644
--- a/tests/baselines/reference/baseConstraintOfDecorator.symbols
+++ b/tests/baselines/reference/baseConstraintOfDecorator.symbols
@@ -51,6 +51,7 @@ export function classExtender2<TFunction extends new (...args: string[]) => MyCl
 >args : Symbol(args, Decl(baseConstraintOfDecorator.ts, 12, 20))
 
             super(...args);
+>super : Symbol(TFunction, Decl(baseConstraintOfDecorator.ts, 10, 31))
 >args : Symbol(args, Decl(baseConstraintOfDecorator.ts, 12, 20))
 
             _instanceModifier(this, args);
diff --git a/tests/baselines/reference/baseConstraintOfDecorator.types b/tests/baselines/reference/baseConstraintOfDecorator.types
index a5a277c5d2a..78c77ee78a2 100644
--- a/tests/baselines/reference/baseConstraintOfDecorator.types
+++ b/tests/baselines/reference/baseConstraintOfDecorator.types
@@ -42,16 +42,16 @@ export function classExtender2<TFunction extends new (...args: string[]) => MyCl
 >args : any[]
 
     return class decoratorFunc extends superClass {
->class decoratorFunc extends superClass {        constructor(...args: any[]) {            super(...args);            _instanceModifier(this, args);        }    } : typeof decoratorFunc
->decoratorFunc : typeof decoratorFunc
->superClass : TFunction
+>class decoratorFunc extends superClass {        constructor(...args: any[]) {            super(...args);            _instanceModifier(this, args);        }    } : { new (...args: any[]): decoratorFunc; prototype: classExtender2<any>.decoratorFunc; } & TFunction
+>decoratorFunc : { new (...args: any[]): decoratorFunc; prototype: classExtender2<any>.decoratorFunc; } & TFunction
+>superClass : MyClass
 
         constructor(...args: any[]) {
 >args : any[]
 
             super(...args);
 >super(...args) : void
->super : any
+>super : TFunction
 >...args : any
 >args : any[]
 
diff --git a/tests/baselines/reference/bigintWithLib.errors.txt b/tests/baselines/reference/bigintWithLib.errors.txt
index b4c9f65cf9c..fb54c2a530b 100644
--- a/tests/baselines/reference/bigintWithLib.errors.txt
+++ b/tests/baselines/reference/bigintWithLib.errors.txt
@@ -4,15 +4,11 @@ tests/cases/compiler/bigintWithLib.ts(16,33): error TS2769: No overload matches
     Argument of type 'number[]' is not assignable to parameter of type 'number'.
   Overload 2 of 3, '(array: Iterable<bigint>): BigInt64Array', gave the following error.
     Argument of type 'number[]' is not assignable to parameter of type 'Iterable<bigint>'.
-      Types of property '[Symbol.iterator]' are incompatible.
-        Type '() => IterableIterator<number>' is not assignable to type '() => Iterator<bigint, any, undefined>'.
-          Type 'IterableIterator<number>' is not assignable to type 'Iterator<bigint, any, undefined>'.
-            Types of property 'next' are incompatible.
-              Type '(...args: [] | [undefined]) => IteratorResult<number, any>' is not assignable to type '(...args: [] | [undefined]) => IteratorResult<bigint, any>'.
-                Type 'IteratorResult<number, any>' is not assignable to type 'IteratorResult<bigint, any>'.
-                  Type 'IteratorYieldResult<number>' is not assignable to type 'IteratorResult<bigint, any>'.
-                    Type 'IteratorYieldResult<number>' is not assignable to type 'IteratorYieldResult<bigint>'.
-                      Type 'number' is not assignable to type 'bigint'.
+      The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types.
+        Type 'IteratorResult<number, any>' is not assignable to type 'IteratorResult<bigint, any>'.
+          Type 'IteratorYieldResult<number>' is not assignable to type 'IteratorResult<bigint, any>'.
+            Type 'IteratorYieldResult<number>' is not assignable to type 'IteratorYieldResult<bigint>'.
+              Type 'number' is not assignable to type 'bigint'.
   Overload 3 of 3, '(buffer: ArrayBuffer | SharedArrayBuffer, byteOffset?: number, length?: number): BigInt64Array', gave the following error.
     Argument of type 'number[]' is not assignable to parameter of type 'ArrayBuffer | SharedArrayBuffer'.
       Type 'number[]' is missing the following properties from type 'SharedArrayBuffer': byteLength, [Symbol.species], [Symbol.toStringTag]
@@ -55,15 +51,11 @@ tests/cases/compiler/bigintWithLib.ts(43,26): error TS2345: Argument of type '12
 !!! error TS2769:     Argument of type 'number[]' is not assignable to parameter of type 'number'.
 !!! error TS2769:   Overload 2 of 3, '(array: Iterable<bigint>): BigInt64Array', gave the following error.
 !!! error TS2769:     Argument of type 'number[]' is not assignable to parameter of type 'Iterable<bigint>'.
-!!! error TS2769:       Types of property '[Symbol.iterator]' are incompatible.
-!!! error TS2769:         Type '() => IterableIterator<number>' is not assignable to type '() => Iterator<bigint, any, undefined>'.
-!!! error TS2769:           Type 'IterableIterator<number>' is not assignable to type 'Iterator<bigint, any, undefined>'.
-!!! error TS2769:             Types of property 'next' are incompatible.
-!!! error TS2769:               Type '(...args: [] | [undefined]) => IteratorResult<number, any>' is not assignable to type '(...args: [] | [undefined]) => IteratorResult<bigint, any>'.
-!!! error TS2769:                 Type 'IteratorResult<number, any>' is not assignable to type 'IteratorResult<bigint, any>'.
-!!! error TS2769:                   Type 'IteratorYieldResult<number>' is not assignable to type 'IteratorResult<bigint, any>'.
-!!! error TS2769:                     Type 'IteratorYieldResult<number>' is not assignable to type 'IteratorYieldResult<bigint>'.
-!!! error TS2769:                       Type 'number' is not assignable to type 'bigint'.
+!!! error TS2769:       The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types.
+!!! error TS2769:         Type 'IteratorResult<number, any>' is not assignable to type 'IteratorResult<bigint, any>'.
+!!! error TS2769:           Type 'IteratorYieldResult<number>' is not assignable to type 'IteratorResult<bigint, any>'.
+!!! error TS2769:             Type 'IteratorYieldResult<number>' is not assignable to type 'IteratorYieldResult<bigint>'.
+!!! error TS2769:               Type 'number' is not assignable to type 'bigint'.
 !!! error TS2769:   Overload 3 of 3, '(buffer: ArrayBuffer | SharedArrayBuffer, byteOffset?: number, length?: number): BigInt64Array', gave the following error.
 !!! error TS2769:     Argument of type 'number[]' is not assignable to parameter of type 'ArrayBuffer | SharedArrayBuffer'.
 !!! error TS2769:       Type 'number[]' is missing the following properties from type 'SharedArrayBuffer': byteLength, [Symbol.species], [Symbol.toStringTag]
diff --git a/tests/baselines/reference/booleanAssignment.errors.txt b/tests/baselines/reference/booleanAssignment.errors.txt
index fc25fd4007f..8a928c57404 100644
--- a/tests/baselines/reference/booleanAssignment.errors.txt
+++ b/tests/baselines/reference/booleanAssignment.errors.txt
@@ -1,9 +1,8 @@
 tests/cases/compiler/booleanAssignment.ts(2,1): error TS2322: Type '1' is not assignable to type 'Boolean'.
 tests/cases/compiler/booleanAssignment.ts(3,1): error TS2322: Type '"a"' is not assignable to type 'Boolean'.
 tests/cases/compiler/booleanAssignment.ts(4,1): error TS2322: Type '{}' is not assignable to type 'Boolean'.
-  Types of property 'valueOf' are incompatible.
-    Type '() => Object' is not assignable to type '() => boolean'.
-      Type 'Object' is not assignable to type 'boolean'.
+  The types returned by 'valueOf()' are incompatible between these types.
+    Type 'Object' is not assignable to type 'boolean'.
 
 
 ==== tests/cases/compiler/booleanAssignment.ts (3 errors) ====
@@ -17,9 +16,8 @@ tests/cases/compiler/booleanAssignment.ts(4,1): error TS2322: Type '{}' is not a
     b = {}; // Error
     ~
 !!! error TS2322: Type '{}' is not assignable to type 'Boolean'.
-!!! error TS2322:   Types of property 'valueOf' are incompatible.
-!!! error TS2322:     Type '() => Object' is not assignable to type '() => boolean'.
-!!! error TS2322:       Type 'Object' is not assignable to type 'boolean'.
+!!! error TS2322:   The types returned by 'valueOf()' are incompatible between these types.
+!!! error TS2322:     Type 'Object' is not assignable to type 'boolean'.
     
     var o = {};
     o = b; // OK
diff --git a/tests/baselines/reference/callSignatureAssignabilityInInheritance.errors.txt b/tests/baselines/reference/callSignatureAssignabilityInInheritance.errors.txt
index 2ca3bb1aaf0..43589e94370 100644
--- a/tests/baselines/reference/callSignatureAssignabilityInInheritance.errors.txt
+++ b/tests/baselines/reference/callSignatureAssignabilityInInheritance.errors.txt
@@ -1,12 +1,10 @@
 tests/cases/conformance/types/typeRelationships/assignmentCompatibility/callSignatureAssignabilityInInheritance.ts(57,15): error TS2430: Interface 'I2' incorrectly extends interface 'Base2'.
-  Types of property 'a' are incompatible.
-    Type '(x: number) => string' is not assignable to type '(x: number) => number'.
-      Type 'string' is not assignable to type 'number'.
+  The types returned by 'a(...)' are incompatible between these types.
+    Type 'string' is not assignable to type 'number'.
 tests/cases/conformance/types/typeRelationships/assignmentCompatibility/callSignatureAssignabilityInInheritance.ts(63,15): error TS2430: Interface 'I3' incorrectly extends interface 'Base2'.
-  Types of property 'a2' are incompatible.
-    Type '<T>(x: T) => string' is not assignable to type '<T>(x: T) => T'.
-      Type 'string' is not assignable to type 'T'.
-        'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+  The types returned by 'a2(...)' are incompatible between these types.
+    Type 'string' is not assignable to type 'T'.
+      'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
 
 
 ==== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/callSignatureAssignabilityInInheritance.ts (2 errors) ====
@@ -69,9 +67,8 @@ tests/cases/conformance/types/typeRelationships/assignmentCompatibility/callSign
         interface I2 extends Base2 {
                   ~~
 !!! error TS2430: Interface 'I2' incorrectly extends interface 'Base2'.
-!!! error TS2430:   Types of property 'a' are incompatible.
-!!! error TS2430:     Type '(x: number) => string' is not assignable to type '(x: number) => number'.
-!!! error TS2430:       Type 'string' is not assignable to type 'number'.
+!!! error TS2430:   The types returned by 'a(...)' are incompatible between these types.
+!!! error TS2430:     Type 'string' is not assignable to type 'number'.
             // N's
             a: (x: number) => string; // error because base returns non-void;
         }
@@ -80,10 +77,9 @@ tests/cases/conformance/types/typeRelationships/assignmentCompatibility/callSign
         interface I3 extends Base2 {
                   ~~
 !!! error TS2430: Interface 'I3' incorrectly extends interface 'Base2'.
-!!! error TS2430:   Types of property 'a2' are incompatible.
-!!! error TS2430:     Type '<T>(x: T) => string' is not assignable to type '<T>(x: T) => T'.
-!!! error TS2430:       Type 'string' is not assignable to type 'T'.
-!!! error TS2430:         'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+!!! error TS2430:   The types returned by 'a2(...)' are incompatible between these types.
+!!! error TS2430:     Type 'string' is not assignable to type 'T'.
+!!! error TS2430:       'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
             // N's
             a2: <T>(x: T) => string; // error because base returns non-void;
         }
diff --git a/tests/baselines/reference/callSignatureAssignabilityInInheritance3.errors.txt b/tests/baselines/reference/callSignatureAssignabilityInInheritance3.errors.txt
index 671c09b3d79..287875d44da 100644
--- a/tests/baselines/reference/callSignatureAssignabilityInInheritance3.errors.txt
+++ b/tests/baselines/reference/callSignatureAssignabilityInInheritance3.errors.txt
@@ -27,16 +27,14 @@ tests/cases/conformance/types/typeRelationships/assignmentCompatibility/callSign
           Types of property 'a' are incompatible.
             Type 'string' is not assignable to type 'Base'.
 tests/cases/conformance/types/typeRelationships/assignmentCompatibility/callSignatureAssignabilityInInheritance3.ts(100,19): error TS2430: Interface 'I6' incorrectly extends interface 'B'.
-  Types of property 'a2' are incompatible.
-    Type '<T>(x: T) => string[]' is not assignable to type '<T>(x: T) => T[]'.
-      Type 'string[]' is not assignable to type 'T[]'.
-        Type 'string' is not assignable to type 'T'.
-          'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+  The types returned by 'a2(...)' are incompatible between these types.
+    Type 'string[]' is not assignable to type 'T[]'.
+      Type 'string' is not assignable to type 'T'.
+        'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
 tests/cases/conformance/types/typeRelationships/assignmentCompatibility/callSignatureAssignabilityInInheritance3.ts(109,19): error TS2430: Interface 'I7' incorrectly extends interface 'C'.
-  Types of property 'a2' are incompatible.
-    Type '<T>(x: T) => T[]' is not assignable to type '<T>(x: T) => string[]'.
-      Type 'T[]' is not assignable to type 'string[]'.
-        Type 'T' is not assignable to type 'string'.
+  The types returned by 'a2(...)' are incompatible between these types.
+    Type 'T[]' is not assignable to type 'string[]'.
+      Type 'T' is not assignable to type 'string'.
 
 
 ==== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/callSignatureAssignabilityInInheritance3.ts (6 errors) ====
@@ -174,11 +172,10 @@ tests/cases/conformance/types/typeRelationships/assignmentCompatibility/callSign
             interface I6 extends B {
                       ~~
 !!! error TS2430: Interface 'I6' incorrectly extends interface 'B'.
-!!! error TS2430:   Types of property 'a2' are incompatible.
-!!! error TS2430:     Type '<T>(x: T) => string[]' is not assignable to type '<T>(x: T) => T[]'.
-!!! error TS2430:       Type 'string[]' is not assignable to type 'T[]'.
-!!! error TS2430:         Type 'string' is not assignable to type 'T'.
-!!! error TS2430:           'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+!!! error TS2430:   The types returned by 'a2(...)' are incompatible between these types.
+!!! error TS2430:     Type 'string[]' is not assignable to type 'T[]'.
+!!! error TS2430:       Type 'string' is not assignable to type 'T'.
+!!! error TS2430:         'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
                 a2: <T>(x: T) => string[]; // error
             }
     
@@ -190,10 +187,9 @@ tests/cases/conformance/types/typeRelationships/assignmentCompatibility/callSign
             interface I7 extends C {
                       ~~
 !!! error TS2430: Interface 'I7' incorrectly extends interface 'C'.
-!!! error TS2430:   Types of property 'a2' are incompatible.
-!!! error TS2430:     Type '<T>(x: T) => T[]' is not assignable to type '<T>(x: T) => string[]'.
-!!! error TS2430:       Type 'T[]' is not assignable to type 'string[]'.
-!!! error TS2430:         Type 'T' is not assignable to type 'string'.
+!!! error TS2430:   The types returned by 'a2(...)' are incompatible between these types.
+!!! error TS2430:     Type 'T[]' is not assignable to type 'string[]'.
+!!! error TS2430:       Type 'T' is not assignable to type 'string'.
                 a2: <T>(x: T) => T[]; // error
             }
         }
diff --git a/tests/baselines/reference/checkJsxChildrenCanBeTupleType.errors.txt b/tests/baselines/reference/checkJsxChildrenCanBeTupleType.errors.txt
index aeaeb56ea75..0780f4e92c1 100644
--- a/tests/baselines/reference/checkJsxChildrenCanBeTupleType.errors.txt
+++ b/tests/baselines/reference/checkJsxChildrenCanBeTupleType.errors.txt
@@ -1,10 +1,8 @@
 tests/cases/conformance/jsx/checkJsxChildrenCanBeTupleType.tsx(17,18): error TS2769: No overload matches this call.
   Overload 1 of 2, '(props: Readonly<ResizablePanelProps>): ResizablePanel', gave the following error.
     Type '{ children: [Element, Element, Element]; }' is not assignable to type 'Readonly<ResizablePanelProps>'.
-      Types of property 'children' are incompatible.
-        Type '[Element, Element, Element]' is not assignable to type '[ReactNode, ReactNode]'.
-          Types of property 'length' are incompatible.
-            Type '3' is not assignable to type '2'.
+      The types of 'children.length' are incompatible between these types.
+        Type '3' is not assignable to type '2'.
   Overload 2 of 2, '(props: ResizablePanelProps, context?: any): ResizablePanel', gave the following error.
     Type '{ children: [Element, Element, Element]; }' is not assignable to type 'Readonly<ResizablePanelProps>'.
       Types of property 'children' are incompatible.
@@ -33,10 +31,8 @@ tests/cases/conformance/jsx/checkJsxChildrenCanBeTupleType.tsx(17,18): error TS2
 !!! error TS2769: No overload matches this call.
 !!! error TS2769:   Overload 1 of 2, '(props: Readonly<ResizablePanelProps>): ResizablePanel', gave the following error.
 !!! error TS2769:     Type '{ children: [Element, Element, Element]; }' is not assignable to type 'Readonly<ResizablePanelProps>'.
-!!! error TS2769:       Types of property 'children' are incompatible.
-!!! error TS2769:         Type '[Element, Element, Element]' is not assignable to type '[ReactNode, ReactNode]'.
-!!! error TS2769:           Types of property 'length' are incompatible.
-!!! error TS2769:             Type '3' is not assignable to type '2'.
+!!! error TS2769:       The types of 'children.length' are incompatible between these types.
+!!! error TS2769:         Type '3' is not assignable to type '2'.
 !!! error TS2769:   Overload 2 of 2, '(props: ResizablePanelProps, context?: any): ResizablePanel', gave the following error.
 !!! error TS2769:     Type '{ children: [Element, Element, Element]; }' is not assignable to type 'Readonly<ResizablePanelProps>'.
 !!! error TS2769:       Types of property 'children' are incompatible.
diff --git a/tests/baselines/reference/checkJsxChildrenProperty15.errors.txt b/tests/baselines/reference/checkJsxChildrenProperty15.errors.txt
index 605a293ffaa..d0be275765f 100644
--- a/tests/baselines/reference/checkJsxChildrenProperty15.errors.txt
+++ b/tests/baselines/reference/checkJsxChildrenProperty15.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/jsx/file.tsx(10,13): error TS2322: Type '{ children: Element; }' is not assignable to type 'IntrinsicAttributes'.
+tests/cases/conformance/jsx/file.tsx(10,17): error TS2322: Type '{ children: Element; }' is not assignable to type 'IntrinsicAttributes'.
   Property 'children' does not exist on type 'IntrinsicAttributes'.
 tests/cases/conformance/jsx/file.tsx(11,13): error TS2322: Type '{ children: Element; key: string; }' is not assignable to type 'IntrinsicAttributes'.
   Property 'children' does not exist on type 'IntrinsicAttributes'.
@@ -17,7 +17,7 @@ tests/cases/conformance/jsx/file.tsx(12,13): error TS2322: Type '{ children: Ele
     
     // Not OK (excess children)
     const k3 = <Tag children={<div></div>} />;
-                ~~~
+                    ~~~~~~~~
 !!! error TS2322: Type '{ children: Element; }' is not assignable to type 'IntrinsicAttributes'.
 !!! error TS2322:   Property 'children' does not exist on type 'IntrinsicAttributes'.
     const k4 = <Tag key="1"><div></div></Tag>;
diff --git a/tests/baselines/reference/complexRecursiveCollections.errors.txt b/tests/baselines/reference/complexRecursiveCollections.errors.txt
index 27bb24bc5cc..cd88e596fd1 100644
--- a/tests/baselines/reference/complexRecursiveCollections.errors.txt
+++ b/tests/baselines/reference/complexRecursiveCollections.errors.txt
@@ -1,18 +1,15 @@
 tests/cases/compiler/immutable.ts(341,22): error TS2430: Interface 'Keyed<K, V>' incorrectly extends interface 'Collection<K, V>'.
-  Types of property 'toSeq' are incompatible.
-    Type '() => Keyed<K, V>' is not assignable to type '() => this'.
-      Type 'Keyed<K, V>' is not assignable to type 'this'.
-        'Keyed<K, V>' is assignable to the constraint of type 'this', but 'this' could be instantiated with a different subtype of constraint 'Keyed<K, V>'.
+  The types returned by 'toSeq()' are incompatible between these types.
+    Type 'Keyed<K, V>' is not assignable to type 'this'.
+      'Keyed<K, V>' is assignable to the constraint of type 'this', but 'this' could be instantiated with a different subtype of constraint 'Keyed<K, V>'.
 tests/cases/compiler/immutable.ts(359,22): error TS2430: Interface 'Indexed<T>' incorrectly extends interface 'Collection<number, T>'.
-  Types of property 'toSeq' are incompatible.
-    Type '() => Indexed<T>' is not assignable to type '() => this'.
-      Type 'Indexed<T>' is not assignable to type 'this'.
-        'Indexed<T>' is assignable to the constraint of type 'this', but 'this' could be instantiated with a different subtype of constraint 'Indexed<T>'.
+  The types returned by 'toSeq()' are incompatible between these types.
+    Type 'Indexed<T>' is not assignable to type 'this'.
+      'Indexed<T>' is assignable to the constraint of type 'this', but 'this' could be instantiated with a different subtype of constraint 'Indexed<T>'.
 tests/cases/compiler/immutable.ts(391,22): error TS2430: Interface 'Set<T>' incorrectly extends interface 'Collection<never, T>'.
-  Types of property 'toSeq' are incompatible.
-    Type '() => Set<T>' is not assignable to type '() => this'.
-      Type 'Set<T>' is not assignable to type 'this'.
-        'Set<T>' is assignable to the constraint of type 'this', but 'this' could be instantiated with a different subtype of constraint 'Set<T>'.
+  The types returned by 'toSeq()' are incompatible between these types.
+    Type 'Set<T>' is not assignable to type 'this'.
+      'Set<T>' is assignable to the constraint of type 'this', but 'this' could be instantiated with a different subtype of constraint 'Set<T>'.
 
 
 ==== tests/cases/compiler/complex.ts (0 errors) ====
@@ -380,10 +377,9 @@ tests/cases/compiler/immutable.ts(391,22): error TS2430: Interface 'Set<T>' inco
         export interface Keyed<K, V> extends Collection<K, V> {
                          ~~~~~
 !!! error TS2430: Interface 'Keyed<K, V>' incorrectly extends interface 'Collection<K, V>'.
-!!! error TS2430:   Types of property 'toSeq' are incompatible.
-!!! error TS2430:     Type '() => Keyed<K, V>' is not assignable to type '() => this'.
-!!! error TS2430:       Type 'Keyed<K, V>' is not assignable to type 'this'.
-!!! error TS2430:         'Keyed<K, V>' is assignable to the constraint of type 'this', but 'this' could be instantiated with a different subtype of constraint 'Keyed<K, V>'.
+!!! error TS2430:   The types returned by 'toSeq()' are incompatible between these types.
+!!! error TS2430:     Type 'Keyed<K, V>' is not assignable to type 'this'.
+!!! error TS2430:       'Keyed<K, V>' is assignable to the constraint of type 'this', but 'this' could be instantiated with a different subtype of constraint 'Keyed<K, V>'.
           toJS(): Object;
           toJSON(): { [key: string]: V };
           toSeq(): Seq.Keyed<K, V>;
@@ -404,10 +400,9 @@ tests/cases/compiler/immutable.ts(391,22): error TS2430: Interface 'Set<T>' inco
         export interface Indexed<T> extends Collection<number, T> {
                          ~~~~~~~
 !!! error TS2430: Interface 'Indexed<T>' incorrectly extends interface 'Collection<number, T>'.
-!!! error TS2430:   Types of property 'toSeq' are incompatible.
-!!! error TS2430:     Type '() => Indexed<T>' is not assignable to type '() => this'.
-!!! error TS2430:       Type 'Indexed<T>' is not assignable to type 'this'.
-!!! error TS2430:         'Indexed<T>' is assignable to the constraint of type 'this', but 'this' could be instantiated with a different subtype of constraint 'Indexed<T>'.
+!!! error TS2430:   The types returned by 'toSeq()' are incompatible between these types.
+!!! error TS2430:     Type 'Indexed<T>' is not assignable to type 'this'.
+!!! error TS2430:       'Indexed<T>' is assignable to the constraint of type 'this', but 'this' could be instantiated with a different subtype of constraint 'Indexed<T>'.
           toJS(): Array<any>;
           toJSON(): Array<T>;
           // Reading values
@@ -442,10 +437,9 @@ tests/cases/compiler/immutable.ts(391,22): error TS2430: Interface 'Set<T>' inco
         export interface Set<T> extends Collection<never, T> {
                          ~~~
 !!! error TS2430: Interface 'Set<T>' incorrectly extends interface 'Collection<never, T>'.
-!!! error TS2430:   Types of property 'toSeq' are incompatible.
-!!! error TS2430:     Type '() => Set<T>' is not assignable to type '() => this'.
-!!! error TS2430:       Type 'Set<T>' is not assignable to type 'this'.
-!!! error TS2430:         'Set<T>' is assignable to the constraint of type 'this', but 'this' could be instantiated with a different subtype of constraint 'Set<T>'.
+!!! error TS2430:   The types returned by 'toSeq()' are incompatible between these types.
+!!! error TS2430:     Type 'Set<T>' is not assignable to type 'this'.
+!!! error TS2430:       'Set<T>' is assignable to the constraint of type 'this', but 'this' could be instantiated with a different subtype of constraint 'Set<T>'.
           toJS(): Array<any>;
           toJSON(): Array<T>;
           toSeq(): Seq.Set<T>;
diff --git a/tests/baselines/reference/constructSignatureAssignabilityInInheritance.errors.txt b/tests/baselines/reference/constructSignatureAssignabilityInInheritance.errors.txt
index e326d163c8c..1cc019746ba 100644
--- a/tests/baselines/reference/constructSignatureAssignabilityInInheritance.errors.txt
+++ b/tests/baselines/reference/constructSignatureAssignabilityInInheritance.errors.txt
@@ -1,12 +1,10 @@
 tests/cases/conformance/types/typeRelationships/assignmentCompatibility/constructSignatureAssignabilityInInheritance.ts(61,15): error TS2430: Interface 'I2' incorrectly extends interface 'Base2'.
-  Types of property 'a' are incompatible.
-    Type 'new (x: number) => string' is not assignable to type 'new (x: number) => number'.
-      Type 'string' is not assignable to type 'number'.
+  The types returned by 'new a(...)' are incompatible between these types.
+    Type 'string' is not assignable to type 'number'.
 tests/cases/conformance/types/typeRelationships/assignmentCompatibility/constructSignatureAssignabilityInInheritance.ts(67,15): error TS2430: Interface 'I3' incorrectly extends interface 'Base2'.
-  Types of property 'a2' are incompatible.
-    Type 'new <T>(x: T) => string' is not assignable to type 'new <T>(x: T) => T'.
-      Type 'string' is not assignable to type 'T'.
-        'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+  The types returned by 'new a2(...)' are incompatible between these types.
+    Type 'string' is not assignable to type 'T'.
+      'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
 
 
 ==== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/constructSignatureAssignabilityInInheritance.ts (2 errors) ====
@@ -73,9 +71,8 @@ tests/cases/conformance/types/typeRelationships/assignmentCompatibility/construc
         interface I2 extends Base2 {
                   ~~
 !!! error TS2430: Interface 'I2' incorrectly extends interface 'Base2'.
-!!! error TS2430:   Types of property 'a' are incompatible.
-!!! error TS2430:     Type 'new (x: number) => string' is not assignable to type 'new (x: number) => number'.
-!!! error TS2430:       Type 'string' is not assignable to type 'number'.
+!!! error TS2430:   The types returned by 'new a(...)' are incompatible between these types.
+!!! error TS2430:     Type 'string' is not assignable to type 'number'.
             // N's
             a: new (x: number) => string; // error because base returns non-void;
         }
@@ -84,10 +81,9 @@ tests/cases/conformance/types/typeRelationships/assignmentCompatibility/construc
         interface I3 extends Base2 {
                   ~~
 !!! error TS2430: Interface 'I3' incorrectly extends interface 'Base2'.
-!!! error TS2430:   Types of property 'a2' are incompatible.
-!!! error TS2430:     Type 'new <T>(x: T) => string' is not assignable to type 'new <T>(x: T) => T'.
-!!! error TS2430:       Type 'string' is not assignable to type 'T'.
-!!! error TS2430:         'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+!!! error TS2430:   The types returned by 'new a2(...)' are incompatible between these types.
+!!! error TS2430:     Type 'string' is not assignable to type 'T'.
+!!! error TS2430:       'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
             // N's
             a2: new <T>(x: T) => string; // error because base returns non-void;
         }
diff --git a/tests/baselines/reference/constructSignatureAssignabilityInInheritance3.errors.txt b/tests/baselines/reference/constructSignatureAssignabilityInInheritance3.errors.txt
index 59d8105c59c..d4c9e808200 100644
--- a/tests/baselines/reference/constructSignatureAssignabilityInInheritance3.errors.txt
+++ b/tests/baselines/reference/constructSignatureAssignabilityInInheritance3.errors.txt
@@ -27,16 +27,14 @@ tests/cases/conformance/types/typeRelationships/assignmentCompatibility/construc
           Types of property 'a' are incompatible.
             Type 'string' is not assignable to type 'Base'.
 tests/cases/conformance/types/typeRelationships/assignmentCompatibility/constructSignatureAssignabilityInInheritance3.ts(86,19): error TS2430: Interface 'I6' incorrectly extends interface 'B'.
-  Types of property 'a2' are incompatible.
-    Type 'new <T>(x: T) => string[]' is not assignable to type 'new <T>(x: T) => T[]'.
-      Type 'string[]' is not assignable to type 'T[]'.
-        Type 'string' is not assignable to type 'T'.
-          'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+  The types returned by 'new a2(...)' are incompatible between these types.
+    Type 'string[]' is not assignable to type 'T[]'.
+      Type 'string' is not assignable to type 'T'.
+        'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
 tests/cases/conformance/types/typeRelationships/assignmentCompatibility/constructSignatureAssignabilityInInheritance3.ts(95,19): error TS2430: Interface 'I7' incorrectly extends interface 'C'.
-  Types of property 'a2' are incompatible.
-    Type 'new <T>(x: T) => T[]' is not assignable to type 'new <T>(x: T) => string[]'.
-      Type 'T[]' is not assignable to type 'string[]'.
-        Type 'T' is not assignable to type 'string'.
+  The types returned by 'new a2(...)' are incompatible between these types.
+    Type 'T[]' is not assignable to type 'string[]'.
+      Type 'T' is not assignable to type 'string'.
 
 
 ==== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/constructSignatureAssignabilityInInheritance3.ts (6 errors) ====
@@ -160,11 +158,10 @@ tests/cases/conformance/types/typeRelationships/assignmentCompatibility/construc
             interface I6 extends B {
                       ~~
 !!! error TS2430: Interface 'I6' incorrectly extends interface 'B'.
-!!! error TS2430:   Types of property 'a2' are incompatible.
-!!! error TS2430:     Type 'new <T>(x: T) => string[]' is not assignable to type 'new <T>(x: T) => T[]'.
-!!! error TS2430:       Type 'string[]' is not assignable to type 'T[]'.
-!!! error TS2430:         Type 'string' is not assignable to type 'T'.
-!!! error TS2430:           'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+!!! error TS2430:   The types returned by 'new a2(...)' are incompatible between these types.
+!!! error TS2430:     Type 'string[]' is not assignable to type 'T[]'.
+!!! error TS2430:       Type 'string' is not assignable to type 'T'.
+!!! error TS2430:         'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
                 a2: new <T>(x: T) => string[]; // error
             }
     
@@ -176,10 +173,9 @@ tests/cases/conformance/types/typeRelationships/assignmentCompatibility/construc
             interface I7 extends C {
                       ~~
 !!! error TS2430: Interface 'I7' incorrectly extends interface 'C'.
-!!! error TS2430:   Types of property 'a2' are incompatible.
-!!! error TS2430:     Type 'new <T>(x: T) => T[]' is not assignable to type 'new <T>(x: T) => string[]'.
-!!! error TS2430:       Type 'T[]' is not assignable to type 'string[]'.
-!!! error TS2430:         Type 'T' is not assignable to type 'string'.
+!!! error TS2430:   The types returned by 'new a2(...)' are incompatible between these types.
+!!! error TS2430:     Type 'T[]' is not assignable to type 'string[]'.
+!!! error TS2430:       Type 'T' is not assignable to type 'string'.
                 a2: new <T>(x: T) => T[]; // error
             }
     
diff --git a/tests/baselines/reference/contextualSignatureInstantiation4.js b/tests/baselines/reference/contextualSignatureInstantiation4.js
new file mode 100644
index 00000000000..8db041b29b5
--- /dev/null
+++ b/tests/baselines/reference/contextualSignatureInstantiation4.js
@@ -0,0 +1,29 @@
+//// [contextualSignatureInstantiation4.ts]
+// Repros from #32976
+
+declare class Banana<T extends string> { constructor(a: string, property: T) }
+
+declare function fruitFactory1<TFruit>(Fruit: new (...args: any[]) => TFruit): TFruit
+const banana1 = fruitFactory1(Banana) // Banana<any>
+
+declare function fruitFactory2<TFruit>(Fruit: new (a: string, ...args: any[]) => TFruit): TFruit
+const banana2 = fruitFactory2(Banana) // Banana<any>
+
+declare function fruitFactory3<TFruit>(Fruit: new (a: string, s: "foo", ...args: any[]) => TFruit): TFruit
+const banana3 = fruitFactory3(Banana) // Banana<"foo">
+
+declare function fruitFactory4<TFruit>(Fruit: new (a: string, ...args: "foo"[]) => TFruit): TFruit
+const banana4 = fruitFactory4(Banana) // Banana<"foo">
+
+declare function fruitFactory5<TFruit>(Fruit: new (...args: "foo"[]) => TFruit): TFruit
+const banana5 = fruitFactory5(Banana) // Banana<"foo">
+
+
+//// [contextualSignatureInstantiation4.js]
+"use strict";
+// Repros from #32976
+var banana1 = fruitFactory1(Banana); // Banana<any>
+var banana2 = fruitFactory2(Banana); // Banana<any>
+var banana3 = fruitFactory3(Banana); // Banana<"foo">
+var banana4 = fruitFactory4(Banana); // Banana<"foo">
+var banana5 = fruitFactory5(Banana); // Banana<"foo">
diff --git a/tests/baselines/reference/contextualSignatureInstantiation4.symbols b/tests/baselines/reference/contextualSignatureInstantiation4.symbols
new file mode 100644
index 00000000000..a08486b43d8
--- /dev/null
+++ b/tests/baselines/reference/contextualSignatureInstantiation4.symbols
@@ -0,0 +1,79 @@
+=== tests/cases/compiler/contextualSignatureInstantiation4.ts ===
+// Repros from #32976
+
+declare class Banana<T extends string> { constructor(a: string, property: T) }
+>Banana : Symbol(Banana, Decl(contextualSignatureInstantiation4.ts, 0, 0))
+>T : Symbol(T, Decl(contextualSignatureInstantiation4.ts, 2, 21))
+>a : Symbol(a, Decl(contextualSignatureInstantiation4.ts, 2, 53))
+>property : Symbol(property, Decl(contextualSignatureInstantiation4.ts, 2, 63))
+>T : Symbol(T, Decl(contextualSignatureInstantiation4.ts, 2, 21))
+
+declare function fruitFactory1<TFruit>(Fruit: new (...args: any[]) => TFruit): TFruit
+>fruitFactory1 : Symbol(fruitFactory1, Decl(contextualSignatureInstantiation4.ts, 2, 78))
+>TFruit : Symbol(TFruit, Decl(contextualSignatureInstantiation4.ts, 4, 31))
+>Fruit : Symbol(Fruit, Decl(contextualSignatureInstantiation4.ts, 4, 39))
+>args : Symbol(args, Decl(contextualSignatureInstantiation4.ts, 4, 51))
+>TFruit : Symbol(TFruit, Decl(contextualSignatureInstantiation4.ts, 4, 31))
+>TFruit : Symbol(TFruit, Decl(contextualSignatureInstantiation4.ts, 4, 31))
+
+const banana1 = fruitFactory1(Banana) // Banana<any>
+>banana1 : Symbol(banana1, Decl(contextualSignatureInstantiation4.ts, 5, 5))
+>fruitFactory1 : Symbol(fruitFactory1, Decl(contextualSignatureInstantiation4.ts, 2, 78))
+>Banana : Symbol(Banana, Decl(contextualSignatureInstantiation4.ts, 0, 0))
+
+declare function fruitFactory2<TFruit>(Fruit: new (a: string, ...args: any[]) => TFruit): TFruit
+>fruitFactory2 : Symbol(fruitFactory2, Decl(contextualSignatureInstantiation4.ts, 5, 37))
+>TFruit : Symbol(TFruit, Decl(contextualSignatureInstantiation4.ts, 7, 31))
+>Fruit : Symbol(Fruit, Decl(contextualSignatureInstantiation4.ts, 7, 39))
+>a : Symbol(a, Decl(contextualSignatureInstantiation4.ts, 7, 51))
+>args : Symbol(args, Decl(contextualSignatureInstantiation4.ts, 7, 61))
+>TFruit : Symbol(TFruit, Decl(contextualSignatureInstantiation4.ts, 7, 31))
+>TFruit : Symbol(TFruit, Decl(contextualSignatureInstantiation4.ts, 7, 31))
+
+const banana2 = fruitFactory2(Banana) // Banana<any>
+>banana2 : Symbol(banana2, Decl(contextualSignatureInstantiation4.ts, 8, 5))
+>fruitFactory2 : Symbol(fruitFactory2, Decl(contextualSignatureInstantiation4.ts, 5, 37))
+>Banana : Symbol(Banana, Decl(contextualSignatureInstantiation4.ts, 0, 0))
+
+declare function fruitFactory3<TFruit>(Fruit: new (a: string, s: "foo", ...args: any[]) => TFruit): TFruit
+>fruitFactory3 : Symbol(fruitFactory3, Decl(contextualSignatureInstantiation4.ts, 8, 37))
+>TFruit : Symbol(TFruit, Decl(contextualSignatureInstantiation4.ts, 10, 31))
+>Fruit : Symbol(Fruit, Decl(contextualSignatureInstantiation4.ts, 10, 39))
+>a : Symbol(a, Decl(contextualSignatureInstantiation4.ts, 10, 51))
+>s : Symbol(s, Decl(contextualSignatureInstantiation4.ts, 10, 61))
+>args : Symbol(args, Decl(contextualSignatureInstantiation4.ts, 10, 71))
+>TFruit : Symbol(TFruit, Decl(contextualSignatureInstantiation4.ts, 10, 31))
+>TFruit : Symbol(TFruit, Decl(contextualSignatureInstantiation4.ts, 10, 31))
+
+const banana3 = fruitFactory3(Banana) // Banana<"foo">
+>banana3 : Symbol(banana3, Decl(contextualSignatureInstantiation4.ts, 11, 5))
+>fruitFactory3 : Symbol(fruitFactory3, Decl(contextualSignatureInstantiation4.ts, 8, 37))
+>Banana : Symbol(Banana, Decl(contextualSignatureInstantiation4.ts, 0, 0))
+
+declare function fruitFactory4<TFruit>(Fruit: new (a: string, ...args: "foo"[]) => TFruit): TFruit
+>fruitFactory4 : Symbol(fruitFactory4, Decl(contextualSignatureInstantiation4.ts, 11, 37))
+>TFruit : Symbol(TFruit, Decl(contextualSignatureInstantiation4.ts, 13, 31))
+>Fruit : Symbol(Fruit, Decl(contextualSignatureInstantiation4.ts, 13, 39))
+>a : Symbol(a, Decl(contextualSignatureInstantiation4.ts, 13, 51))
+>args : Symbol(args, Decl(contextualSignatureInstantiation4.ts, 13, 61))
+>TFruit : Symbol(TFruit, Decl(contextualSignatureInstantiation4.ts, 13, 31))
+>TFruit : Symbol(TFruit, Decl(contextualSignatureInstantiation4.ts, 13, 31))
+
+const banana4 = fruitFactory4(Banana) // Banana<"foo">
+>banana4 : Symbol(banana4, Decl(contextualSignatureInstantiation4.ts, 14, 5))
+>fruitFactory4 : Symbol(fruitFactory4, Decl(contextualSignatureInstantiation4.ts, 11, 37))
+>Banana : Symbol(Banana, Decl(contextualSignatureInstantiation4.ts, 0, 0))
+
+declare function fruitFactory5<TFruit>(Fruit: new (...args: "foo"[]) => TFruit): TFruit
+>fruitFactory5 : Symbol(fruitFactory5, Decl(contextualSignatureInstantiation4.ts, 14, 37))
+>TFruit : Symbol(TFruit, Decl(contextualSignatureInstantiation4.ts, 16, 31))
+>Fruit : Symbol(Fruit, Decl(contextualSignatureInstantiation4.ts, 16, 39))
+>args : Symbol(args, Decl(contextualSignatureInstantiation4.ts, 16, 51))
+>TFruit : Symbol(TFruit, Decl(contextualSignatureInstantiation4.ts, 16, 31))
+>TFruit : Symbol(TFruit, Decl(contextualSignatureInstantiation4.ts, 16, 31))
+
+const banana5 = fruitFactory5(Banana) // Banana<"foo">
+>banana5 : Symbol(banana5, Decl(contextualSignatureInstantiation4.ts, 17, 5))
+>fruitFactory5 : Symbol(fruitFactory5, Decl(contextualSignatureInstantiation4.ts, 14, 37))
+>Banana : Symbol(Banana, Decl(contextualSignatureInstantiation4.ts, 0, 0))
+
diff --git a/tests/baselines/reference/contextualSignatureInstantiation4.types b/tests/baselines/reference/contextualSignatureInstantiation4.types
new file mode 100644
index 00000000000..1c27df7ff69
--- /dev/null
+++ b/tests/baselines/reference/contextualSignatureInstantiation4.types
@@ -0,0 +1,67 @@
+=== tests/cases/compiler/contextualSignatureInstantiation4.ts ===
+// Repros from #32976
+
+declare class Banana<T extends string> { constructor(a: string, property: T) }
+>Banana : Banana<T>
+>a : string
+>property : T
+
+declare function fruitFactory1<TFruit>(Fruit: new (...args: any[]) => TFruit): TFruit
+>fruitFactory1 : <TFruit>(Fruit: new (...args: any[]) => TFruit) => TFruit
+>Fruit : new (...args: any[]) => TFruit
+>args : any[]
+
+const banana1 = fruitFactory1(Banana) // Banana<any>
+>banana1 : Banana<any>
+>fruitFactory1(Banana) : Banana<any>
+>fruitFactory1 : <TFruit>(Fruit: new (...args: any[]) => TFruit) => TFruit
+>Banana : typeof Banana
+
+declare function fruitFactory2<TFruit>(Fruit: new (a: string, ...args: any[]) => TFruit): TFruit
+>fruitFactory2 : <TFruit>(Fruit: new (a: string, ...args: any[]) => TFruit) => TFruit
+>Fruit : new (a: string, ...args: any[]) => TFruit
+>a : string
+>args : any[]
+
+const banana2 = fruitFactory2(Banana) // Banana<any>
+>banana2 : Banana<any>
+>fruitFactory2(Banana) : Banana<any>
+>fruitFactory2 : <TFruit>(Fruit: new (a: string, ...args: any[]) => TFruit) => TFruit
+>Banana : typeof Banana
+
+declare function fruitFactory3<TFruit>(Fruit: new (a: string, s: "foo", ...args: any[]) => TFruit): TFruit
+>fruitFactory3 : <TFruit>(Fruit: new (a: string, s: "foo", ...args: any[]) => TFruit) => TFruit
+>Fruit : new (a: string, s: "foo", ...args: any[]) => TFruit
+>a : string
+>s : "foo"
+>args : any[]
+
+const banana3 = fruitFactory3(Banana) // Banana<"foo">
+>banana3 : Banana<"foo">
+>fruitFactory3(Banana) : Banana<"foo">
+>fruitFactory3 : <TFruit>(Fruit: new (a: string, s: "foo", ...args: any[]) => TFruit) => TFruit
+>Banana : typeof Banana
+
+declare function fruitFactory4<TFruit>(Fruit: new (a: string, ...args: "foo"[]) => TFruit): TFruit
+>fruitFactory4 : <TFruit>(Fruit: new (a: string, ...args: "foo"[]) => TFruit) => TFruit
+>Fruit : new (a: string, ...args: "foo"[]) => TFruit
+>a : string
+>args : "foo"[]
+
+const banana4 = fruitFactory4(Banana) // Banana<"foo">
+>banana4 : Banana<"foo">
+>fruitFactory4(Banana) : Banana<"foo">
+>fruitFactory4 : <TFruit>(Fruit: new (a: string, ...args: "foo"[]) => TFruit) => TFruit
+>Banana : typeof Banana
+
+declare function fruitFactory5<TFruit>(Fruit: new (...args: "foo"[]) => TFruit): TFruit
+>fruitFactory5 : <TFruit>(Fruit: new (...args: "foo"[]) => TFruit) => TFruit
+>Fruit : new (...args: "foo"[]) => TFruit
+>args : "foo"[]
+
+const banana5 = fruitFactory5(Banana) // Banana<"foo">
+>banana5 : Banana<"foo">
+>fruitFactory5(Banana) : Banana<"foo">
+>fruitFactory5 : <TFruit>(Fruit: new (...args: "foo"[]) => TFruit) => TFruit
+>Banana : typeof Banana
+
diff --git a/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes02.errors.txt b/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes02.errors.txt
index ff2ec7e5106..b66975fdb73 100644
--- a/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes02.errors.txt
+++ b/tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes02.errors.txt
@@ -1,34 +1,34 @@
-tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(27,13): error TS2769: No overload matches this call.
+tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(27,64): error TS2769: No overload matches this call.
   Overload 1 of 2, '(buttonProps: ButtonProps): Element', gave the following error.
     Type '{ extra: true; onClick: (k: "left" | "right") => void; }' is not assignable to type 'IntrinsicAttributes & ButtonProps'.
       Property 'extra' does not exist on type 'IntrinsicAttributes & ButtonProps'.
   Overload 2 of 2, '(linkProps: LinkProps): Element', gave the following error.
     Type '{ extra: true; onClick: (k: "left" | "right") => void; }' is not assignable to type 'IntrinsicAttributes & LinkProps'.
       Property 'extra' does not exist on type 'IntrinsicAttributes & LinkProps'.
-tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(28,13): error TS2769: No overload matches this call.
+tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(28,12): error TS2769: No overload matches this call.
   Overload 1 of 2, '(buttonProps: ButtonProps): Element', gave the following error.
     Type '{ onClick: (k: "left" | "right") => void; extra: true; }' is not assignable to type 'IntrinsicAttributes & ButtonProps'.
       Property 'extra' does not exist on type 'IntrinsicAttributes & ButtonProps'.
   Overload 2 of 2, '(linkProps: LinkProps): Element', gave the following error.
     Type '{ onClick: (k: "left" | "right") => void; extra: true; }' is not assignable to type 'IntrinsicAttributes & LinkProps'.
       Property 'onClick' does not exist on type 'IntrinsicAttributes & LinkProps'.
-tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(29,13): error TS2769: No overload matches this call.
+tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(29,43): error TS2769: No overload matches this call.
   Overload 1 of 2, '(buttonProps: ButtonProps): Element', gave the following error.
     Type '{ extra: true; goTo: string; }' is not assignable to type 'IntrinsicAttributes & ButtonProps'.
       Property 'extra' does not exist on type 'IntrinsicAttributes & ButtonProps'.
   Overload 2 of 2, '(linkProps: LinkProps): Element', gave the following error.
     Type '{ extra: true; goTo: "home"; }' is not assignable to type 'IntrinsicAttributes & LinkProps'.
       Property 'extra' does not exist on type 'IntrinsicAttributes & LinkProps'.
-tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(30,13): error TS2769: No overload matches this call.
+tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(30,12): error TS2769: No overload matches this call.
   Overload 1 of 2, '(buttonProps: ButtonProps): Element', gave the following error.
     Type '{ goTo: string; extra: true; }' is not assignable to type 'IntrinsicAttributes & ButtonProps'.
       Property 'goTo' does not exist on type 'IntrinsicAttributes & ButtonProps'.
   Overload 2 of 2, '(linkProps: LinkProps): Element', gave the following error.
     Type '{ goTo: "home"; extra: true; }' is not assignable to type 'IntrinsicAttributes & LinkProps'.
       Property 'extra' does not exist on type 'IntrinsicAttributes & LinkProps'.
-tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(33,13): error TS2322: Type '{ extra: true; onClick: (k: "left" | "right") => void; }' is not assignable to type 'IntrinsicAttributes & ButtonProps'.
+tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(33,65): error TS2322: Type '{ extra: true; onClick: (k: "left" | "right") => void; }' is not assignable to type 'IntrinsicAttributes & ButtonProps'.
   Property 'extra' does not exist on type 'IntrinsicAttributes & ButtonProps'.
-tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(36,13): error TS2322: Type '{ extra: true; goTo: "home"; }' is not assignable to type 'IntrinsicAttributes & LinkProps'.
+tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(36,44): error TS2322: Type '{ extra: true; goTo: "home"; }' is not assignable to type 'IntrinsicAttributes & LinkProps'.
   Property 'extra' does not exist on type 'IntrinsicAttributes & LinkProps'.
 
 
@@ -60,7 +60,7 @@ tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(36,13): err
     }
     
     const b0 = <MainButton {...{onClick: (k) => {console.log(k)}}} extra />;  // k has type "left" | "right"
-                ~~~~~~~~~~
+                                                                   ~~~~~
 !!! error TS2769: No overload matches this call.
 !!! error TS2769:   Overload 1 of 2, '(buttonProps: ButtonProps): Element', gave the following error.
 !!! error TS2769:     Type '{ extra: true; onClick: (k: "left" | "right") => void; }' is not assignable to type 'IntrinsicAttributes & ButtonProps'.
@@ -69,7 +69,7 @@ tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(36,13): err
 !!! error TS2769:     Type '{ extra: true; onClick: (k: "left" | "right") => void; }' is not assignable to type 'IntrinsicAttributes & LinkProps'.
 !!! error TS2769:       Property 'extra' does not exist on type 'IntrinsicAttributes & LinkProps'.
     const b2 = <MainButton onClick={(k)=>{console.log(k)}} extra />;  // k has type "left" | "right"
-                ~~~~~~~~~~
+               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2769: No overload matches this call.
 !!! error TS2769:   Overload 1 of 2, '(buttonProps: ButtonProps): Element', gave the following error.
 !!! error TS2769:     Type '{ onClick: (k: "left" | "right") => void; extra: true; }' is not assignable to type 'IntrinsicAttributes & ButtonProps'.
@@ -78,7 +78,7 @@ tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(36,13): err
 !!! error TS2769:     Type '{ onClick: (k: "left" | "right") => void; extra: true; }' is not assignable to type 'IntrinsicAttributes & LinkProps'.
 !!! error TS2769:       Property 'onClick' does not exist on type 'IntrinsicAttributes & LinkProps'.
     const b3 = <MainButton {...{goTo:"home"}} extra />;  // goTo has type"home" | "contact"
-                ~~~~~~~~~~
+                                              ~~~~~
 !!! error TS2769: No overload matches this call.
 !!! error TS2769:   Overload 1 of 2, '(buttonProps: ButtonProps): Element', gave the following error.
 !!! error TS2769:     Type '{ extra: true; goTo: string; }' is not assignable to type 'IntrinsicAttributes & ButtonProps'.
@@ -87,7 +87,7 @@ tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(36,13): err
 !!! error TS2769:     Type '{ extra: true; goTo: "home"; }' is not assignable to type 'IntrinsicAttributes & LinkProps'.
 !!! error TS2769:       Property 'extra' does not exist on type 'IntrinsicAttributes & LinkProps'.
     const b4 = <MainButton goTo="home" extra />;  // goTo has type "home" | "contact"
-                ~~~~~~~~~~
+               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2769: No overload matches this call.
 !!! error TS2769:   Overload 1 of 2, '(buttonProps: ButtonProps): Element', gave the following error.
 !!! error TS2769:     Type '{ goTo: string; extra: true; }' is not assignable to type 'IntrinsicAttributes & ButtonProps'.
@@ -98,13 +98,13 @@ tests/cases/conformance/types/contextualTypes/jsxAttributes/file.tsx(36,13): err
     
     export function NoOverload(buttonProps: ButtonProps): JSX.Element { return undefined }
     const c1 = <NoOverload  {...{onClick: (k) => {console.log(k)}}} extra />;  // k has type any
-                ~~~~~~~~~~
+                                                                    ~~~~~
 !!! error TS2322: Type '{ extra: true; onClick: (k: "left" | "right") => void; }' is not assignable to type 'IntrinsicAttributes & ButtonProps'.
 !!! error TS2322:   Property 'extra' does not exist on type 'IntrinsicAttributes & ButtonProps'.
     
     export function NoOverload1(linkProps: LinkProps): JSX.Element { return undefined }
     const d1 = <NoOverload1 {...{goTo:"home"}} extra  />;  // goTo has type "home" | "contact"
-                ~~~~~~~~~~~
+                                               ~~~~~
 !!! error TS2322: Type '{ extra: true; goTo: "home"; }' is not assignable to type 'IntrinsicAttributes & LinkProps'.
 !!! error TS2322:   Property 'extra' does not exist on type 'IntrinsicAttributes & LinkProps'.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/correctOrderOfPromiseMethod.js b/tests/baselines/reference/correctOrderOfPromiseMethod.js
index 58c98189a43..fadda95374f 100644
--- a/tests/baselines/reference/correctOrderOfPromiseMethod.js
+++ b/tests/baselines/reference/correctOrderOfPromiseMethod.js
@@ -15,7 +15,7 @@ async function countEverything(): Promise<number> {
     const [resultA, resultB] = await Promise.all([
         providerA(),
         providerB(),
-    ]);
+    ] as const);
 
     const dataA: A[] = resultA;
     const dataB: B[] = resultB;
@@ -23,7 +23,8 @@ async function countEverything(): Promise<number> {
         return dataA.length + dataB.length;
     }
     return 0;
-}
+}
+
 
 //// [correctOrderOfPromiseMethod.js]
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
diff --git a/tests/baselines/reference/correctOrderOfPromiseMethod.symbols b/tests/baselines/reference/correctOrderOfPromiseMethod.symbols
index 290b482e5c7..1e67e9444c6 100644
--- a/tests/baselines/reference/correctOrderOfPromiseMethod.symbols
+++ b/tests/baselines/reference/correctOrderOfPromiseMethod.symbols
@@ -43,7 +43,7 @@ async function countEverything(): Promise<number> {
         providerB(),
 >providerB : Symbol(providerB, Decl(correctOrderOfPromiseMethod.ts, 11, 9))
 
-    ]);
+    ] as const);
 
     const dataA: A[] = resultA;
 >dataA : Symbol(dataA, Decl(correctOrderOfPromiseMethod.ts, 18, 9))
@@ -69,3 +69,4 @@ async function countEverything(): Promise<number> {
     }
     return 0;
 }
+
diff --git a/tests/baselines/reference/correctOrderOfPromiseMethod.types b/tests/baselines/reference/correctOrderOfPromiseMethod.types
index 5e8eaa72f42..a6f2c46782e 100644
--- a/tests/baselines/reference/correctOrderOfPromiseMethod.types
+++ b/tests/baselines/reference/correctOrderOfPromiseMethod.types
@@ -28,12 +28,13 @@ async function countEverything(): Promise<number> {
     const [resultA, resultB] = await Promise.all([
 >resultA : A[]
 >resultB : B[]
->await Promise.all([        providerA(),        providerB(),    ]) : [A[], B[]]
->Promise.all([        providerA(),        providerB(),    ]) : Promise<[A[], B[]]>
->Promise.all : { <TAll>(values: Iterable<TAll | PromiseLike<TAll>>): Promise<TAll[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>, T10 | PromiseLike<T10>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>]): Promise<[T1, T2, T3, T4, T5, T6, T7]>; <T1, T2, T3, T4, T5, T6>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[T1, T2, T3, T4, T5, T6]>; <T1, T2, T3, T4, T5>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>]): Promise<[T1, T2, T3, T4, T5]>; <T1, T2, T3, T4>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[T1, T2, T3, T4]>; <T1, T2, T3>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>; <T1, T2>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>; <T>(values: (T | PromiseLike<T>)[]): Promise<T[]>; }
+>await Promise.all([        providerA(),        providerB(),    ] as const) : [A[], B[]]
+>Promise.all([        providerA(),        providerB(),    ] as const) : Promise<[A[], B[]]>
+>Promise.all : { <TAll>(values: Iterable<TAll | PromiseLike<TAll>>): Promise<TAll[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>, T10 | PromiseLike<T10>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>]): Promise<[T1, T2, T3, T4, T5, T6, T7]>; <T1, T2, T3, T4, T5, T6>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[T1, T2, T3, T4, T5, T6]>; <T1, T2, T3, T4, T5>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>]): Promise<[T1, T2, T3, T4, T5]>; <T1, T2, T3, T4>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[T1, T2, T3, T4]>; <T1, T2, T3>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>; <T1, T2>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>; <T>(values: readonly (T | PromiseLike<T>)[]): Promise<T[]>; }
 >Promise : PromiseConstructor
->all : { <TAll>(values: Iterable<TAll | PromiseLike<TAll>>): Promise<TAll[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>, T10 | PromiseLike<T10>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>]): Promise<[T1, T2, T3, T4, T5, T6, T7]>; <T1, T2, T3, T4, T5, T6>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[T1, T2, T3, T4, T5, T6]>; <T1, T2, T3, T4, T5>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>]): Promise<[T1, T2, T3, T4, T5]>; <T1, T2, T3, T4>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[T1, T2, T3, T4]>; <T1, T2, T3>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>; <T1, T2>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>; <T>(values: (T | PromiseLike<T>)[]): Promise<T[]>; }
->[        providerA(),        providerB(),    ] : [Promise<A[]>, Promise<B[]>]
+>all : { <TAll>(values: Iterable<TAll | PromiseLike<TAll>>): Promise<TAll[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>, T10 | PromiseLike<T10>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>]): Promise<[T1, T2, T3, T4, T5, T6, T7]>; <T1, T2, T3, T4, T5, T6>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[T1, T2, T3, T4, T5, T6]>; <T1, T2, T3, T4, T5>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>]): Promise<[T1, T2, T3, T4, T5]>; <T1, T2, T3, T4>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[T1, T2, T3, T4]>; <T1, T2, T3>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>; <T1, T2>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>; <T>(values: readonly (T | PromiseLike<T>)[]): Promise<T[]>; }
+>[        providerA(),        providerB(),    ] as const : readonly [Promise<A[]>, Promise<B[]>]
+>[        providerA(),        providerB(),    ] : readonly [Promise<A[]>, Promise<B[]>]
 
         providerA(),
 >providerA() : Promise<A[]>
@@ -43,7 +44,7 @@ async function countEverything(): Promise<number> {
 >providerB() : Promise<B[]>
 >providerB : () => Promise<B[]>
 
-    ]);
+    ] as const);
 
     const dataA: A[] = resultA;
 >dataA : A[]
@@ -70,3 +71,4 @@ async function countEverything(): Promise<number> {
     return 0;
 >0 : 0
 }
+
diff --git a/tests/baselines/reference/covariantCallbacks.errors.txt b/tests/baselines/reference/covariantCallbacks.errors.txt
index 9ee5a9e2fed..401bf454baa 100644
--- a/tests/baselines/reference/covariantCallbacks.errors.txt
+++ b/tests/baselines/reference/covariantCallbacks.errors.txt
@@ -10,9 +10,8 @@ tests/cases/conformance/types/typeRelationships/assignmentCompatibility/covarian
           Type 'A' is not assignable to type 'B'.
 tests/cases/conformance/types/typeRelationships/assignmentCompatibility/covariantCallbacks.ts(43,5): error TS2322: Type 'AList2' is not assignable to type 'BList2'.
   Types of property 'forEach' are incompatible.
-    Type '(cb: (item: A) => boolean) => void' is not assignable to type '(cb: (item: A) => void) => void'.
-      Types of parameters 'cb' and 'cb' are incompatible.
-        Type 'void' is not assignable to type 'boolean'.
+    Types of parameters 'cb' and 'cb' are incompatible.
+      Type 'void' is not assignable to type 'boolean'.
 tests/cases/conformance/types/typeRelationships/assignmentCompatibility/covariantCallbacks.ts(56,5): error TS2322: Type 'AList3' is not assignable to type 'BList3'.
   Types of property 'forEach' are incompatible.
     Type '(cb: (item: A) => void) => void' is not assignable to type '(cb: (item: A, context: any) => void) => void'.
@@ -86,9 +85,8 @@ tests/cases/conformance/types/typeRelationships/assignmentCompatibility/covarian
         ~
 !!! error TS2322: Type 'AList2' is not assignable to type 'BList2'.
 !!! error TS2322:   Types of property 'forEach' are incompatible.
-!!! error TS2322:     Type '(cb: (item: A) => boolean) => void' is not assignable to type '(cb: (item: A) => void) => void'.
-!!! error TS2322:       Types of parameters 'cb' and 'cb' are incompatible.
-!!! error TS2322:         Type 'void' is not assignable to type 'boolean'.
+!!! error TS2322:     Types of parameters 'cb' and 'cb' are incompatible.
+!!! error TS2322:       Type 'void' is not assignable to type 'boolean'.
     }
     
     interface AList3 {
diff --git a/tests/baselines/reference/decoratorCallGeneric.errors.txt b/tests/baselines/reference/decoratorCallGeneric.errors.txt
index c2e4042743e..495160a191b 100644
--- a/tests/baselines/reference/decoratorCallGeneric.errors.txt
+++ b/tests/baselines/reference/decoratorCallGeneric.errors.txt
@@ -1,7 +1,6 @@
 tests/cases/conformance/decorators/decoratorCallGeneric.ts(7,2): error TS2345: Argument of type 'typeof C' is not assignable to parameter of type 'I<C>'.
-  Types of property 'm' are incompatible.
-    Type '() => void' is not assignable to type '() => C'.
-      Type 'void' is not assignable to type 'C'.
+  The types returned by 'm()' are incompatible between these types.
+    Type 'void' is not assignable to type 'C'.
 
 
 ==== tests/cases/conformance/decorators/decoratorCallGeneric.ts (1 errors) ====
@@ -14,9 +13,8 @@ tests/cases/conformance/decorators/decoratorCallGeneric.ts(7,2): error TS2345: A
     @dec
      ~~~
 !!! error TS2345: Argument of type 'typeof C' is not assignable to parameter of type 'I<C>'.
-!!! error TS2345:   Types of property 'm' are incompatible.
-!!! error TS2345:     Type '() => void' is not assignable to type '() => C'.
-!!! error TS2345:       Type 'void' is not assignable to type 'C'.
+!!! error TS2345:   The types returned by 'm()' are incompatible between these types.
+!!! error TS2345:     Type 'void' is not assignable to type 'C'.
     class C {
         _brand: any;
         static m() {}
diff --git a/tests/baselines/reference/deepExcessPropertyCheckingWhenTargetIsIntersection.errors.txt b/tests/baselines/reference/deepExcessPropertyCheckingWhenTargetIsIntersection.errors.txt
index 6a83638ba90..1f2552d47f2 100644
--- a/tests/baselines/reference/deepExcessPropertyCheckingWhenTargetIsIntersection.errors.txt
+++ b/tests/baselines/reference/deepExcessPropertyCheckingWhenTargetIsIntersection.errors.txt
@@ -1,10 +1,8 @@
 tests/cases/compiler/deepExcessPropertyCheckingWhenTargetIsIntersection.ts(21,33): error TS2322: Type '{ INVALID_PROP_NAME: string; ariaLabel: string; }' is not assignable to type 'ITestProps'.
   Object literal may only specify known properties, and 'INVALID_PROP_NAME' does not exist in type 'ITestProps'.
-tests/cases/compiler/deepExcessPropertyCheckingWhenTargetIsIntersection.ts(27,34): error TS2326: Types of property 'icon' are incompatible.
-  Type '{ props: { INVALID_PROP_NAME: string; ariaLabel: string; }; }' is not assignable to type 'NestedProp<ITestProps>'.
-    Types of property 'props' are incompatible.
-      Type '{ INVALID_PROP_NAME: string; ariaLabel: string; }' is not assignable to type 'ITestProps'.
-        Object literal may only specify known properties, and 'INVALID_PROP_NAME' does not exist in type 'ITestProps'.
+tests/cases/compiler/deepExcessPropertyCheckingWhenTargetIsIntersection.ts(27,34): error TS2200: The types of 'icon.props' are incompatible between these types.
+  Type '{ INVALID_PROP_NAME: string; ariaLabel: string; }' is not assignable to type 'ITestProps'.
+    Object literal may only specify known properties, and 'INVALID_PROP_NAME' does not exist in type 'ITestProps'.
 
 
 ==== tests/cases/compiler/deepExcessPropertyCheckingWhenTargetIsIntersection.ts (2 errors) ====
@@ -40,9 +38,7 @@ tests/cases/compiler/deepExcessPropertyCheckingWhenTargetIsIntersection.ts(27,34
     
     TestComponent2({icon: { props: { INVALID_PROP_NAME: 'share', ariaLabel: 'test label' } }});
                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2326: Types of property 'icon' are incompatible.
-!!! error TS2326:   Type '{ props: { INVALID_PROP_NAME: string; ariaLabel: string; }; }' is not assignable to type 'NestedProp<ITestProps>'.
-!!! error TS2326:     Types of property 'props' are incompatible.
-!!! error TS2326:       Type '{ INVALID_PROP_NAME: string; ariaLabel: string; }' is not assignable to type 'ITestProps'.
-!!! error TS2326:         Object literal may only specify known properties, and 'INVALID_PROP_NAME' does not exist in type 'ITestProps'.
+!!! error TS2200: The types of 'icon.props' are incompatible between these types.
+!!! error TS2200:   Type '{ INVALID_PROP_NAME: string; ariaLabel: string; }' is not assignable to type 'ITestProps'.
+!!! error TS2200:     Object literal may only specify known properties, and 'INVALID_PROP_NAME' does not exist in type 'ITestProps'.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/deeplyNestedAssignabilityErrorsCombined.errors.txt b/tests/baselines/reference/deeplyNestedAssignabilityErrorsCombined.errors.txt
new file mode 100644
index 00000000000..6245d06d2b7
--- /dev/null
+++ b/tests/baselines/reference/deeplyNestedAssignabilityErrorsCombined.errors.txt
@@ -0,0 +1,32 @@
+tests/cases/compiler/deeplyNestedAssignabilityErrorsCombined.ts(3,1): error TS2322: Type '{ a: { b: { c: { d: { e: { f(): { g: number; }; }; }; }; }; }; }' is not assignable to type '{ a: { b: { c: { d: { e: { f(): { g: string; }; }; }; }; }; }; }'.
+  The types of 'a.b.c.d.e.f().g' are incompatible between these types.
+    Type 'number' is not assignable to type 'string'.
+tests/cases/compiler/deeplyNestedAssignabilityErrorsCombined.ts(15,1): error TS2322: Type '{ a: { b: { c: { d: { e: { f: typeof Ctor2; }; }; }; }; }; }' is not assignable to type '{ a: { b: { c: { d: { e: { f: typeof Ctor1; }; }; }; }; }; }'.
+  The types of '(new a.b.c.d.e.f()).g' are incompatible between these types.
+    Type 'number' is not assignable to type 'string'.
+
+
+==== tests/cases/compiler/deeplyNestedAssignabilityErrorsCombined.ts (2 errors) ====
+    let x = { a: { b: { c: { d: { e: { f() { return { g: "hello" }; } } } } } } };
+    let y = { a: { b: { c: { d: { e: { f() { return { g: 12345 }; } } } } } } };
+    x = y;
+    ~
+!!! error TS2322: Type '{ a: { b: { c: { d: { e: { f(): { g: number; }; }; }; }; }; }; }' is not assignable to type '{ a: { b: { c: { d: { e: { f(): { g: string; }; }; }; }; }; }; }'.
+!!! error TS2322:   The types of 'a.b.c.d.e.f().g' are incompatible between these types.
+!!! error TS2322:     Type 'number' is not assignable to type 'string'.
+    
+    class Ctor1 {
+        g = "ok"
+    }
+    
+    class Ctor2 {
+        g = 12;
+    }
+    
+    let x2 = { a: { b: { c: { d: { e: { f: Ctor1 } } } } } };
+    let y2 = { a: { b: { c: { d: { e: { f: Ctor2 } } } } } };
+    x2 = y2;
+    ~~
+!!! error TS2322: Type '{ a: { b: { c: { d: { e: { f: typeof Ctor2; }; }; }; }; }; }' is not assignable to type '{ a: { b: { c: { d: { e: { f: typeof Ctor1; }; }; }; }; }; }'.
+!!! error TS2322:   The types of '(new a.b.c.d.e.f()).g' are incompatible between these types.
+!!! error TS2322:     Type 'number' is not assignable to type 'string'.
\ No newline at end of file
diff --git a/tests/baselines/reference/deeplyNestedAssignabilityErrorsCombined.js b/tests/baselines/reference/deeplyNestedAssignabilityErrorsCombined.js
new file mode 100644
index 00000000000..01bdcc7f253
--- /dev/null
+++ b/tests/baselines/reference/deeplyNestedAssignabilityErrorsCombined.js
@@ -0,0 +1,36 @@
+//// [deeplyNestedAssignabilityErrorsCombined.ts]
+let x = { a: { b: { c: { d: { e: { f() { return { g: "hello" }; } } } } } } };
+let y = { a: { b: { c: { d: { e: { f() { return { g: 12345 }; } } } } } } };
+x = y;
+
+class Ctor1 {
+    g = "ok"
+}
+
+class Ctor2 {
+    g = 12;
+}
+
+let x2 = { a: { b: { c: { d: { e: { f: Ctor1 } } } } } };
+let y2 = { a: { b: { c: { d: { e: { f: Ctor2 } } } } } };
+x2 = y2;
+
+//// [deeplyNestedAssignabilityErrorsCombined.js]
+var x = { a: { b: { c: { d: { e: { f: function () { return { g: "hello" }; } } } } } } };
+var y = { a: { b: { c: { d: { e: { f: function () { return { g: 12345 }; } } } } } } };
+x = y;
+var Ctor1 = /** @class */ (function () {
+    function Ctor1() {
+        this.g = "ok";
+    }
+    return Ctor1;
+}());
+var Ctor2 = /** @class */ (function () {
+    function Ctor2() {
+        this.g = 12;
+    }
+    return Ctor2;
+}());
+var x2 = { a: { b: { c: { d: { e: { f: Ctor1 } } } } } };
+var y2 = { a: { b: { c: { d: { e: { f: Ctor2 } } } } } };
+x2 = y2;
diff --git a/tests/baselines/reference/deeplyNestedAssignabilityErrorsCombined.symbols b/tests/baselines/reference/deeplyNestedAssignabilityErrorsCombined.symbols
new file mode 100644
index 00000000000..12333869923
--- /dev/null
+++ b/tests/baselines/reference/deeplyNestedAssignabilityErrorsCombined.symbols
@@ -0,0 +1,63 @@
+=== tests/cases/compiler/deeplyNestedAssignabilityErrorsCombined.ts ===
+let x = { a: { b: { c: { d: { e: { f() { return { g: "hello" }; } } } } } } };
+>x : Symbol(x, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 0, 3))
+>a : Symbol(a, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 0, 9))
+>b : Symbol(b, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 0, 14))
+>c : Symbol(c, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 0, 19))
+>d : Symbol(d, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 0, 24))
+>e : Symbol(e, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 0, 29))
+>f : Symbol(f, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 0, 34))
+>g : Symbol(g, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 0, 49))
+
+let y = { a: { b: { c: { d: { e: { f() { return { g: 12345 }; } } } } } } };
+>y : Symbol(y, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 1, 3))
+>a : Symbol(a, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 1, 9))
+>b : Symbol(b, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 1, 14))
+>c : Symbol(c, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 1, 19))
+>d : Symbol(d, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 1, 24))
+>e : Symbol(e, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 1, 29))
+>f : Symbol(f, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 1, 34))
+>g : Symbol(g, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 1, 49))
+
+x = y;
+>x : Symbol(x, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 0, 3))
+>y : Symbol(y, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 1, 3))
+
+class Ctor1 {
+>Ctor1 : Symbol(Ctor1, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 2, 6))
+
+    g = "ok"
+>g : Symbol(Ctor1.g, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 4, 13))
+}
+
+class Ctor2 {
+>Ctor2 : Symbol(Ctor2, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 6, 1))
+
+    g = 12;
+>g : Symbol(Ctor2.g, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 8, 13))
+}
+
+let x2 = { a: { b: { c: { d: { e: { f: Ctor1 } } } } } };
+>x2 : Symbol(x2, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 12, 3))
+>a : Symbol(a, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 12, 10))
+>b : Symbol(b, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 12, 15))
+>c : Symbol(c, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 12, 20))
+>d : Symbol(d, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 12, 25))
+>e : Symbol(e, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 12, 30))
+>f : Symbol(f, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 12, 35))
+>Ctor1 : Symbol(Ctor1, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 2, 6))
+
+let y2 = { a: { b: { c: { d: { e: { f: Ctor2 } } } } } };
+>y2 : Symbol(y2, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 13, 3))
+>a : Symbol(a, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 13, 10))
+>b : Symbol(b, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 13, 15))
+>c : Symbol(c, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 13, 20))
+>d : Symbol(d, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 13, 25))
+>e : Symbol(e, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 13, 30))
+>f : Symbol(f, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 13, 35))
+>Ctor2 : Symbol(Ctor2, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 6, 1))
+
+x2 = y2;
+>x2 : Symbol(x2, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 12, 3))
+>y2 : Symbol(y2, Decl(deeplyNestedAssignabilityErrorsCombined.ts, 13, 3))
+
diff --git a/tests/baselines/reference/deeplyNestedAssignabilityErrorsCombined.types b/tests/baselines/reference/deeplyNestedAssignabilityErrorsCombined.types
new file mode 100644
index 00000000000..565de61ef08
--- /dev/null
+++ b/tests/baselines/reference/deeplyNestedAssignabilityErrorsCombined.types
@@ -0,0 +1,95 @@
+=== tests/cases/compiler/deeplyNestedAssignabilityErrorsCombined.ts ===
+let x = { a: { b: { c: { d: { e: { f() { return { g: "hello" }; } } } } } } };
+>x : { a: { b: { c: { d: { e: { f(): { g: string; }; }; }; }; }; }; }
+>{ a: { b: { c: { d: { e: { f() { return { g: "hello" }; } } } } } } } : { a: { b: { c: { d: { e: { f(): { g: string; }; }; }; }; }; }; }
+>a : { b: { c: { d: { e: { f(): { g: string; }; }; }; }; }; }
+>{ b: { c: { d: { e: { f() { return { g: "hello" }; } } } } } } : { b: { c: { d: { e: { f(): { g: string; }; }; }; }; }; }
+>b : { c: { d: { e: { f(): { g: string; }; }; }; }; }
+>{ c: { d: { e: { f() { return { g: "hello" }; } } } } } : { c: { d: { e: { f(): { g: string; }; }; }; }; }
+>c : { d: { e: { f(): { g: string; }; }; }; }
+>{ d: { e: { f() { return { g: "hello" }; } } } } : { d: { e: { f(): { g: string; }; }; }; }
+>d : { e: { f(): { g: string; }; }; }
+>{ e: { f() { return { g: "hello" }; } } } : { e: { f(): { g: string; }; }; }
+>e : { f(): { g: string; }; }
+>{ f() { return { g: "hello" }; } } : { f(): { g: string; }; }
+>f : () => { g: string; }
+>{ g: "hello" } : { g: string; }
+>g : string
+>"hello" : "hello"
+
+let y = { a: { b: { c: { d: { e: { f() { return { g: 12345 }; } } } } } } };
+>y : { a: { b: { c: { d: { e: { f(): { g: number; }; }; }; }; }; }; }
+>{ a: { b: { c: { d: { e: { f() { return { g: 12345 }; } } } } } } } : { a: { b: { c: { d: { e: { f(): { g: number; }; }; }; }; }; }; }
+>a : { b: { c: { d: { e: { f(): { g: number; }; }; }; }; }; }
+>{ b: { c: { d: { e: { f() { return { g: 12345 }; } } } } } } : { b: { c: { d: { e: { f(): { g: number; }; }; }; }; }; }
+>b : { c: { d: { e: { f(): { g: number; }; }; }; }; }
+>{ c: { d: { e: { f() { return { g: 12345 }; } } } } } : { c: { d: { e: { f(): { g: number; }; }; }; }; }
+>c : { d: { e: { f(): { g: number; }; }; }; }
+>{ d: { e: { f() { return { g: 12345 }; } } } } : { d: { e: { f(): { g: number; }; }; }; }
+>d : { e: { f(): { g: number; }; }; }
+>{ e: { f() { return { g: 12345 }; } } } : { e: { f(): { g: number; }; }; }
+>e : { f(): { g: number; }; }
+>{ f() { return { g: 12345 }; } } : { f(): { g: number; }; }
+>f : () => { g: number; }
+>{ g: 12345 } : { g: number; }
+>g : number
+>12345 : 12345
+
+x = y;
+>x = y : { a: { b: { c: { d: { e: { f(): { g: number; }; }; }; }; }; }; }
+>x : { a: { b: { c: { d: { e: { f(): { g: string; }; }; }; }; }; }; }
+>y : { a: { b: { c: { d: { e: { f(): { g: number; }; }; }; }; }; }; }
+
+class Ctor1 {
+>Ctor1 : Ctor1
+
+    g = "ok"
+>g : string
+>"ok" : "ok"
+}
+
+class Ctor2 {
+>Ctor2 : Ctor2
+
+    g = 12;
+>g : number
+>12 : 12
+}
+
+let x2 = { a: { b: { c: { d: { e: { f: Ctor1 } } } } } };
+>x2 : { a: { b: { c: { d: { e: { f: typeof Ctor1; }; }; }; }; }; }
+>{ a: { b: { c: { d: { e: { f: Ctor1 } } } } } } : { a: { b: { c: { d: { e: { f: typeof Ctor1; }; }; }; }; }; }
+>a : { b: { c: { d: { e: { f: typeof Ctor1; }; }; }; }; }
+>{ b: { c: { d: { e: { f: Ctor1 } } } } } : { b: { c: { d: { e: { f: typeof Ctor1; }; }; }; }; }
+>b : { c: { d: { e: { f: typeof Ctor1; }; }; }; }
+>{ c: { d: { e: { f: Ctor1 } } } } : { c: { d: { e: { f: typeof Ctor1; }; }; }; }
+>c : { d: { e: { f: typeof Ctor1; }; }; }
+>{ d: { e: { f: Ctor1 } } } : { d: { e: { f: typeof Ctor1; }; }; }
+>d : { e: { f: typeof Ctor1; }; }
+>{ e: { f: Ctor1 } } : { e: { f: typeof Ctor1; }; }
+>e : { f: typeof Ctor1; }
+>{ f: Ctor1 } : { f: typeof Ctor1; }
+>f : typeof Ctor1
+>Ctor1 : typeof Ctor1
+
+let y2 = { a: { b: { c: { d: { e: { f: Ctor2 } } } } } };
+>y2 : { a: { b: { c: { d: { e: { f: typeof Ctor2; }; }; }; }; }; }
+>{ a: { b: { c: { d: { e: { f: Ctor2 } } } } } } : { a: { b: { c: { d: { e: { f: typeof Ctor2; }; }; }; }; }; }
+>a : { b: { c: { d: { e: { f: typeof Ctor2; }; }; }; }; }
+>{ b: { c: { d: { e: { f: Ctor2 } } } } } : { b: { c: { d: { e: { f: typeof Ctor2; }; }; }; }; }
+>b : { c: { d: { e: { f: typeof Ctor2; }; }; }; }
+>{ c: { d: { e: { f: Ctor2 } } } } : { c: { d: { e: { f: typeof Ctor2; }; }; }; }
+>c : { d: { e: { f: typeof Ctor2; }; }; }
+>{ d: { e: { f: Ctor2 } } } : { d: { e: { f: typeof Ctor2; }; }; }
+>d : { e: { f: typeof Ctor2; }; }
+>{ e: { f: Ctor2 } } : { e: { f: typeof Ctor2; }; }
+>e : { f: typeof Ctor2; }
+>{ f: Ctor2 } : { f: typeof Ctor2; }
+>f : typeof Ctor2
+>Ctor2 : typeof Ctor2
+
+x2 = y2;
+>x2 = y2 : { a: { b: { c: { d: { e: { f: typeof Ctor2; }; }; }; }; }; }
+>x2 : { a: { b: { c: { d: { e: { f: typeof Ctor1; }; }; }; }; }; }
+>y2 : { a: { b: { c: { d: { e: { f: typeof Ctor2; }; }; }; }; }; }
+
diff --git a/tests/baselines/reference/docker/office-ui-fabric.log b/tests/baselines/reference/docker/office-ui-fabric.log
index 7bd402b8327..e75c479de90 100644
--- a/tests/baselines/reference/docker/office-ui-fabric.log
+++ b/tests/baselines/reference/docker/office-ui-fabric.log
@@ -1,14 +1,5 @@
 Exit Code: 1
 Standard output:
-@uifabric/codepen-loader: yarn run vX.X.X
-@uifabric/codepen-loader: $ just-scripts build --production --lint
-@uifabric/codepen-loader: [XX:XX:XX XM] ■ Removing [lib, temp, dist, coverage, lib-commonjs]
-@uifabric/codepen-loader: [XX:XX:XX XM] ■ Running /office-ui-fabric-react/node_modules/typescript/lib/tsc.js with /office-ui-fabric-react/packages/codepen-loader/tsconfig.json
-@uifabric/codepen-loader: [XX:XX:XX XM] ■ Executing: /usr/local/bin/node "/office-ui-fabric-react/node_modules/typescript/lib/tsc.js" --module commonjs --outDir "./lib" --project "/office-ui-fabric-react/packages/codepen-loader/tsconfig.json"
-@uifabric/codepen-loader: [XX:XX:XX XM] ■ Running Jest
-@uifabric/codepen-loader: [XX:XX:XX XM] ■ /usr/local/bin/node "/office-ui-fabric-react/node_modules/jest/bin/jest.js" --config "/office-ui-fabric-react/packages/codepen-loader/jest.config.js" --passWithNoTests --colors --forceExit
-@uifabric/codepen-loader:  PASS  src/__tests__/codepenTransform.test.ts
-@uifabric/codepen-loader: Done in ?s.
 @uifabric/build: yarn run vX.X.X
 @uifabric/build: $ node ./just-scripts.js no-op --production --lint
 @uifabric/build: Done in ?s.
@@ -36,9 +27,11 @@ Standard output:
 @uifabric/migration: Done in ?s.
 @uifabric/monaco-editor: yarn run vX.X.X
 @uifabric/monaco-editor: $ just-scripts build --production --lint
-@uifabric/monaco-editor: [XX:XX:XX XM] ■ Removing [esm, lib]
+@uifabric/monaco-editor: [XX:XX:XX XM] ■ Removing [esm, lib, lib-commonjs]
 @uifabric/monaco-editor: [XX:XX:XX XM] ■ Running /office-ui-fabric-react/node_modules/typescript/lib/tsc.js with /office-ui-fabric-react/packages/monaco-editor/tsconfig.json
 @uifabric/monaco-editor: [XX:XX:XX XM] ■ Executing: /usr/local/bin/node "/office-ui-fabric-react/node_modules/typescript/lib/tsc.js" --pretty --target es5 --inlineSources --sourceRoot "../src" --outDir lib --module esnext --project "/office-ui-fabric-react/packages/monaco-editor/tsconfig.json"
+@uifabric/monaco-editor: [XX:XX:XX XM] ■ Running /office-ui-fabric-react/node_modules/typescript/lib/tsc.js with /office-ui-fabric-react/packages/monaco-editor/tsconfig.json
+@uifabric/monaco-editor: [XX:XX:XX XM] ■ Executing: /usr/local/bin/node "/office-ui-fabric-react/node_modules/typescript/lib/tsc.js" --pretty --target es5 --inlineSources --sourceRoot "../src" --outDir lib-commonjs --module commonjs --project "/office-ui-fabric-react/packages/monaco-editor/tsconfig.json"
 @uifabric/monaco-editor: Done in ?s.
 @uifabric/set-version: yarn run vX.X.X
 @uifabric/set-version: $ just-scripts build --production --lint
@@ -91,6 +84,7 @@ Standard output:
 @uifabric/merge-styles:  PASS  src/extractStyleParts.test.ts
 @uifabric/merge-styles:  PASS  src/server.test.ts
 @uifabric/merge-styles:  PASS  src/concatStyleSetsWithProps.test.ts
+@uifabric/merge-styles:  PASS  src/fontFace.test.ts
 @uifabric/merge-styles: [XX:XX:XX XM] ■ Extracting Public API surface from '/office-ui-fabric-react/packages/merge-styles/lib/index.d.ts'
 @uifabric/merge-styles: Done in ?s.
 @uifabric/jest-serializer-merge-styles: yarn run vX.X.X
@@ -134,9 +128,9 @@ Standard output:
 @uifabric/utilities:  PASS  src/warn/warnControlledUsage.test.ts
 @uifabric/utilities:  PASS  src/focus.test.tsx
 @uifabric/utilities:  PASS  src/styled.test.tsx
+@uifabric/utilities:  PASS  src/customizations/Customizer.test.tsx
 @uifabric/utilities:  PASS  src/EventGroup.test.ts
 @uifabric/utilities:  PASS  src/array.test.ts
-@uifabric/utilities:  PASS  src/customizations/Customizer.test.tsx
 @uifabric/utilities:  PASS  src/math.test.ts
 @uifabric/utilities:  PASS  src/warn/warn.test.ts
 @uifabric/utilities:  PASS  src/dom/dom.test.ts
@@ -206,7 +200,6 @@ Standard output:
 @uifabric/styling:  PASS  src/styles/theme.test.ts
 @uifabric/styling:  PASS  src/styles/scheme.test.ts
 @uifabric/styling:  PASS  src/styles/getGlobalClassNames.test.ts
-@uifabric/styling:  PASS  src/utilities/icons.test.ts
 @uifabric/styling: [XX:XX:XX XM] ■ Extracting Public API surface from '/office-ui-fabric-react/packages/styling/lib/index.d.ts'
 @uifabric/styling: Done in ?s.
 @uifabric/file-type-icons: yarn run vX.X.X
@@ -249,11 +242,7 @@ Standard output:
 Standard error:
 info cli using local version of lerna
 lerna notice cli vX.X.X
-lerna info Executing command in 43 packages: "yarn run build --production --lint"
-@uifabric/codepen-loader: ts-jest[versions] (WARN) Version X.X.X-insiders.xxxxxxxx of typescript installed has not been tested with ts-jest. If you're experiencing issues, consider using a supported version (>=2.7.0 <4.0.0). Please do not report issues in ts-jest if you are using unsupported versions.
-@uifabric/codepen-loader: Force exiting Jest
-@uifabric/codepen-loader: 
-@uifabric/codepen-loader: Have you considered using `--detectOpenHandles` to detect async operations that kept running after all tests finished?
+lerna info Executing command in 42 packages: "yarn run build --production --lint"
 @uifabric/example-data: [XX:XX:XX XM] ▲ One of these [node-sass, postcss, autoprefixer] is not installed, so this task has no effect
 @uifabric/set-version: [XX:XX:XX XM] ▲ One of these [node-sass, postcss, autoprefixer] is not installed, so this task has no effect
 @uifabric/merge-styles: [XX:XX:XX XM] ▲ One of these [node-sass, postcss, autoprefixer] is not installed, so this task has no effect
diff --git a/tests/baselines/reference/elaboratedErrorsOnNullableTargets01.errors.txt b/tests/baselines/reference/elaboratedErrorsOnNullableTargets01.errors.txt
index dc7e3f10bd1..b84fb863ad8 100644
--- a/tests/baselines/reference/elaboratedErrorsOnNullableTargets01.errors.txt
+++ b/tests/baselines/reference/elaboratedErrorsOnNullableTargets01.errors.txt
@@ -1,9 +1,7 @@
 tests/cases/compiler/elaboratedErrorsOnNullableTargets01.ts(4,1): error TS2322: Type '{ foo: { bar: number | undefined; }; }' is not assignable to type '{ foo: { bar: string | null; } | undefined; }'.
-  Types of property 'foo' are incompatible.
-    Type '{ bar: number | undefined; }' is not assignable to type '{ bar: string | null; }'.
-      Types of property 'bar' are incompatible.
-        Type 'number | undefined' is not assignable to type 'string | null'.
-          Type 'undefined' is not assignable to type 'string | null'.
+  The types of 'foo.bar' are incompatible between these types.
+    Type 'number | undefined' is not assignable to type 'string | null'.
+      Type 'undefined' is not assignable to type 'string | null'.
 tests/cases/compiler/elaboratedErrorsOnNullableTargets01.ts(6,1): error TS2322: Type '{ foo: { bar: string | null; } | undefined; } | null | undefined' is not assignable to type '{ foo: { bar: number | undefined; }; }'.
   Type 'undefined' is not assignable to type '{ foo: { bar: number | undefined; }; }'.
 
@@ -15,11 +13,9 @@ tests/cases/compiler/elaboratedErrorsOnNullableTargets01.ts(6,1): error TS2322:
     x = y;
     ~
 !!! error TS2322: Type '{ foo: { bar: number | undefined; }; }' is not assignable to type '{ foo: { bar: string | null; } | undefined; }'.
-!!! error TS2322:   Types of property 'foo' are incompatible.
-!!! error TS2322:     Type '{ bar: number | undefined; }' is not assignable to type '{ bar: string | null; }'.
-!!! error TS2322:       Types of property 'bar' are incompatible.
-!!! error TS2322:         Type 'number | undefined' is not assignable to type 'string | null'.
-!!! error TS2322:           Type 'undefined' is not assignable to type 'string | null'.
+!!! error TS2322:   The types of 'foo.bar' are incompatible between these types.
+!!! error TS2322:     Type 'number | undefined' is not assignable to type 'string | null'.
+!!! error TS2322:       Type 'undefined' is not assignable to type 'string | null'.
     
     y = x;
     ~
diff --git a/tests/baselines/reference/everyTypeWithAnnotationAndInvalidInitializer.errors.txt b/tests/baselines/reference/everyTypeWithAnnotationAndInvalidInitializer.errors.txt
index 31848458a87..f552bb35ca4 100644
--- a/tests/baselines/reference/everyTypeWithAnnotationAndInvalidInitializer.errors.txt
+++ b/tests/baselines/reference/everyTypeWithAnnotationAndInvalidInitializer.errors.txt
@@ -17,9 +17,8 @@ tests/cases/conformance/statements/VariableStatements/everyTypeWithAnnotationAnd
     Type 'string' is not assignable to type 'number'.
 tests/cases/conformance/statements/VariableStatements/everyTypeWithAnnotationAndInvalidInitializer.ts(48,32): error TS2322: Type 'string' is not assignable to type 'number'.
 tests/cases/conformance/statements/VariableStatements/everyTypeWithAnnotationAndInvalidInitializer.ts(50,5): error TS2322: Type 'typeof N' is not assignable to type 'typeof M'.
-  Types of property 'A' are incompatible.
-    Type 'typeof N.A' is not assignable to type 'typeof M.A'.
-      Property 'name' is missing in type 'N.A' but required in type 'M.A'.
+  The types returned by 'new A()' are incompatible between these types.
+    Property 'name' is missing in type 'N.A' but required in type 'M.A'.
 tests/cases/conformance/statements/VariableStatements/everyTypeWithAnnotationAndInvalidInitializer.ts(51,5): error TS2322: Type 'N.A' is not assignable to type 'M.A'.
 tests/cases/conformance/statements/VariableStatements/everyTypeWithAnnotationAndInvalidInitializer.ts(52,5): error TS2322: Type '(x: number) => boolean' is not assignable to type '(x: number) => string'.
   Type 'boolean' is not assignable to type 'string'.
@@ -112,9 +111,8 @@ tests/cases/conformance/statements/VariableStatements/everyTypeWithAnnotationAnd
     var aModule: typeof M = N;
         ~~~~~~~
 !!! error TS2322: Type 'typeof N' is not assignable to type 'typeof M'.
-!!! error TS2322:   Types of property 'A' are incompatible.
-!!! error TS2322:     Type 'typeof N.A' is not assignable to type 'typeof M.A'.
-!!! error TS2322:       Property 'name' is missing in type 'N.A' but required in type 'M.A'.
+!!! error TS2322:   The types returned by 'new A()' are incompatible between these types.
+!!! error TS2322:     Property 'name' is missing in type 'N.A' but required in type 'M.A'.
 !!! related TS2728 tests/cases/conformance/statements/VariableStatements/everyTypeWithAnnotationAndInvalidInitializer.ts:20:9: 'name' is declared here.
     var aClassInModule: M.A = new N.A();
         ~~~~~~~~~~~~~~
diff --git a/tests/baselines/reference/exhaustiveSwitchImplicitReturn.errors.txt b/tests/baselines/reference/exhaustiveSwitchImplicitReturn.errors.txt
index 43b5467f0d2..89daa42c268 100644
--- a/tests/baselines/reference/exhaustiveSwitchImplicitReturn.errors.txt
+++ b/tests/baselines/reference/exhaustiveSwitchImplicitReturn.errors.txt
@@ -44,4 +44,18 @@ tests/cases/compiler/exhaustiveSwitchImplicitReturn.ts(35,32): error TS7030: Not
                 return 1;
         }
     }
+    
+    function foo6(bar: "a", a: boolean, b: boolean): number {
+        if (a) {
+            switch (bar) {
+                case "a": return 1;
+            }
+        }
+        else {
+            switch (b) {
+                case true: return -1;
+                case false: return 0;
+            }
+        }
+    }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/exhaustiveSwitchImplicitReturn.js b/tests/baselines/reference/exhaustiveSwitchImplicitReturn.js
index 5f8bf348c5f..9877f251993 100644
--- a/tests/baselines/reference/exhaustiveSwitchImplicitReturn.js
+++ b/tests/baselines/reference/exhaustiveSwitchImplicitReturn.js
@@ -39,6 +39,20 @@ function foo5(bar: "a" | "b"): number {
             return 1;
     }
 }
+
+function foo6(bar: "a", a: boolean, b: boolean): number {
+    if (a) {
+        switch (bar) {
+            case "a": return 1;
+        }
+    }
+    else {
+        switch (b) {
+            case true: return -1;
+            case false: return 0;
+        }
+    }
+}
 
 
 //// [exhaustiveSwitchImplicitReturn.js]
@@ -75,3 +89,16 @@ function foo5(bar) {
             return 1;
     }
 }
+function foo6(bar, a, b) {
+    if (a) {
+        switch (bar) {
+            case "a": return 1;
+        }
+    }
+    else {
+        switch (b) {
+            case true: return -1;
+            case false: return 0;
+        }
+    }
+}
diff --git a/tests/baselines/reference/exhaustiveSwitchImplicitReturn.symbols b/tests/baselines/reference/exhaustiveSwitchImplicitReturn.symbols
index d93a5228362..dcad190a9b3 100644
--- a/tests/baselines/reference/exhaustiveSwitchImplicitReturn.symbols
+++ b/tests/baselines/reference/exhaustiveSwitchImplicitReturn.symbols
@@ -69,3 +69,28 @@ function foo5(bar: "a" | "b"): number {
     }
 }
 
+function foo6(bar: "a", a: boolean, b: boolean): number {
+>foo6 : Symbol(foo6, Decl(exhaustiveSwitchImplicitReturn.ts, 39, 1))
+>bar : Symbol(bar, Decl(exhaustiveSwitchImplicitReturn.ts, 41, 14))
+>a : Symbol(a, Decl(exhaustiveSwitchImplicitReturn.ts, 41, 23))
+>b : Symbol(b, Decl(exhaustiveSwitchImplicitReturn.ts, 41, 35))
+
+    if (a) {
+>a : Symbol(a, Decl(exhaustiveSwitchImplicitReturn.ts, 41, 23))
+
+        switch (bar) {
+>bar : Symbol(bar, Decl(exhaustiveSwitchImplicitReturn.ts, 41, 14))
+
+            case "a": return 1;
+        }
+    }
+    else {
+        switch (b) {
+>b : Symbol(b, Decl(exhaustiveSwitchImplicitReturn.ts, 41, 35))
+
+            case true: return -1;
+            case false: return 0;
+        }
+    }
+}
+
diff --git a/tests/baselines/reference/exhaustiveSwitchImplicitReturn.types b/tests/baselines/reference/exhaustiveSwitchImplicitReturn.types
index c868aa99b8f..c72b3b24477 100644
--- a/tests/baselines/reference/exhaustiveSwitchImplicitReturn.types
+++ b/tests/baselines/reference/exhaustiveSwitchImplicitReturn.types
@@ -85,3 +85,36 @@ function foo5(bar: "a" | "b"): number {
     }
 }
 
+function foo6(bar: "a", a: boolean, b: boolean): number {
+>foo6 : (bar: "a", a: boolean, b: boolean) => number
+>bar : "a"
+>a : boolean
+>b : boolean
+
+    if (a) {
+>a : boolean
+
+        switch (bar) {
+>bar : "a"
+
+            case "a": return 1;
+>"a" : "a"
+>1 : 1
+        }
+    }
+    else {
+        switch (b) {
+>b : boolean
+
+            case true: return -1;
+>true : true
+>-1 : -1
+>1 : 1
+
+            case false: return 0;
+>false : false
+>0 : 0
+        }
+    }
+}
+
diff --git a/tests/baselines/reference/exhaustiveSwitchStatements1.errors.txt b/tests/baselines/reference/exhaustiveSwitchStatements1.errors.txt
new file mode 100644
index 00000000000..4a54518413d
--- /dev/null
+++ b/tests/baselines/reference/exhaustiveSwitchStatements1.errors.txt
@@ -0,0 +1,202 @@
+tests/cases/conformance/controlFlow/exhaustiveSwitchStatements1.ts(7,9): error TS7027: Unreachable code detected.
+
+
+==== tests/cases/conformance/controlFlow/exhaustiveSwitchStatements1.ts (1 errors) ====
+    function f1(x: 1 | 2): string {
+        if (!!true) {
+            switch (x) {
+                case 1: return 'a';
+                case 2: return 'b';
+            }
+            x;  // Unreachable
+            ~~
+!!! error TS7027: Unreachable code detected.
+        }
+        else {
+            throw 0;
+        }
+    }
+    
+    function f2(x: 1 | 2) {
+        let z: number;
+        switch (x) {
+            case 1: z = 10; break;
+            case 2: z = 20; break;
+        }
+        z;  // Definitely assigned
+    }
+    
+    function f3(x: 1 | 2) {
+        switch (x) {
+            case 1: return 10;
+            case 2: return 20;
+            // Default considered reachable to allow defensive coding
+            default: throw new Error("Bad input");
+        }
+    }
+    
+    // Repro from #11572
+    
+    enum E { A, B }
+    
+    function f(e: E): number {
+        switch (e) {
+            case E.A: return 0
+            case E.B: return 1
+        }
+    }
+    
+    function g(e: E): number {
+        if (!true)
+            return -1
+        else
+            switch (e) {
+                case E.A: return 0
+                case E.B: return 1
+            }
+    }
+    
+    // Repro from #12668
+    
+    interface Square { kind: "square"; size: number; }
+    
+    interface Rectangle { kind: "rectangle"; width: number; height: number; }
+    
+    interface Circle { kind: "circle"; radius: number; }
+    
+    interface Triangle { kind: "triangle"; side: number; }
+    
+    type Shape = Square | Rectangle | Circle | Triangle;
+    
+    function area(s: Shape): number {
+        let area;
+        switch (s.kind) {
+            case "square": area = s.size * s.size; break;
+            case "rectangle": area = s.width * s.height; break;
+            case "circle": area = Math.PI * s.radius * s.radius; break;
+            case "triangle": area = Math.sqrt(3) / 4 * s.side * s.side; break;
+        }
+        return area;
+    }
+    
+    function areaWrapped(s: Shape): number {
+        let area;
+        area = (() => {
+            switch (s.kind) {
+                case "square": return s.size * s.size;
+                case "rectangle": return s.width * s.height;
+                case "circle": return Math.PI * s.radius * s.radius;
+                case "triangle": return Math.sqrt(3) / 4 * s.side * s.side;
+            }
+        })();
+        return area;
+    }
+    
+    // Repro from #13241
+    
+    enum MyEnum {
+    	A,
+    	B
+    }
+    
+    function thisGivesError(e: MyEnum): string {
+    	let s: string;
+    	switch (e) {
+    		case MyEnum.A: s = "it was A"; break;
+    		case MyEnum.B: s = "it was B"; break;
+    	}
+    	return s;
+    }
+    
+    function good1(e: MyEnum): string {
+    	let s: string;
+    	switch (e) {
+    		case MyEnum.A: s = "it was A"; break;
+    		case MyEnum.B: s = "it was B"; break;
+    		default: s = "it was something else"; break;
+    	}
+    	return s;
+    }
+    
+    function good2(e: MyEnum): string {
+    	switch (e) {
+    		case MyEnum.A: return "it was A";
+    		case MyEnum.B: return "it was B";
+    	}
+    }
+    
+    // Repro from #18362
+    
+    enum Level {
+      One,
+      Two,
+    }
+    
+    const doSomethingWithLevel = (level: Level) => {
+      let next: Level;
+      switch (level) {
+        case Level.One:
+          next = Level.Two;
+          break;
+        case Level.Two:
+          next = Level.One;
+          break;
+      }
+      return next;
+    };
+    
+    // Repro from #20409
+    
+    interface Square2 {
+        kind: "square";
+        size: number;
+    }
+    
+    interface Circle2 {
+        kind: "circle";
+        radius: number;
+    }
+    
+    type Shape2 = Square2 | Circle2;
+    
+    function withDefault(s1: Shape2, s2: Shape2): string {
+        switch (s1.kind) {
+            case "square":
+                return "1";
+            case "circle":
+                switch (s2.kind) {
+                    case "square":
+                        return "2";
+                    case "circle":
+                        return "3";
+                    default:
+                        return "never";
+                }
+        }
+    }
+    
+    function withoutDefault(s1: Shape2, s2: Shape2): string {
+        switch (s1.kind) {
+            case "square":
+                return "1";
+            case "circle":
+                switch (s2.kind) {
+                    case "square":
+                        return "2";
+                    case "circle":
+                        return "3";
+                }
+        }
+    }
+    
+    // Repro from #20823
+    
+    function test4(value: 1 | 2) {
+        let x: string;
+        switch (value) {
+            case 1: x = "one"; break;
+            case 2: x = "two"; break;
+        }
+        return x;
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/exhaustiveSwitchStatements1.js b/tests/baselines/reference/exhaustiveSwitchStatements1.js
new file mode 100644
index 00000000000..a39db3b8101
--- /dev/null
+++ b/tests/baselines/reference/exhaustiveSwitchStatements1.js
@@ -0,0 +1,437 @@
+//// [exhaustiveSwitchStatements1.ts]
+function f1(x: 1 | 2): string {
+    if (!!true) {
+        switch (x) {
+            case 1: return 'a';
+            case 2: return 'b';
+        }
+        x;  // Unreachable
+    }
+    else {
+        throw 0;
+    }
+}
+
+function f2(x: 1 | 2) {
+    let z: number;
+    switch (x) {
+        case 1: z = 10; break;
+        case 2: z = 20; break;
+    }
+    z;  // Definitely assigned
+}
+
+function f3(x: 1 | 2) {
+    switch (x) {
+        case 1: return 10;
+        case 2: return 20;
+        // Default considered reachable to allow defensive coding
+        default: throw new Error("Bad input");
+    }
+}
+
+// Repro from #11572
+
+enum E { A, B }
+
+function f(e: E): number {
+    switch (e) {
+        case E.A: return 0
+        case E.B: return 1
+    }
+}
+
+function g(e: E): number {
+    if (!true)
+        return -1
+    else
+        switch (e) {
+            case E.A: return 0
+            case E.B: return 1
+        }
+}
+
+// Repro from #12668
+
+interface Square { kind: "square"; size: number; }
+
+interface Rectangle { kind: "rectangle"; width: number; height: number; }
+
+interface Circle { kind: "circle"; radius: number; }
+
+interface Triangle { kind: "triangle"; side: number; }
+
+type Shape = Square | Rectangle | Circle | Triangle;
+
+function area(s: Shape): number {
+    let area;
+    switch (s.kind) {
+        case "square": area = s.size * s.size; break;
+        case "rectangle": area = s.width * s.height; break;
+        case "circle": area = Math.PI * s.radius * s.radius; break;
+        case "triangle": area = Math.sqrt(3) / 4 * s.side * s.side; break;
+    }
+    return area;
+}
+
+function areaWrapped(s: Shape): number {
+    let area;
+    area = (() => {
+        switch (s.kind) {
+            case "square": return s.size * s.size;
+            case "rectangle": return s.width * s.height;
+            case "circle": return Math.PI * s.radius * s.radius;
+            case "triangle": return Math.sqrt(3) / 4 * s.side * s.side;
+        }
+    })();
+    return area;
+}
+
+// Repro from #13241
+
+enum MyEnum {
+	A,
+	B
+}
+
+function thisGivesError(e: MyEnum): string {
+	let s: string;
+	switch (e) {
+		case MyEnum.A: s = "it was A"; break;
+		case MyEnum.B: s = "it was B"; break;
+	}
+	return s;
+}
+
+function good1(e: MyEnum): string {
+	let s: string;
+	switch (e) {
+		case MyEnum.A: s = "it was A"; break;
+		case MyEnum.B: s = "it was B"; break;
+		default: s = "it was something else"; break;
+	}
+	return s;
+}
+
+function good2(e: MyEnum): string {
+	switch (e) {
+		case MyEnum.A: return "it was A";
+		case MyEnum.B: return "it was B";
+	}
+}
+
+// Repro from #18362
+
+enum Level {
+  One,
+  Two,
+}
+
+const doSomethingWithLevel = (level: Level) => {
+  let next: Level;
+  switch (level) {
+    case Level.One:
+      next = Level.Two;
+      break;
+    case Level.Two:
+      next = Level.One;
+      break;
+  }
+  return next;
+};
+
+// Repro from #20409
+
+interface Square2 {
+    kind: "square";
+    size: number;
+}
+
+interface Circle2 {
+    kind: "circle";
+    radius: number;
+}
+
+type Shape2 = Square2 | Circle2;
+
+function withDefault(s1: Shape2, s2: Shape2): string {
+    switch (s1.kind) {
+        case "square":
+            return "1";
+        case "circle":
+            switch (s2.kind) {
+                case "square":
+                    return "2";
+                case "circle":
+                    return "3";
+                default:
+                    return "never";
+            }
+    }
+}
+
+function withoutDefault(s1: Shape2, s2: Shape2): string {
+    switch (s1.kind) {
+        case "square":
+            return "1";
+        case "circle":
+            switch (s2.kind) {
+                case "square":
+                    return "2";
+                case "circle":
+                    return "3";
+            }
+    }
+}
+
+// Repro from #20823
+
+function test4(value: 1 | 2) {
+    let x: string;
+    switch (value) {
+        case 1: x = "one"; break;
+        case 2: x = "two"; break;
+    }
+    return x;
+}
+
+
+//// [exhaustiveSwitchStatements1.js]
+"use strict";
+function f1(x) {
+    if (!!true) {
+        switch (x) {
+            case 1: return 'a';
+            case 2: return 'b';
+        }
+        x; // Unreachable
+    }
+    else {
+        throw 0;
+    }
+}
+function f2(x) {
+    var z;
+    switch (x) {
+        case 1:
+            z = 10;
+            break;
+        case 2:
+            z = 20;
+            break;
+    }
+    z; // Definitely assigned
+}
+function f3(x) {
+    switch (x) {
+        case 1: return 10;
+        case 2: return 20;
+        // Default considered reachable to allow defensive coding
+        default: throw new Error("Bad input");
+    }
+}
+// Repro from #11572
+var E;
+(function (E) {
+    E[E["A"] = 0] = "A";
+    E[E["B"] = 1] = "B";
+})(E || (E = {}));
+function f(e) {
+    switch (e) {
+        case E.A: return 0;
+        case E.B: return 1;
+    }
+}
+function g(e) {
+    if (!true)
+        return -1;
+    else
+        switch (e) {
+            case E.A: return 0;
+            case E.B: return 1;
+        }
+}
+function area(s) {
+    var area;
+    switch (s.kind) {
+        case "square":
+            area = s.size * s.size;
+            break;
+        case "rectangle":
+            area = s.width * s.height;
+            break;
+        case "circle":
+            area = Math.PI * s.radius * s.radius;
+            break;
+        case "triangle":
+            area = Math.sqrt(3) / 4 * s.side * s.side;
+            break;
+    }
+    return area;
+}
+function areaWrapped(s) {
+    var area;
+    area = (function () {
+        switch (s.kind) {
+            case "square": return s.size * s.size;
+            case "rectangle": return s.width * s.height;
+            case "circle": return Math.PI * s.radius * s.radius;
+            case "triangle": return Math.sqrt(3) / 4 * s.side * s.side;
+        }
+    })();
+    return area;
+}
+// Repro from #13241
+var MyEnum;
+(function (MyEnum) {
+    MyEnum[MyEnum["A"] = 0] = "A";
+    MyEnum[MyEnum["B"] = 1] = "B";
+})(MyEnum || (MyEnum = {}));
+function thisGivesError(e) {
+    var s;
+    switch (e) {
+        case MyEnum.A:
+            s = "it was A";
+            break;
+        case MyEnum.B:
+            s = "it was B";
+            break;
+    }
+    return s;
+}
+function good1(e) {
+    var s;
+    switch (e) {
+        case MyEnum.A:
+            s = "it was A";
+            break;
+        case MyEnum.B:
+            s = "it was B";
+            break;
+        default:
+            s = "it was something else";
+            break;
+    }
+    return s;
+}
+function good2(e) {
+    switch (e) {
+        case MyEnum.A: return "it was A";
+        case MyEnum.B: return "it was B";
+    }
+}
+// Repro from #18362
+var Level;
+(function (Level) {
+    Level[Level["One"] = 0] = "One";
+    Level[Level["Two"] = 1] = "Two";
+})(Level || (Level = {}));
+var doSomethingWithLevel = function (level) {
+    var next;
+    switch (level) {
+        case Level.One:
+            next = Level.Two;
+            break;
+        case Level.Two:
+            next = Level.One;
+            break;
+    }
+    return next;
+};
+function withDefault(s1, s2) {
+    switch (s1.kind) {
+        case "square":
+            return "1";
+        case "circle":
+            switch (s2.kind) {
+                case "square":
+                    return "2";
+                case "circle":
+                    return "3";
+                default:
+                    return "never";
+            }
+    }
+}
+function withoutDefault(s1, s2) {
+    switch (s1.kind) {
+        case "square":
+            return "1";
+        case "circle":
+            switch (s2.kind) {
+                case "square":
+                    return "2";
+                case "circle":
+                    return "3";
+            }
+    }
+}
+// Repro from #20823
+function test4(value) {
+    var x;
+    switch (value) {
+        case 1:
+            x = "one";
+            break;
+        case 2:
+            x = "two";
+            break;
+    }
+    return x;
+}
+
+
+//// [exhaustiveSwitchStatements1.d.ts]
+declare function f1(x: 1 | 2): string;
+declare function f2(x: 1 | 2): void;
+declare function f3(x: 1 | 2): 10 | 20;
+declare enum E {
+    A = 0,
+    B = 1
+}
+declare function f(e: E): number;
+declare function g(e: E): number;
+interface Square {
+    kind: "square";
+    size: number;
+}
+interface Rectangle {
+    kind: "rectangle";
+    width: number;
+    height: number;
+}
+interface Circle {
+    kind: "circle";
+    radius: number;
+}
+interface Triangle {
+    kind: "triangle";
+    side: number;
+}
+declare type Shape = Square | Rectangle | Circle | Triangle;
+declare function area(s: Shape): number;
+declare function areaWrapped(s: Shape): number;
+declare enum MyEnum {
+    A = 0,
+    B = 1
+}
+declare function thisGivesError(e: MyEnum): string;
+declare function good1(e: MyEnum): string;
+declare function good2(e: MyEnum): string;
+declare enum Level {
+    One = 0,
+    Two = 1
+}
+declare const doSomethingWithLevel: (level: Level) => Level;
+interface Square2 {
+    kind: "square";
+    size: number;
+}
+interface Circle2 {
+    kind: "circle";
+    radius: number;
+}
+declare type Shape2 = Square2 | Circle2;
+declare function withDefault(s1: Shape2, s2: Shape2): string;
+declare function withoutDefault(s1: Shape2, s2: Shape2): string;
+declare function test4(value: 1 | 2): string;
diff --git a/tests/baselines/reference/exhaustiveSwitchStatements1.symbols b/tests/baselines/reference/exhaustiveSwitchStatements1.symbols
new file mode 100644
index 00000000000..8beb3911883
--- /dev/null
+++ b/tests/baselines/reference/exhaustiveSwitchStatements1.symbols
@@ -0,0 +1,503 @@
+=== tests/cases/conformance/controlFlow/exhaustiveSwitchStatements1.ts ===
+function f1(x: 1 | 2): string {
+>f1 : Symbol(f1, Decl(exhaustiveSwitchStatements1.ts, 0, 0))
+>x : Symbol(x, Decl(exhaustiveSwitchStatements1.ts, 0, 12))
+
+    if (!!true) {
+        switch (x) {
+>x : Symbol(x, Decl(exhaustiveSwitchStatements1.ts, 0, 12))
+
+            case 1: return 'a';
+            case 2: return 'b';
+        }
+        x;  // Unreachable
+>x : Symbol(x, Decl(exhaustiveSwitchStatements1.ts, 0, 12))
+    }
+    else {
+        throw 0;
+    }
+}
+
+function f2(x: 1 | 2) {
+>f2 : Symbol(f2, Decl(exhaustiveSwitchStatements1.ts, 11, 1))
+>x : Symbol(x, Decl(exhaustiveSwitchStatements1.ts, 13, 12))
+
+    let z: number;
+>z : Symbol(z, Decl(exhaustiveSwitchStatements1.ts, 14, 7))
+
+    switch (x) {
+>x : Symbol(x, Decl(exhaustiveSwitchStatements1.ts, 13, 12))
+
+        case 1: z = 10; break;
+>z : Symbol(z, Decl(exhaustiveSwitchStatements1.ts, 14, 7))
+
+        case 2: z = 20; break;
+>z : Symbol(z, Decl(exhaustiveSwitchStatements1.ts, 14, 7))
+    }
+    z;  // Definitely assigned
+>z : Symbol(z, Decl(exhaustiveSwitchStatements1.ts, 14, 7))
+}
+
+function f3(x: 1 | 2) {
+>f3 : Symbol(f3, Decl(exhaustiveSwitchStatements1.ts, 20, 1))
+>x : Symbol(x, Decl(exhaustiveSwitchStatements1.ts, 22, 12))
+
+    switch (x) {
+>x : Symbol(x, Decl(exhaustiveSwitchStatements1.ts, 22, 12))
+
+        case 1: return 10;
+        case 2: return 20;
+        // Default considered reachable to allow defensive coding
+        default: throw new Error("Bad input");
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+    }
+}
+
+// Repro from #11572
+
+enum E { A, B }
+>E : Symbol(E, Decl(exhaustiveSwitchStatements1.ts, 29, 1))
+>A : Symbol(E.A, Decl(exhaustiveSwitchStatements1.ts, 33, 8))
+>B : Symbol(E.B, Decl(exhaustiveSwitchStatements1.ts, 33, 11))
+
+function f(e: E): number {
+>f : Symbol(f, Decl(exhaustiveSwitchStatements1.ts, 33, 15))
+>e : Symbol(e, Decl(exhaustiveSwitchStatements1.ts, 35, 11))
+>E : Symbol(E, Decl(exhaustiveSwitchStatements1.ts, 29, 1))
+
+    switch (e) {
+>e : Symbol(e, Decl(exhaustiveSwitchStatements1.ts, 35, 11))
+
+        case E.A: return 0
+>E.A : Symbol(E.A, Decl(exhaustiveSwitchStatements1.ts, 33, 8))
+>E : Symbol(E, Decl(exhaustiveSwitchStatements1.ts, 29, 1))
+>A : Symbol(E.A, Decl(exhaustiveSwitchStatements1.ts, 33, 8))
+
+        case E.B: return 1
+>E.B : Symbol(E.B, Decl(exhaustiveSwitchStatements1.ts, 33, 11))
+>E : Symbol(E, Decl(exhaustiveSwitchStatements1.ts, 29, 1))
+>B : Symbol(E.B, Decl(exhaustiveSwitchStatements1.ts, 33, 11))
+    }
+}
+
+function g(e: E): number {
+>g : Symbol(g, Decl(exhaustiveSwitchStatements1.ts, 40, 1))
+>e : Symbol(e, Decl(exhaustiveSwitchStatements1.ts, 42, 11))
+>E : Symbol(E, Decl(exhaustiveSwitchStatements1.ts, 29, 1))
+
+    if (!true)
+        return -1
+    else
+        switch (e) {
+>e : Symbol(e, Decl(exhaustiveSwitchStatements1.ts, 42, 11))
+
+            case E.A: return 0
+>E.A : Symbol(E.A, Decl(exhaustiveSwitchStatements1.ts, 33, 8))
+>E : Symbol(E, Decl(exhaustiveSwitchStatements1.ts, 29, 1))
+>A : Symbol(E.A, Decl(exhaustiveSwitchStatements1.ts, 33, 8))
+
+            case E.B: return 1
+>E.B : Symbol(E.B, Decl(exhaustiveSwitchStatements1.ts, 33, 11))
+>E : Symbol(E, Decl(exhaustiveSwitchStatements1.ts, 29, 1))
+>B : Symbol(E.B, Decl(exhaustiveSwitchStatements1.ts, 33, 11))
+        }
+}
+
+// Repro from #12668
+
+interface Square { kind: "square"; size: number; }
+>Square : Symbol(Square, Decl(exhaustiveSwitchStatements1.ts, 50, 1))
+>kind : Symbol(Square.kind, Decl(exhaustiveSwitchStatements1.ts, 54, 18))
+>size : Symbol(Square.size, Decl(exhaustiveSwitchStatements1.ts, 54, 34))
+
+interface Rectangle { kind: "rectangle"; width: number; height: number; }
+>Rectangle : Symbol(Rectangle, Decl(exhaustiveSwitchStatements1.ts, 54, 50))
+>kind : Symbol(Rectangle.kind, Decl(exhaustiveSwitchStatements1.ts, 56, 21))
+>width : Symbol(Rectangle.width, Decl(exhaustiveSwitchStatements1.ts, 56, 40))
+>height : Symbol(Rectangle.height, Decl(exhaustiveSwitchStatements1.ts, 56, 55))
+
+interface Circle { kind: "circle"; radius: number; }
+>Circle : Symbol(Circle, Decl(exhaustiveSwitchStatements1.ts, 56, 73))
+>kind : Symbol(Circle.kind, Decl(exhaustiveSwitchStatements1.ts, 58, 18))
+>radius : Symbol(Circle.radius, Decl(exhaustiveSwitchStatements1.ts, 58, 34))
+
+interface Triangle { kind: "triangle"; side: number; }
+>Triangle : Symbol(Triangle, Decl(exhaustiveSwitchStatements1.ts, 58, 52))
+>kind : Symbol(Triangle.kind, Decl(exhaustiveSwitchStatements1.ts, 60, 20))
+>side : Symbol(Triangle.side, Decl(exhaustiveSwitchStatements1.ts, 60, 38))
+
+type Shape = Square | Rectangle | Circle | Triangle;
+>Shape : Symbol(Shape, Decl(exhaustiveSwitchStatements1.ts, 60, 54))
+>Square : Symbol(Square, Decl(exhaustiveSwitchStatements1.ts, 50, 1))
+>Rectangle : Symbol(Rectangle, Decl(exhaustiveSwitchStatements1.ts, 54, 50))
+>Circle : Symbol(Circle, Decl(exhaustiveSwitchStatements1.ts, 56, 73))
+>Triangle : Symbol(Triangle, Decl(exhaustiveSwitchStatements1.ts, 58, 52))
+
+function area(s: Shape): number {
+>area : Symbol(area, Decl(exhaustiveSwitchStatements1.ts, 62, 52))
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 64, 14))
+>Shape : Symbol(Shape, Decl(exhaustiveSwitchStatements1.ts, 60, 54))
+
+    let area;
+>area : Symbol(area, Decl(exhaustiveSwitchStatements1.ts, 65, 7))
+
+    switch (s.kind) {
+>s.kind : Symbol(kind, Decl(exhaustiveSwitchStatements1.ts, 54, 18), Decl(exhaustiveSwitchStatements1.ts, 56, 21), Decl(exhaustiveSwitchStatements1.ts, 58, 18), Decl(exhaustiveSwitchStatements1.ts, 60, 20))
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 64, 14))
+>kind : Symbol(kind, Decl(exhaustiveSwitchStatements1.ts, 54, 18), Decl(exhaustiveSwitchStatements1.ts, 56, 21), Decl(exhaustiveSwitchStatements1.ts, 58, 18), Decl(exhaustiveSwitchStatements1.ts, 60, 20))
+
+        case "square": area = s.size * s.size; break;
+>area : Symbol(area, Decl(exhaustiveSwitchStatements1.ts, 65, 7))
+>s.size : Symbol(Square.size, Decl(exhaustiveSwitchStatements1.ts, 54, 34))
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 64, 14))
+>size : Symbol(Square.size, Decl(exhaustiveSwitchStatements1.ts, 54, 34))
+>s.size : Symbol(Square.size, Decl(exhaustiveSwitchStatements1.ts, 54, 34))
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 64, 14))
+>size : Symbol(Square.size, Decl(exhaustiveSwitchStatements1.ts, 54, 34))
+
+        case "rectangle": area = s.width * s.height; break;
+>area : Symbol(area, Decl(exhaustiveSwitchStatements1.ts, 65, 7))
+>s.width : Symbol(Rectangle.width, Decl(exhaustiveSwitchStatements1.ts, 56, 40))
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 64, 14))
+>width : Symbol(Rectangle.width, Decl(exhaustiveSwitchStatements1.ts, 56, 40))
+>s.height : Symbol(Rectangle.height, Decl(exhaustiveSwitchStatements1.ts, 56, 55))
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 64, 14))
+>height : Symbol(Rectangle.height, Decl(exhaustiveSwitchStatements1.ts, 56, 55))
+
+        case "circle": area = Math.PI * s.radius * s.radius; break;
+>area : Symbol(area, Decl(exhaustiveSwitchStatements1.ts, 65, 7))
+>Math.PI : Symbol(Math.PI, Decl(lib.es5.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>PI : Symbol(Math.PI, Decl(lib.es5.d.ts, --, --))
+>s.radius : Symbol(Circle.radius, Decl(exhaustiveSwitchStatements1.ts, 58, 34))
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 64, 14))
+>radius : Symbol(Circle.radius, Decl(exhaustiveSwitchStatements1.ts, 58, 34))
+>s.radius : Symbol(Circle.radius, Decl(exhaustiveSwitchStatements1.ts, 58, 34))
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 64, 14))
+>radius : Symbol(Circle.radius, Decl(exhaustiveSwitchStatements1.ts, 58, 34))
+
+        case "triangle": area = Math.sqrt(3) / 4 * s.side * s.side; break;
+>area : Symbol(area, Decl(exhaustiveSwitchStatements1.ts, 65, 7))
+>Math.sqrt : Symbol(Math.sqrt, Decl(lib.es5.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>sqrt : Symbol(Math.sqrt, Decl(lib.es5.d.ts, --, --))
+>s.side : Symbol(Triangle.side, Decl(exhaustiveSwitchStatements1.ts, 60, 38))
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 64, 14))
+>side : Symbol(Triangle.side, Decl(exhaustiveSwitchStatements1.ts, 60, 38))
+>s.side : Symbol(Triangle.side, Decl(exhaustiveSwitchStatements1.ts, 60, 38))
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 64, 14))
+>side : Symbol(Triangle.side, Decl(exhaustiveSwitchStatements1.ts, 60, 38))
+    }
+    return area;
+>area : Symbol(area, Decl(exhaustiveSwitchStatements1.ts, 65, 7))
+}
+
+function areaWrapped(s: Shape): number {
+>areaWrapped : Symbol(areaWrapped, Decl(exhaustiveSwitchStatements1.ts, 73, 1))
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 75, 21))
+>Shape : Symbol(Shape, Decl(exhaustiveSwitchStatements1.ts, 60, 54))
+
+    let area;
+>area : Symbol(area, Decl(exhaustiveSwitchStatements1.ts, 76, 7))
+
+    area = (() => {
+>area : Symbol(area, Decl(exhaustiveSwitchStatements1.ts, 76, 7))
+
+        switch (s.kind) {
+>s.kind : Symbol(kind, Decl(exhaustiveSwitchStatements1.ts, 54, 18), Decl(exhaustiveSwitchStatements1.ts, 56, 21), Decl(exhaustiveSwitchStatements1.ts, 58, 18), Decl(exhaustiveSwitchStatements1.ts, 60, 20))
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 75, 21))
+>kind : Symbol(kind, Decl(exhaustiveSwitchStatements1.ts, 54, 18), Decl(exhaustiveSwitchStatements1.ts, 56, 21), Decl(exhaustiveSwitchStatements1.ts, 58, 18), Decl(exhaustiveSwitchStatements1.ts, 60, 20))
+
+            case "square": return s.size * s.size;
+>s.size : Symbol(Square.size, Decl(exhaustiveSwitchStatements1.ts, 54, 34))
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 75, 21))
+>size : Symbol(Square.size, Decl(exhaustiveSwitchStatements1.ts, 54, 34))
+>s.size : Symbol(Square.size, Decl(exhaustiveSwitchStatements1.ts, 54, 34))
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 75, 21))
+>size : Symbol(Square.size, Decl(exhaustiveSwitchStatements1.ts, 54, 34))
+
+            case "rectangle": return s.width * s.height;
+>s.width : Symbol(Rectangle.width, Decl(exhaustiveSwitchStatements1.ts, 56, 40))
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 75, 21))
+>width : Symbol(Rectangle.width, Decl(exhaustiveSwitchStatements1.ts, 56, 40))
+>s.height : Symbol(Rectangle.height, Decl(exhaustiveSwitchStatements1.ts, 56, 55))
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 75, 21))
+>height : Symbol(Rectangle.height, Decl(exhaustiveSwitchStatements1.ts, 56, 55))
+
+            case "circle": return Math.PI * s.radius * s.radius;
+>Math.PI : Symbol(Math.PI, Decl(lib.es5.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>PI : Symbol(Math.PI, Decl(lib.es5.d.ts, --, --))
+>s.radius : Symbol(Circle.radius, Decl(exhaustiveSwitchStatements1.ts, 58, 34))
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 75, 21))
+>radius : Symbol(Circle.radius, Decl(exhaustiveSwitchStatements1.ts, 58, 34))
+>s.radius : Symbol(Circle.radius, Decl(exhaustiveSwitchStatements1.ts, 58, 34))
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 75, 21))
+>radius : Symbol(Circle.radius, Decl(exhaustiveSwitchStatements1.ts, 58, 34))
+
+            case "triangle": return Math.sqrt(3) / 4 * s.side * s.side;
+>Math.sqrt : Symbol(Math.sqrt, Decl(lib.es5.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>sqrt : Symbol(Math.sqrt, Decl(lib.es5.d.ts, --, --))
+>s.side : Symbol(Triangle.side, Decl(exhaustiveSwitchStatements1.ts, 60, 38))
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 75, 21))
+>side : Symbol(Triangle.side, Decl(exhaustiveSwitchStatements1.ts, 60, 38))
+>s.side : Symbol(Triangle.side, Decl(exhaustiveSwitchStatements1.ts, 60, 38))
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 75, 21))
+>side : Symbol(Triangle.side, Decl(exhaustiveSwitchStatements1.ts, 60, 38))
+        }
+    })();
+    return area;
+>area : Symbol(area, Decl(exhaustiveSwitchStatements1.ts, 76, 7))
+}
+
+// Repro from #13241
+
+enum MyEnum {
+>MyEnum : Symbol(MyEnum, Decl(exhaustiveSwitchStatements1.ts, 86, 1))
+
+	A,
+>A : Symbol(MyEnum.A, Decl(exhaustiveSwitchStatements1.ts, 90, 13))
+
+	B
+>B : Symbol(MyEnum.B, Decl(exhaustiveSwitchStatements1.ts, 91, 3))
+}
+
+function thisGivesError(e: MyEnum): string {
+>thisGivesError : Symbol(thisGivesError, Decl(exhaustiveSwitchStatements1.ts, 93, 1))
+>e : Symbol(e, Decl(exhaustiveSwitchStatements1.ts, 95, 24))
+>MyEnum : Symbol(MyEnum, Decl(exhaustiveSwitchStatements1.ts, 86, 1))
+
+	let s: string;
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 96, 4))
+
+	switch (e) {
+>e : Symbol(e, Decl(exhaustiveSwitchStatements1.ts, 95, 24))
+
+		case MyEnum.A: s = "it was A"; break;
+>MyEnum.A : Symbol(MyEnum.A, Decl(exhaustiveSwitchStatements1.ts, 90, 13))
+>MyEnum : Symbol(MyEnum, Decl(exhaustiveSwitchStatements1.ts, 86, 1))
+>A : Symbol(MyEnum.A, Decl(exhaustiveSwitchStatements1.ts, 90, 13))
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 96, 4))
+
+		case MyEnum.B: s = "it was B"; break;
+>MyEnum.B : Symbol(MyEnum.B, Decl(exhaustiveSwitchStatements1.ts, 91, 3))
+>MyEnum : Symbol(MyEnum, Decl(exhaustiveSwitchStatements1.ts, 86, 1))
+>B : Symbol(MyEnum.B, Decl(exhaustiveSwitchStatements1.ts, 91, 3))
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 96, 4))
+	}
+	return s;
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 96, 4))
+}
+
+function good1(e: MyEnum): string {
+>good1 : Symbol(good1, Decl(exhaustiveSwitchStatements1.ts, 102, 1))
+>e : Symbol(e, Decl(exhaustiveSwitchStatements1.ts, 104, 15))
+>MyEnum : Symbol(MyEnum, Decl(exhaustiveSwitchStatements1.ts, 86, 1))
+
+	let s: string;
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 105, 4))
+
+	switch (e) {
+>e : Symbol(e, Decl(exhaustiveSwitchStatements1.ts, 104, 15))
+
+		case MyEnum.A: s = "it was A"; break;
+>MyEnum.A : Symbol(MyEnum.A, Decl(exhaustiveSwitchStatements1.ts, 90, 13))
+>MyEnum : Symbol(MyEnum, Decl(exhaustiveSwitchStatements1.ts, 86, 1))
+>A : Symbol(MyEnum.A, Decl(exhaustiveSwitchStatements1.ts, 90, 13))
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 105, 4))
+
+		case MyEnum.B: s = "it was B"; break;
+>MyEnum.B : Symbol(MyEnum.B, Decl(exhaustiveSwitchStatements1.ts, 91, 3))
+>MyEnum : Symbol(MyEnum, Decl(exhaustiveSwitchStatements1.ts, 86, 1))
+>B : Symbol(MyEnum.B, Decl(exhaustiveSwitchStatements1.ts, 91, 3))
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 105, 4))
+
+		default: s = "it was something else"; break;
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 105, 4))
+	}
+	return s;
+>s : Symbol(s, Decl(exhaustiveSwitchStatements1.ts, 105, 4))
+}
+
+function good2(e: MyEnum): string {
+>good2 : Symbol(good2, Decl(exhaustiveSwitchStatements1.ts, 112, 1))
+>e : Symbol(e, Decl(exhaustiveSwitchStatements1.ts, 114, 15))
+>MyEnum : Symbol(MyEnum, Decl(exhaustiveSwitchStatements1.ts, 86, 1))
+
+	switch (e) {
+>e : Symbol(e, Decl(exhaustiveSwitchStatements1.ts, 114, 15))
+
+		case MyEnum.A: return "it was A";
+>MyEnum.A : Symbol(MyEnum.A, Decl(exhaustiveSwitchStatements1.ts, 90, 13))
+>MyEnum : Symbol(MyEnum, Decl(exhaustiveSwitchStatements1.ts, 86, 1))
+>A : Symbol(MyEnum.A, Decl(exhaustiveSwitchStatements1.ts, 90, 13))
+
+		case MyEnum.B: return "it was B";
+>MyEnum.B : Symbol(MyEnum.B, Decl(exhaustiveSwitchStatements1.ts, 91, 3))
+>MyEnum : Symbol(MyEnum, Decl(exhaustiveSwitchStatements1.ts, 86, 1))
+>B : Symbol(MyEnum.B, Decl(exhaustiveSwitchStatements1.ts, 91, 3))
+	}
+}
+
+// Repro from #18362
+
+enum Level {
+>Level : Symbol(Level, Decl(exhaustiveSwitchStatements1.ts, 119, 1))
+
+  One,
+>One : Symbol(Level.One, Decl(exhaustiveSwitchStatements1.ts, 123, 12))
+
+  Two,
+>Two : Symbol(Level.Two, Decl(exhaustiveSwitchStatements1.ts, 124, 6))
+}
+
+const doSomethingWithLevel = (level: Level) => {
+>doSomethingWithLevel : Symbol(doSomethingWithLevel, Decl(exhaustiveSwitchStatements1.ts, 128, 5))
+>level : Symbol(level, Decl(exhaustiveSwitchStatements1.ts, 128, 30))
+>Level : Symbol(Level, Decl(exhaustiveSwitchStatements1.ts, 119, 1))
+
+  let next: Level;
+>next : Symbol(next, Decl(exhaustiveSwitchStatements1.ts, 129, 5))
+>Level : Symbol(Level, Decl(exhaustiveSwitchStatements1.ts, 119, 1))
+
+  switch (level) {
+>level : Symbol(level, Decl(exhaustiveSwitchStatements1.ts, 128, 30))
+
+    case Level.One:
+>Level.One : Symbol(Level.One, Decl(exhaustiveSwitchStatements1.ts, 123, 12))
+>Level : Symbol(Level, Decl(exhaustiveSwitchStatements1.ts, 119, 1))
+>One : Symbol(Level.One, Decl(exhaustiveSwitchStatements1.ts, 123, 12))
+
+      next = Level.Two;
+>next : Symbol(next, Decl(exhaustiveSwitchStatements1.ts, 129, 5))
+>Level.Two : Symbol(Level.Two, Decl(exhaustiveSwitchStatements1.ts, 124, 6))
+>Level : Symbol(Level, Decl(exhaustiveSwitchStatements1.ts, 119, 1))
+>Two : Symbol(Level.Two, Decl(exhaustiveSwitchStatements1.ts, 124, 6))
+
+      break;
+    case Level.Two:
+>Level.Two : Symbol(Level.Two, Decl(exhaustiveSwitchStatements1.ts, 124, 6))
+>Level : Symbol(Level, Decl(exhaustiveSwitchStatements1.ts, 119, 1))
+>Two : Symbol(Level.Two, Decl(exhaustiveSwitchStatements1.ts, 124, 6))
+
+      next = Level.One;
+>next : Symbol(next, Decl(exhaustiveSwitchStatements1.ts, 129, 5))
+>Level.One : Symbol(Level.One, Decl(exhaustiveSwitchStatements1.ts, 123, 12))
+>Level : Symbol(Level, Decl(exhaustiveSwitchStatements1.ts, 119, 1))
+>One : Symbol(Level.One, Decl(exhaustiveSwitchStatements1.ts, 123, 12))
+
+      break;
+  }
+  return next;
+>next : Symbol(next, Decl(exhaustiveSwitchStatements1.ts, 129, 5))
+
+};
+
+// Repro from #20409
+
+interface Square2 {
+>Square2 : Symbol(Square2, Decl(exhaustiveSwitchStatements1.ts, 139, 2))
+
+    kind: "square";
+>kind : Symbol(Square2.kind, Decl(exhaustiveSwitchStatements1.ts, 143, 19))
+
+    size: number;
+>size : Symbol(Square2.size, Decl(exhaustiveSwitchStatements1.ts, 144, 19))
+}
+
+interface Circle2 {
+>Circle2 : Symbol(Circle2, Decl(exhaustiveSwitchStatements1.ts, 146, 1))
+
+    kind: "circle";
+>kind : Symbol(Circle2.kind, Decl(exhaustiveSwitchStatements1.ts, 148, 19))
+
+    radius: number;
+>radius : Symbol(Circle2.radius, Decl(exhaustiveSwitchStatements1.ts, 149, 19))
+}
+
+type Shape2 = Square2 | Circle2;
+>Shape2 : Symbol(Shape2, Decl(exhaustiveSwitchStatements1.ts, 151, 1))
+>Square2 : Symbol(Square2, Decl(exhaustiveSwitchStatements1.ts, 139, 2))
+>Circle2 : Symbol(Circle2, Decl(exhaustiveSwitchStatements1.ts, 146, 1))
+
+function withDefault(s1: Shape2, s2: Shape2): string {
+>withDefault : Symbol(withDefault, Decl(exhaustiveSwitchStatements1.ts, 153, 32))
+>s1 : Symbol(s1, Decl(exhaustiveSwitchStatements1.ts, 155, 21))
+>Shape2 : Symbol(Shape2, Decl(exhaustiveSwitchStatements1.ts, 151, 1))
+>s2 : Symbol(s2, Decl(exhaustiveSwitchStatements1.ts, 155, 32))
+>Shape2 : Symbol(Shape2, Decl(exhaustiveSwitchStatements1.ts, 151, 1))
+
+    switch (s1.kind) {
+>s1.kind : Symbol(kind, Decl(exhaustiveSwitchStatements1.ts, 143, 19), Decl(exhaustiveSwitchStatements1.ts, 148, 19))
+>s1 : Symbol(s1, Decl(exhaustiveSwitchStatements1.ts, 155, 21))
+>kind : Symbol(kind, Decl(exhaustiveSwitchStatements1.ts, 143, 19), Decl(exhaustiveSwitchStatements1.ts, 148, 19))
+
+        case "square":
+            return "1";
+        case "circle":
+            switch (s2.kind) {
+>s2.kind : Symbol(kind, Decl(exhaustiveSwitchStatements1.ts, 143, 19), Decl(exhaustiveSwitchStatements1.ts, 148, 19))
+>s2 : Symbol(s2, Decl(exhaustiveSwitchStatements1.ts, 155, 32))
+>kind : Symbol(kind, Decl(exhaustiveSwitchStatements1.ts, 143, 19), Decl(exhaustiveSwitchStatements1.ts, 148, 19))
+
+                case "square":
+                    return "2";
+                case "circle":
+                    return "3";
+                default:
+                    return "never";
+            }
+    }
+}
+
+function withoutDefault(s1: Shape2, s2: Shape2): string {
+>withoutDefault : Symbol(withoutDefault, Decl(exhaustiveSwitchStatements1.ts, 169, 1))
+>s1 : Symbol(s1, Decl(exhaustiveSwitchStatements1.ts, 171, 24))
+>Shape2 : Symbol(Shape2, Decl(exhaustiveSwitchStatements1.ts, 151, 1))
+>s2 : Symbol(s2, Decl(exhaustiveSwitchStatements1.ts, 171, 35))
+>Shape2 : Symbol(Shape2, Decl(exhaustiveSwitchStatements1.ts, 151, 1))
+
+    switch (s1.kind) {
+>s1.kind : Symbol(kind, Decl(exhaustiveSwitchStatements1.ts, 143, 19), Decl(exhaustiveSwitchStatements1.ts, 148, 19))
+>s1 : Symbol(s1, Decl(exhaustiveSwitchStatements1.ts, 171, 24))
+>kind : Symbol(kind, Decl(exhaustiveSwitchStatements1.ts, 143, 19), Decl(exhaustiveSwitchStatements1.ts, 148, 19))
+
+        case "square":
+            return "1";
+        case "circle":
+            switch (s2.kind) {
+>s2.kind : Symbol(kind, Decl(exhaustiveSwitchStatements1.ts, 143, 19), Decl(exhaustiveSwitchStatements1.ts, 148, 19))
+>s2 : Symbol(s2, Decl(exhaustiveSwitchStatements1.ts, 171, 35))
+>kind : Symbol(kind, Decl(exhaustiveSwitchStatements1.ts, 143, 19), Decl(exhaustiveSwitchStatements1.ts, 148, 19))
+
+                case "square":
+                    return "2";
+                case "circle":
+                    return "3";
+            }
+    }
+}
+
+// Repro from #20823
+
+function test4(value: 1 | 2) {
+>test4 : Symbol(test4, Decl(exhaustiveSwitchStatements1.ts, 183, 1))
+>value : Symbol(value, Decl(exhaustiveSwitchStatements1.ts, 187, 15))
+
+    let x: string;
+>x : Symbol(x, Decl(exhaustiveSwitchStatements1.ts, 188, 7))
+
+    switch (value) {
+>value : Symbol(value, Decl(exhaustiveSwitchStatements1.ts, 187, 15))
+
+        case 1: x = "one"; break;
+>x : Symbol(x, Decl(exhaustiveSwitchStatements1.ts, 188, 7))
+
+        case 2: x = "two"; break;
+>x : Symbol(x, Decl(exhaustiveSwitchStatements1.ts, 188, 7))
+    }
+    return x;
+>x : Symbol(x, Decl(exhaustiveSwitchStatements1.ts, 188, 7))
+}
+
diff --git a/tests/baselines/reference/exhaustiveSwitchStatements1.types b/tests/baselines/reference/exhaustiveSwitchStatements1.types
new file mode 100644
index 00000000000..04a9bf531ce
--- /dev/null
+++ b/tests/baselines/reference/exhaustiveSwitchStatements1.types
@@ -0,0 +1,595 @@
+=== tests/cases/conformance/controlFlow/exhaustiveSwitchStatements1.ts ===
+function f1(x: 1 | 2): string {
+>f1 : (x: 1 | 2) => string
+>x : 1 | 2
+
+    if (!!true) {
+>!!true : true
+>!true : false
+>true : true
+
+        switch (x) {
+>x : 1 | 2
+
+            case 1: return 'a';
+>1 : 1
+>'a' : "a"
+
+            case 2: return 'b';
+>2 : 2
+>'b' : "b"
+        }
+        x;  // Unreachable
+>x : never
+    }
+    else {
+        throw 0;
+>0 : 0
+    }
+}
+
+function f2(x: 1 | 2) {
+>f2 : (x: 1 | 2) => void
+>x : 1 | 2
+
+    let z: number;
+>z : number
+
+    switch (x) {
+>x : 1 | 2
+
+        case 1: z = 10; break;
+>1 : 1
+>z = 10 : 10
+>z : number
+>10 : 10
+
+        case 2: z = 20; break;
+>2 : 2
+>z = 20 : 20
+>z : number
+>20 : 20
+    }
+    z;  // Definitely assigned
+>z : number
+}
+
+function f3(x: 1 | 2) {
+>f3 : (x: 1 | 2) => 10 | 20
+>x : 1 | 2
+
+    switch (x) {
+>x : 1 | 2
+
+        case 1: return 10;
+>1 : 1
+>10 : 10
+
+        case 2: return 20;
+>2 : 2
+>20 : 20
+
+        // Default considered reachable to allow defensive coding
+        default: throw new Error("Bad input");
+>new Error("Bad input") : Error
+>Error : ErrorConstructor
+>"Bad input" : "Bad input"
+    }
+}
+
+// Repro from #11572
+
+enum E { A, B }
+>E : E
+>A : E.A
+>B : E.B
+
+function f(e: E): number {
+>f : (e: E) => number
+>e : E
+
+    switch (e) {
+>e : E
+
+        case E.A: return 0
+>E.A : E.A
+>E : typeof E
+>A : E.A
+>0 : 0
+
+        case E.B: return 1
+>E.B : E.B
+>E : typeof E
+>B : E.B
+>1 : 1
+    }
+}
+
+function g(e: E): number {
+>g : (e: E) => number
+>e : E
+
+    if (!true)
+>!true : false
+>true : true
+
+        return -1
+>-1 : -1
+>1 : 1
+
+    else
+        switch (e) {
+>e : E
+
+            case E.A: return 0
+>E.A : E.A
+>E : typeof E
+>A : E.A
+>0 : 0
+
+            case E.B: return 1
+>E.B : E.B
+>E : typeof E
+>B : E.B
+>1 : 1
+        }
+}
+
+// Repro from #12668
+
+interface Square { kind: "square"; size: number; }
+>kind : "square"
+>size : number
+
+interface Rectangle { kind: "rectangle"; width: number; height: number; }
+>kind : "rectangle"
+>width : number
+>height : number
+
+interface Circle { kind: "circle"; radius: number; }
+>kind : "circle"
+>radius : number
+
+interface Triangle { kind: "triangle"; side: number; }
+>kind : "triangle"
+>side : number
+
+type Shape = Square | Rectangle | Circle | Triangle;
+>Shape : Shape
+
+function area(s: Shape): number {
+>area : (s: Shape) => number
+>s : Shape
+
+    let area;
+>area : any
+
+    switch (s.kind) {
+>s.kind : "square" | "rectangle" | "circle" | "triangle"
+>s : Shape
+>kind : "square" | "rectangle" | "circle" | "triangle"
+
+        case "square": area = s.size * s.size; break;
+>"square" : "square"
+>area = s.size * s.size : number
+>area : any
+>s.size * s.size : number
+>s.size : number
+>s : Square
+>size : number
+>s.size : number
+>s : Square
+>size : number
+
+        case "rectangle": area = s.width * s.height; break;
+>"rectangle" : "rectangle"
+>area = s.width * s.height : number
+>area : any
+>s.width * s.height : number
+>s.width : number
+>s : Rectangle
+>width : number
+>s.height : number
+>s : Rectangle
+>height : number
+
+        case "circle": area = Math.PI * s.radius * s.radius; break;
+>"circle" : "circle"
+>area = Math.PI * s.radius * s.radius : number
+>area : any
+>Math.PI * s.radius * s.radius : number
+>Math.PI * s.radius : number
+>Math.PI : number
+>Math : Math
+>PI : number
+>s.radius : number
+>s : Circle
+>radius : number
+>s.radius : number
+>s : Circle
+>radius : number
+
+        case "triangle": area = Math.sqrt(3) / 4 * s.side * s.side; break;
+>"triangle" : "triangle"
+>area = Math.sqrt(3) / 4 * s.side * s.side : number
+>area : any
+>Math.sqrt(3) / 4 * s.side * s.side : number
+>Math.sqrt(3) / 4 * s.side : number
+>Math.sqrt(3) / 4 : number
+>Math.sqrt(3) : number
+>Math.sqrt : (x: number) => number
+>Math : Math
+>sqrt : (x: number) => number
+>3 : 3
+>4 : 4
+>s.side : number
+>s : Triangle
+>side : number
+>s.side : number
+>s : Triangle
+>side : number
+    }
+    return area;
+>area : number
+}
+
+function areaWrapped(s: Shape): number {
+>areaWrapped : (s: Shape) => number
+>s : Shape
+
+    let area;
+>area : any
+
+    area = (() => {
+>area = (() => {        switch (s.kind) {            case "square": return s.size * s.size;            case "rectangle": return s.width * s.height;            case "circle": return Math.PI * s.radius * s.radius;            case "triangle": return Math.sqrt(3) / 4 * s.side * s.side;        }    })() : number
+>area : any
+>(() => {        switch (s.kind) {            case "square": return s.size * s.size;            case "rectangle": return s.width * s.height;            case "circle": return Math.PI * s.radius * s.radius;            case "triangle": return Math.sqrt(3) / 4 * s.side * s.side;        }    })() : number
+>(() => {        switch (s.kind) {            case "square": return s.size * s.size;            case "rectangle": return s.width * s.height;            case "circle": return Math.PI * s.radius * s.radius;            case "triangle": return Math.sqrt(3) / 4 * s.side * s.side;        }    }) : () => number
+>() => {        switch (s.kind) {            case "square": return s.size * s.size;            case "rectangle": return s.width * s.height;            case "circle": return Math.PI * s.radius * s.radius;            case "triangle": return Math.sqrt(3) / 4 * s.side * s.side;        }    } : () => number
+
+        switch (s.kind) {
+>s.kind : "square" | "rectangle" | "circle" | "triangle"
+>s : Shape
+>kind : "square" | "rectangle" | "circle" | "triangle"
+
+            case "square": return s.size * s.size;
+>"square" : "square"
+>s.size * s.size : number
+>s.size : number
+>s : Square
+>size : number
+>s.size : number
+>s : Square
+>size : number
+
+            case "rectangle": return s.width * s.height;
+>"rectangle" : "rectangle"
+>s.width * s.height : number
+>s.width : number
+>s : Rectangle
+>width : number
+>s.height : number
+>s : Rectangle
+>height : number
+
+            case "circle": return Math.PI * s.radius * s.radius;
+>"circle" : "circle"
+>Math.PI * s.radius * s.radius : number
+>Math.PI * s.radius : number
+>Math.PI : number
+>Math : Math
+>PI : number
+>s.radius : number
+>s : Circle
+>radius : number
+>s.radius : number
+>s : Circle
+>radius : number
+
+            case "triangle": return Math.sqrt(3) / 4 * s.side * s.side;
+>"triangle" : "triangle"
+>Math.sqrt(3) / 4 * s.side * s.side : number
+>Math.sqrt(3) / 4 * s.side : number
+>Math.sqrt(3) / 4 : number
+>Math.sqrt(3) : number
+>Math.sqrt : (x: number) => number
+>Math : Math
+>sqrt : (x: number) => number
+>3 : 3
+>4 : 4
+>s.side : number
+>s : Triangle
+>side : number
+>s.side : number
+>s : Triangle
+>side : number
+        }
+    })();
+    return area;
+>area : number
+}
+
+// Repro from #13241
+
+enum MyEnum {
+>MyEnum : MyEnum
+
+	A,
+>A : MyEnum.A
+
+	B
+>B : MyEnum.B
+}
+
+function thisGivesError(e: MyEnum): string {
+>thisGivesError : (e: MyEnum) => string
+>e : MyEnum
+
+	let s: string;
+>s : string
+
+	switch (e) {
+>e : MyEnum
+
+		case MyEnum.A: s = "it was A"; break;
+>MyEnum.A : MyEnum.A
+>MyEnum : typeof MyEnum
+>A : MyEnum.A
+>s = "it was A" : "it was A"
+>s : string
+>"it was A" : "it was A"
+
+		case MyEnum.B: s = "it was B"; break;
+>MyEnum.B : MyEnum.B
+>MyEnum : typeof MyEnum
+>B : MyEnum.B
+>s = "it was B" : "it was B"
+>s : string
+>"it was B" : "it was B"
+	}
+	return s;
+>s : string
+}
+
+function good1(e: MyEnum): string {
+>good1 : (e: MyEnum) => string
+>e : MyEnum
+
+	let s: string;
+>s : string
+
+	switch (e) {
+>e : MyEnum
+
+		case MyEnum.A: s = "it was A"; break;
+>MyEnum.A : MyEnum.A
+>MyEnum : typeof MyEnum
+>A : MyEnum.A
+>s = "it was A" : "it was A"
+>s : string
+>"it was A" : "it was A"
+
+		case MyEnum.B: s = "it was B"; break;
+>MyEnum.B : MyEnum.B
+>MyEnum : typeof MyEnum
+>B : MyEnum.B
+>s = "it was B" : "it was B"
+>s : string
+>"it was B" : "it was B"
+
+		default: s = "it was something else"; break;
+>s = "it was something else" : "it was something else"
+>s : string
+>"it was something else" : "it was something else"
+	}
+	return s;
+>s : string
+}
+
+function good2(e: MyEnum): string {
+>good2 : (e: MyEnum) => string
+>e : MyEnum
+
+	switch (e) {
+>e : MyEnum
+
+		case MyEnum.A: return "it was A";
+>MyEnum.A : MyEnum.A
+>MyEnum : typeof MyEnum
+>A : MyEnum.A
+>"it was A" : "it was A"
+
+		case MyEnum.B: return "it was B";
+>MyEnum.B : MyEnum.B
+>MyEnum : typeof MyEnum
+>B : MyEnum.B
+>"it was B" : "it was B"
+	}
+}
+
+// Repro from #18362
+
+enum Level {
+>Level : Level
+
+  One,
+>One : Level.One
+
+  Two,
+>Two : Level.Two
+}
+
+const doSomethingWithLevel = (level: Level) => {
+>doSomethingWithLevel : (level: Level) => Level
+>(level: Level) => {  let next: Level;  switch (level) {    case Level.One:      next = Level.Two;      break;    case Level.Two:      next = Level.One;      break;  }  return next;} : (level: Level) => Level
+>level : Level
+
+  let next: Level;
+>next : Level
+
+  switch (level) {
+>level : Level
+
+    case Level.One:
+>Level.One : Level.One
+>Level : typeof Level
+>One : Level.One
+
+      next = Level.Two;
+>next = Level.Two : Level.Two
+>next : Level
+>Level.Two : Level.Two
+>Level : typeof Level
+>Two : Level.Two
+
+      break;
+    case Level.Two:
+>Level.Two : Level.Two
+>Level : typeof Level
+>Two : Level.Two
+
+      next = Level.One;
+>next = Level.One : Level.One
+>next : Level
+>Level.One : Level.One
+>Level : typeof Level
+>One : Level.One
+
+      break;
+  }
+  return next;
+>next : Level
+
+};
+
+// Repro from #20409
+
+interface Square2 {
+    kind: "square";
+>kind : "square"
+
+    size: number;
+>size : number
+}
+
+interface Circle2 {
+    kind: "circle";
+>kind : "circle"
+
+    radius: number;
+>radius : number
+}
+
+type Shape2 = Square2 | Circle2;
+>Shape2 : Shape2
+
+function withDefault(s1: Shape2, s2: Shape2): string {
+>withDefault : (s1: Shape2, s2: Shape2) => string
+>s1 : Shape2
+>s2 : Shape2
+
+    switch (s1.kind) {
+>s1.kind : "square" | "circle"
+>s1 : Shape2
+>kind : "square" | "circle"
+
+        case "square":
+>"square" : "square"
+
+            return "1";
+>"1" : "1"
+
+        case "circle":
+>"circle" : "circle"
+
+            switch (s2.kind) {
+>s2.kind : "square" | "circle"
+>s2 : Shape2
+>kind : "square" | "circle"
+
+                case "square":
+>"square" : "square"
+
+                    return "2";
+>"2" : "2"
+
+                case "circle":
+>"circle" : "circle"
+
+                    return "3";
+>"3" : "3"
+
+                default:
+                    return "never";
+>"never" : "never"
+            }
+    }
+}
+
+function withoutDefault(s1: Shape2, s2: Shape2): string {
+>withoutDefault : (s1: Shape2, s2: Shape2) => string
+>s1 : Shape2
+>s2 : Shape2
+
+    switch (s1.kind) {
+>s1.kind : "square" | "circle"
+>s1 : Shape2
+>kind : "square" | "circle"
+
+        case "square":
+>"square" : "square"
+
+            return "1";
+>"1" : "1"
+
+        case "circle":
+>"circle" : "circle"
+
+            switch (s2.kind) {
+>s2.kind : "square" | "circle"
+>s2 : Shape2
+>kind : "square" | "circle"
+
+                case "square":
+>"square" : "square"
+
+                    return "2";
+>"2" : "2"
+
+                case "circle":
+>"circle" : "circle"
+
+                    return "3";
+>"3" : "3"
+            }
+    }
+}
+
+// Repro from #20823
+
+function test4(value: 1 | 2) {
+>test4 : (value: 1 | 2) => string
+>value : 1 | 2
+
+    let x: string;
+>x : string
+
+    switch (value) {
+>value : 1 | 2
+
+        case 1: x = "one"; break;
+>1 : 1
+>x = "one" : "one"
+>x : string
+>"one" : "one"
+
+        case 2: x = "two"; break;
+>2 : 2
+>x = "two" : "two"
+>x : string
+>"two" : "two"
+    }
+    return x;
+>x : string
+}
+
diff --git a/tests/baselines/reference/extendAndImplementTheSameBaseType2.errors.txt b/tests/baselines/reference/extendAndImplementTheSameBaseType2.errors.txt
index 799fc7bb8b0..e23d9ebd282 100644
--- a/tests/baselines/reference/extendAndImplementTheSameBaseType2.errors.txt
+++ b/tests/baselines/reference/extendAndImplementTheSameBaseType2.errors.txt
@@ -1,7 +1,6 @@
 tests/cases/compiler/extendAndImplementTheSameBaseType2.ts(7,7): error TS2720: Class 'D' incorrectly implements class 'C<number>'. Did you mean to extend 'C<number>' and inherit its members as a subclass?
-  Types of property 'bar' are incompatible.
-    Type '() => string' is not assignable to type '() => number'.
-      Type 'string' is not assignable to type 'number'.
+  The types returned by 'bar()' are incompatible between these types.
+    Type 'string' is not assignable to type 'number'.
 tests/cases/compiler/extendAndImplementTheSameBaseType2.ts(12,5): error TS2322: Type 'number' is not assignable to type 'string'.
 tests/cases/compiler/extendAndImplementTheSameBaseType2.ts(16,5): error TS2322: Type 'string' is not assignable to type 'number'.
 
@@ -16,9 +15,8 @@ tests/cases/compiler/extendAndImplementTheSameBaseType2.ts(16,5): error TS2322:
     class D extends C<string> implements C<number> {
           ~
 !!! error TS2720: Class 'D' incorrectly implements class 'C<number>'. Did you mean to extend 'C<number>' and inherit its members as a subclass?
-!!! error TS2720:   Types of property 'bar' are incompatible.
-!!! error TS2720:     Type '() => string' is not assignable to type '() => number'.
-!!! error TS2720:       Type 'string' is not assignable to type 'number'.
+!!! error TS2720:   The types returned by 'bar()' are incompatible between these types.
+!!! error TS2720:     Type 'string' is not assignable to type 'number'.
         baz() { }
     }
     
diff --git a/tests/baselines/reference/for-of39.errors.txt b/tests/baselines/reference/for-of39.errors.txt
index a36c1c28a8c..3ecdc46bcfc 100644
--- a/tests/baselines/reference/for-of39.errors.txt
+++ b/tests/baselines/reference/for-of39.errors.txt
@@ -1,18 +1,14 @@
 tests/cases/conformance/es6/for-ofStatements/for-of39.ts(1,11): error TS2769: No overload matches this call.
   Overload 1 of 3, '(iterable: Iterable<readonly [string, boolean]>): Map<string, boolean>', gave the following error.
     Argument of type '([string, number] | [string, true])[]' is not assignable to parameter of type 'Iterable<readonly [string, boolean]>'.
-      Types of property '[Symbol.iterator]' are incompatible.
-        Type '() => IterableIterator<[string, number] | [string, true]>' is not assignable to type '() => Iterator<readonly [string, boolean], any, undefined>'.
-          Type 'IterableIterator<[string, number] | [string, true]>' is not assignable to type 'Iterator<readonly [string, boolean], any, undefined>'.
-            Types of property 'next' are incompatible.
-              Type '(...args: [] | [undefined]) => IteratorResult<[string, number] | [string, true], any>' is not assignable to type '(...args: [] | [undefined]) => IteratorResult<readonly [string, boolean], any>'.
-                Type 'IteratorResult<[string, number] | [string, true], any>' is not assignable to type 'IteratorResult<readonly [string, boolean], any>'.
-                  Type 'IteratorYieldResult<[string, number] | [string, true]>' is not assignable to type 'IteratorResult<readonly [string, boolean], any>'.
-                    Type 'IteratorYieldResult<[string, number] | [string, true]>' is not assignable to type 'IteratorYieldResult<readonly [string, boolean]>'.
-                      Type '[string, number] | [string, true]' is not assignable to type 'readonly [string, boolean]'.
-                        Type '[string, number]' is not assignable to type 'readonly [string, boolean]'.
-                          Types of property '1' are incompatible.
-                            Type 'number' is not assignable to type 'boolean'.
+      The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types.
+        Type 'IteratorResult<[string, number] | [string, true], any>' is not assignable to type 'IteratorResult<readonly [string, boolean], any>'.
+          Type 'IteratorYieldResult<[string, number] | [string, true]>' is not assignable to type 'IteratorResult<readonly [string, boolean], any>'.
+            Type 'IteratorYieldResult<[string, number] | [string, true]>' is not assignable to type 'IteratorYieldResult<readonly [string, boolean]>'.
+              Type '[string, number] | [string, true]' is not assignable to type 'readonly [string, boolean]'.
+                Type '[string, number]' is not assignable to type 'readonly [string, boolean]'.
+                  Types of property '1' are incompatible.
+                    Type 'number' is not assignable to type 'boolean'.
   Overload 2 of 3, '(entries?: readonly (readonly [string, boolean])[]): Map<string, boolean>', gave the following error.
     Type 'number' is not assignable to type 'boolean'.
 
@@ -23,18 +19,14 @@ tests/cases/conformance/es6/for-ofStatements/for-of39.ts(1,11): error TS2769: No
 !!! error TS2769: No overload matches this call.
 !!! error TS2769:   Overload 1 of 3, '(iterable: Iterable<readonly [string, boolean]>): Map<string, boolean>', gave the following error.
 !!! error TS2769:     Argument of type '([string, number] | [string, true])[]' is not assignable to parameter of type 'Iterable<readonly [string, boolean]>'.
-!!! error TS2769:       Types of property '[Symbol.iterator]' are incompatible.
-!!! error TS2769:         Type '() => IterableIterator<[string, number] | [string, true]>' is not assignable to type '() => Iterator<readonly [string, boolean], any, undefined>'.
-!!! error TS2769:           Type 'IterableIterator<[string, number] | [string, true]>' is not assignable to type 'Iterator<readonly [string, boolean], any, undefined>'.
-!!! error TS2769:             Types of property 'next' are incompatible.
-!!! error TS2769:               Type '(...args: [] | [undefined]) => IteratorResult<[string, number] | [string, true], any>' is not assignable to type '(...args: [] | [undefined]) => IteratorResult<readonly [string, boolean], any>'.
-!!! error TS2769:                 Type 'IteratorResult<[string, number] | [string, true], any>' is not assignable to type 'IteratorResult<readonly [string, boolean], any>'.
-!!! error TS2769:                   Type 'IteratorYieldResult<[string, number] | [string, true]>' is not assignable to type 'IteratorResult<readonly [string, boolean], any>'.
-!!! error TS2769:                     Type 'IteratorYieldResult<[string, number] | [string, true]>' is not assignable to type 'IteratorYieldResult<readonly [string, boolean]>'.
-!!! error TS2769:                       Type '[string, number] | [string, true]' is not assignable to type 'readonly [string, boolean]'.
-!!! error TS2769:                         Type '[string, number]' is not assignable to type 'readonly [string, boolean]'.
-!!! error TS2769:                           Types of property '1' are incompatible.
-!!! error TS2769:                             Type 'number' is not assignable to type 'boolean'.
+!!! error TS2769:       The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types.
+!!! error TS2769:         Type 'IteratorResult<[string, number] | [string, true], any>' is not assignable to type 'IteratorResult<readonly [string, boolean], any>'.
+!!! error TS2769:           Type 'IteratorYieldResult<[string, number] | [string, true]>' is not assignable to type 'IteratorResult<readonly [string, boolean], any>'.
+!!! error TS2769:             Type 'IteratorYieldResult<[string, number] | [string, true]>' is not assignable to type 'IteratorYieldResult<readonly [string, boolean]>'.
+!!! error TS2769:               Type '[string, number] | [string, true]' is not assignable to type 'readonly [string, boolean]'.
+!!! error TS2769:                 Type '[string, number]' is not assignable to type 'readonly [string, boolean]'.
+!!! error TS2769:                   Types of property '1' are incompatible.
+!!! error TS2769:                     Type 'number' is not assignable to type 'boolean'.
 !!! error TS2769:   Overload 2 of 3, '(entries?: readonly (readonly [string, boolean])[]): Map<string, boolean>', gave the following error.
 !!! error TS2769:     Type 'number' is not assignable to type 'boolean'.
     for (var [k, v] of map) {
diff --git a/tests/baselines/reference/functionConstraintSatisfaction2.types b/tests/baselines/reference/functionConstraintSatisfaction2.types
index f5a7eb0fd65..f0a0f3b61f2 100644
--- a/tests/baselines/reference/functionConstraintSatisfaction2.types
+++ b/tests/baselines/reference/functionConstraintSatisfaction2.types
@@ -79,8 +79,8 @@ var r7 = foo2(b);
 >b : new (x: string) => string
 
 var r8 = foo2(<U>(x: U) => x); // no error expected
->r8 : (x: string) => string
->foo2(<U>(x: U) => x) : (x: string) => string
+>r8 : <U>(x: U) => U
+>foo2(<U>(x: U) => x) : <U>(x: U) => U
 >foo2 : <T extends (x: string) => string>(x: T) => T
 ><U>(x: U) => x : <U>(x: U) => U
 >x : U
diff --git a/tests/baselines/reference/functionConstraintSatisfaction3.types b/tests/baselines/reference/functionConstraintSatisfaction3.types
index 499f73b1664..dc760608c73 100644
--- a/tests/baselines/reference/functionConstraintSatisfaction3.types
+++ b/tests/baselines/reference/functionConstraintSatisfaction3.types
@@ -103,16 +103,16 @@ var c2: { <T>(x: T): T; <T>(x: T, y: T): T };
 >y : T
 
 var r9 = foo(function <U>(x: U) { return x; });
->r9 : (x: string) => string
->foo(function <U>(x: U) { return x; }) : (x: string) => string
+>r9 : <U>(x: U) => U
+>foo(function <U>(x: U) { return x; }) : <U>(x: U) => U
 >foo : <T extends (x: string) => string>(x: T) => T
 >function <U>(x: U) { return x; } : <U>(x: U) => U
 >x : U
 >x : U
 
 var r10 = foo(<U extends string>(x: U) => x);
->r10 : (x: string) => string
->foo(<U extends string>(x: U) => x) : (x: string) => string
+>r10 : <U extends string>(x: U) => U
+>foo(<U extends string>(x: U) => x) : <U extends string>(x: U) => U
 >foo : <T extends (x: string) => string>(x: T) => T
 ><U extends string>(x: U) => x : <U extends string>(x: U) => U
 >x : U
diff --git a/tests/baselines/reference/generatorTypeCheck25.errors.txt b/tests/baselines/reference/generatorTypeCheck25.errors.txt
index 365a19dfdd7..e37f1304963 100644
--- a/tests/baselines/reference/generatorTypeCheck25.errors.txt
+++ b/tests/baselines/reference/generatorTypeCheck25.errors.txt
@@ -1,15 +1,11 @@
 tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck25.ts(4,5): error TS2322: Type '() => Generator<Bar | Baz, void, undefined>' is not assignable to type '() => Iterable<Foo>'.
-  Type 'Generator<Bar | Baz, void, undefined>' is not assignable to type 'Iterable<Foo>'.
-    Types of property '[Symbol.iterator]' are incompatible.
-      Type '() => Generator<Bar | Baz, void, undefined>' is not assignable to type '() => Iterator<Foo, any, undefined>'.
-        Type 'Generator<Bar | Baz, void, undefined>' is not assignable to type 'Iterator<Foo, any, undefined>'.
-          Types of property 'next' are incompatible.
-            Type '(...args: [] | [undefined]) => IteratorResult<Bar | Baz, void>' is not assignable to type '(...args: [] | [undefined]) => IteratorResult<Foo, any>'.
-              Type 'IteratorResult<Bar | Baz, void>' is not assignable to type 'IteratorResult<Foo, any>'.
-                Type 'IteratorYieldResult<Bar | Baz>' is not assignable to type 'IteratorResult<Foo, any>'.
-                  Type 'IteratorYieldResult<Bar | Baz>' is not assignable to type 'IteratorYieldResult<Foo>'.
-                    Type 'Bar | Baz' is not assignable to type 'Foo'.
-                      Property 'x' is missing in type 'Baz' but required in type 'Foo'.
+  Call signature return types 'Generator<Bar | Baz, void, undefined>' and 'Iterable<Foo>' are incompatible.
+    The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types.
+      Type 'IteratorResult<Bar | Baz, void>' is not assignable to type 'IteratorResult<Foo, any>'.
+        Type 'IteratorYieldResult<Bar | Baz>' is not assignable to type 'IteratorResult<Foo, any>'.
+          Type 'IteratorYieldResult<Bar | Baz>' is not assignable to type 'IteratorYieldResult<Foo>'.
+            Type 'Bar | Baz' is not assignable to type 'Foo'.
+              Property 'x' is missing in type 'Baz' but required in type 'Foo'.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck25.ts (1 errors) ====
@@ -19,17 +15,13 @@ tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck25.ts(4,5): error
     var g3: () => Iterable<Foo> = function* () {
         ~~
 !!! error TS2322: Type '() => Generator<Bar | Baz, void, undefined>' is not assignable to type '() => Iterable<Foo>'.
-!!! error TS2322:   Type 'Generator<Bar | Baz, void, undefined>' is not assignable to type 'Iterable<Foo>'.
-!!! error TS2322:     Types of property '[Symbol.iterator]' are incompatible.
-!!! error TS2322:       Type '() => Generator<Bar | Baz, void, undefined>' is not assignable to type '() => Iterator<Foo, any, undefined>'.
-!!! error TS2322:         Type 'Generator<Bar | Baz, void, undefined>' is not assignable to type 'Iterator<Foo, any, undefined>'.
-!!! error TS2322:           Types of property 'next' are incompatible.
-!!! error TS2322:             Type '(...args: [] | [undefined]) => IteratorResult<Bar | Baz, void>' is not assignable to type '(...args: [] | [undefined]) => IteratorResult<Foo, any>'.
-!!! error TS2322:               Type 'IteratorResult<Bar | Baz, void>' is not assignable to type 'IteratorResult<Foo, any>'.
-!!! error TS2322:                 Type 'IteratorYieldResult<Bar | Baz>' is not assignable to type 'IteratorResult<Foo, any>'.
-!!! error TS2322:                   Type 'IteratorYieldResult<Bar | Baz>' is not assignable to type 'IteratorYieldResult<Foo>'.
-!!! error TS2322:                     Type 'Bar | Baz' is not assignable to type 'Foo'.
-!!! error TS2322:                       Property 'x' is missing in type 'Baz' but required in type 'Foo'.
+!!! error TS2322:   Call signature return types 'Generator<Bar | Baz, void, undefined>' and 'Iterable<Foo>' are incompatible.
+!!! error TS2322:     The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types.
+!!! error TS2322:       Type 'IteratorResult<Bar | Baz, void>' is not assignable to type 'IteratorResult<Foo, any>'.
+!!! error TS2322:         Type 'IteratorYieldResult<Bar | Baz>' is not assignable to type 'IteratorResult<Foo, any>'.
+!!! error TS2322:           Type 'IteratorYieldResult<Bar | Baz>' is not assignable to type 'IteratorYieldResult<Foo>'.
+!!! error TS2322:             Type 'Bar | Baz' is not assignable to type 'Foo'.
+!!! error TS2322:               Property 'x' is missing in type 'Baz' but required in type 'Foo'.
 !!! related TS2728 tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck25.ts:1:13: 'x' is declared here.
         yield;
         yield new Bar;
diff --git a/tests/baselines/reference/generatorTypeCheck63.errors.txt b/tests/baselines/reference/generatorTypeCheck63.errors.txt
index 60dfb089822..10cafbe0ced 100644
--- a/tests/baselines/reference/generatorTypeCheck63.errors.txt
+++ b/tests/baselines/reference/generatorTypeCheck63.errors.txt
@@ -1,11 +1,10 @@
 tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck63.ts(24,61): error TS2345: Argument of type '(state: State) => Generator<number, State, undefined>' is not assignable to parameter of type '(a: State) => IterableIterator<State>'.
-  Type 'Generator<number, State, undefined>' is not assignable to type 'IterableIterator<State>'.
-    Types of property 'next' are incompatible.
-      Type '(...args: [] | [undefined]) => IteratorResult<number, State>' is not assignable to type '(...args: [] | [undefined]) => IteratorResult<State, any>'.
-        Type 'IteratorResult<number, State>' is not assignable to type 'IteratorResult<State, any>'.
-          Type 'IteratorYieldResult<number>' is not assignable to type 'IteratorResult<State, any>'.
-            Type 'IteratorYieldResult<number>' is not assignable to type 'IteratorYieldResult<State>'.
-              Type 'number' is not assignable to type 'State'.
+  Call signature return types 'Generator<number, State, undefined>' and 'IterableIterator<State>' are incompatible.
+    The types returned by 'next(...)' are incompatible between these types.
+      Type 'IteratorResult<number, State>' is not assignable to type 'IteratorResult<State, any>'.
+        Type 'IteratorYieldResult<number>' is not assignable to type 'IteratorResult<State, any>'.
+          Type 'IteratorYieldResult<number>' is not assignable to type 'IteratorYieldResult<State>'.
+            Type 'number' is not assignable to type 'State'.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck63.ts (1 errors) ====
@@ -35,13 +34,12 @@ tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck63.ts(24,61): err
     export const Nothing: Strategy<State> = strategy("Nothing", function* (state: State) {
                                                                 ~~~~~~~~
 !!! error TS2345: Argument of type '(state: State) => Generator<number, State, undefined>' is not assignable to parameter of type '(a: State) => IterableIterator<State>'.
-!!! error TS2345:   Type 'Generator<number, State, undefined>' is not assignable to type 'IterableIterator<State>'.
-!!! error TS2345:     Types of property 'next' are incompatible.
-!!! error TS2345:       Type '(...args: [] | [undefined]) => IteratorResult<number, State>' is not assignable to type '(...args: [] | [undefined]) => IteratorResult<State, any>'.
-!!! error TS2345:         Type 'IteratorResult<number, State>' is not assignable to type 'IteratorResult<State, any>'.
-!!! error TS2345:           Type 'IteratorYieldResult<number>' is not assignable to type 'IteratorResult<State, any>'.
-!!! error TS2345:             Type 'IteratorYieldResult<number>' is not assignable to type 'IteratorYieldResult<State>'.
-!!! error TS2345:               Type 'number' is not assignable to type 'State'.
+!!! error TS2345:   Call signature return types 'Generator<number, State, undefined>' and 'IterableIterator<State>' are incompatible.
+!!! error TS2345:     The types returned by 'next(...)' are incompatible between these types.
+!!! error TS2345:       Type 'IteratorResult<number, State>' is not assignable to type 'IteratorResult<State, any>'.
+!!! error TS2345:         Type 'IteratorYieldResult<number>' is not assignable to type 'IteratorResult<State, any>'.
+!!! error TS2345:           Type 'IteratorYieldResult<number>' is not assignable to type 'IteratorYieldResult<State>'.
+!!! error TS2345:             Type 'number' is not assignable to type 'State'.
         yield 1;
         return state;
     });
diff --git a/tests/baselines/reference/generatorTypeCheck8.errors.txt b/tests/baselines/reference/generatorTypeCheck8.errors.txt
index 6261d419ddd..ca0b1e30366 100644
--- a/tests/baselines/reference/generatorTypeCheck8.errors.txt
+++ b/tests/baselines/reference/generatorTypeCheck8.errors.txt
@@ -1,10 +1,9 @@
 tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck8.ts(2,17): error TS2322: Type 'Generator<string, any, undefined>' is not assignable to type 'BadGenerator'.
-  Types of property 'next' are incompatible.
-    Type '(...args: [] | [undefined]) => IteratorResult<string, any>' is not assignable to type '(...args: [] | [undefined]) => IteratorResult<number, any>'.
-      Type 'IteratorResult<string, any>' is not assignable to type 'IteratorResult<number, any>'.
-        Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorResult<number, any>'.
-          Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorYieldResult<number>'.
-            Type 'string' is not assignable to type 'number'.
+  The types returned by 'next(...)' are incompatible between these types.
+    Type 'IteratorResult<string, any>' is not assignable to type 'IteratorResult<number, any>'.
+      Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorResult<number, any>'.
+        Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorYieldResult<number>'.
+          Type 'string' is not assignable to type 'number'.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck8.ts (1 errors) ====
@@ -12,9 +11,8 @@ tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck8.ts(2,17): error
     function* g3(): BadGenerator { }
                     ~~~~~~~~~~~~
 !!! error TS2322: Type 'Generator<string, any, undefined>' is not assignable to type 'BadGenerator'.
-!!! error TS2322:   Types of property 'next' are incompatible.
-!!! error TS2322:     Type '(...args: [] | [undefined]) => IteratorResult<string, any>' is not assignable to type '(...args: [] | [undefined]) => IteratorResult<number, any>'.
-!!! error TS2322:       Type 'IteratorResult<string, any>' is not assignable to type 'IteratorResult<number, any>'.
-!!! error TS2322:         Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorResult<number, any>'.
-!!! error TS2322:           Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorYieldResult<number>'.
-!!! error TS2322:             Type 'string' is not assignable to type 'number'.
\ No newline at end of file
+!!! error TS2322:   The types returned by 'next(...)' are incompatible between these types.
+!!! error TS2322:     Type 'IteratorResult<string, any>' is not assignable to type 'IteratorResult<number, any>'.
+!!! error TS2322:       Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorResult<number, any>'.
+!!! error TS2322:         Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorYieldResult<number>'.
+!!! error TS2322:           Type 'string' is not assignable to type 'number'.
\ No newline at end of file
diff --git a/tests/baselines/reference/generics4.errors.txt b/tests/baselines/reference/generics4.errors.txt
index 06bfa122901..6181685983e 100644
--- a/tests/baselines/reference/generics4.errors.txt
+++ b/tests/baselines/reference/generics4.errors.txt
@@ -1,8 +1,7 @@
 tests/cases/compiler/generics4.ts(7,1): error TS2322: Type 'C<Y>' is not assignable to type 'C<X>'.
   Type 'Y' is not assignable to type 'X'.
-    Types of property 'f' are incompatible.
-      Type '() => boolean' is not assignable to type '() => string'.
-        Type 'boolean' is not assignable to type 'string'.
+    The types returned by 'f()' are incompatible between these types.
+      Type 'boolean' is not assignable to type 'string'.
 
 
 ==== tests/cases/compiler/generics4.ts (1 errors) ====
@@ -16,6 +15,5 @@ tests/cases/compiler/generics4.ts(7,1): error TS2322: Type 'C<Y>' is not assigna
     ~
 !!! error TS2322: Type 'C<Y>' is not assignable to type 'C<X>'.
 !!! error TS2322:   Type 'Y' is not assignable to type 'X'.
-!!! error TS2322:     Types of property 'f' are incompatible.
-!!! error TS2322:       Type '() => boolean' is not assignable to type '() => string'.
-!!! error TS2322:         Type 'boolean' is not assignable to type 'string'.
\ No newline at end of file
+!!! error TS2322:     The types returned by 'f()' are incompatible between these types.
+!!! error TS2322:       Type 'boolean' is not assignable to type 'string'.
\ No newline at end of file
diff --git a/tests/baselines/reference/incompatibleTypes.errors.txt b/tests/baselines/reference/incompatibleTypes.errors.txt
index 0b5e587ad53..66d94bea79c 100644
--- a/tests/baselines/reference/incompatibleTypes.errors.txt
+++ b/tests/baselines/reference/incompatibleTypes.errors.txt
@@ -12,14 +12,12 @@ tests/cases/compiler/incompatibleTypes.ts(34,12): error TS2416: Property 'p1' in
 tests/cases/compiler/incompatibleTypes.ts(42,5): error TS2769: No overload matches this call.
   Overload 1 of 2, '(i: IFoo1): void', gave the following error.
     Argument of type 'C1' is not assignable to parameter of type 'IFoo1'.
-      Types of property 'p1' are incompatible.
-        Type '() => string' is not assignable to type '() => number'.
-          Type 'string' is not assignable to type 'number'.
+      The types returned by 'p1()' are incompatible between these types.
+        Type 'string' is not assignable to type 'number'.
   Overload 2 of 2, '(i: IFoo2): void', gave the following error.
     Argument of type 'C1' is not assignable to parameter of type 'IFoo2'.
-      Types of property 'p1' are incompatible.
-        Type '() => string' is not assignable to type '(s: string) => number'.
-          Type 'string' is not assignable to type 'number'.
+      The types returned by 'p1(...)' are incompatible between these types.
+        Type 'string' is not assignable to type 'number'.
 tests/cases/compiler/incompatibleTypes.ts(49,7): error TS2769: No overload matches this call.
   Overload 1 of 2, '(n: { a: { a: string; }; b: string; }): number', gave the following error.
     Argument of type '{ e: number; f: number; }' is not assignable to parameter of type '{ a: { a: string; }; b: string; }'.
@@ -95,14 +93,12 @@ tests/cases/compiler/incompatibleTypes.ts(74,5): error TS2322: Type '(a: any) =>
 !!! error TS2769: No overload matches this call.
 !!! error TS2769:   Overload 1 of 2, '(i: IFoo1): void', gave the following error.
 !!! error TS2769:     Argument of type 'C1' is not assignable to parameter of type 'IFoo1'.
-!!! error TS2769:       Types of property 'p1' are incompatible.
-!!! error TS2769:         Type '() => string' is not assignable to type '() => number'.
-!!! error TS2769:           Type 'string' is not assignable to type 'number'.
+!!! error TS2769:       The types returned by 'p1()' are incompatible between these types.
+!!! error TS2769:         Type 'string' is not assignable to type 'number'.
 !!! error TS2769:   Overload 2 of 2, '(i: IFoo2): void', gave the following error.
 !!! error TS2769:     Argument of type 'C1' is not assignable to parameter of type 'IFoo2'.
-!!! error TS2769:       Types of property 'p1' are incompatible.
-!!! error TS2769:         Type '() => string' is not assignable to type '(s: string) => number'.
-!!! error TS2769:           Type 'string' is not assignable to type 'number'.
+!!! error TS2769:       The types returned by 'p1(...)' are incompatible between these types.
+!!! error TS2769:         Type 'string' is not assignable to type 'number'.
     
     
     function of1(n: { a: { a: string; }; b: string; }): number;
diff --git a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types
index 4c56070fd3c..f9192dd11ba 100644
--- a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types
+++ b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types
@@ -413,9 +413,9 @@ const f1: F = () => {
 
     return Promise.all([
 >Promise.all([        {            name: "David Gomes",            age: 23,            position: "GOALKEEPER",        }, {            name: "Cristiano Ronaldo",            age: 33,            position: "STRIKER",        }    ]) : Promise<[{ name: string; age: number; position: "GOALKEEPER"; }, { name: string; age: number; position: "STRIKER"; }]>
->Promise.all : { <TAll>(values: Iterable<TAll | PromiseLike<TAll>>): Promise<TAll[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>, T10 | PromiseLike<T10>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>]): Promise<[T1, T2, T3, T4, T5, T6, T7]>; <T1, T2, T3, T4, T5, T6>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[T1, T2, T3, T4, T5, T6]>; <T1, T2, T3, T4, T5>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>]): Promise<[T1, T2, T3, T4, T5]>; <T1, T2, T3, T4>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[T1, T2, T3, T4]>; <T1, T2, T3>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>; <T1, T2>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>; <T>(values: (T | PromiseLike<T>)[]): Promise<T[]>; }
+>Promise.all : { <TAll>(values: Iterable<TAll | PromiseLike<TAll>>): Promise<TAll[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>, T10 | PromiseLike<T10>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>]): Promise<[T1, T2, T3, T4, T5, T6, T7]>; <T1, T2, T3, T4, T5, T6>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[T1, T2, T3, T4, T5, T6]>; <T1, T2, T3, T4, T5>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>]): Promise<[T1, T2, T3, T4, T5]>; <T1, T2, T3, T4>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[T1, T2, T3, T4]>; <T1, T2, T3>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>; <T1, T2>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>; <T>(values: readonly (T | PromiseLike<T>)[]): Promise<T[]>; }
 >Promise : PromiseConstructor
->all : { <TAll>(values: Iterable<TAll | PromiseLike<TAll>>): Promise<TAll[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>, T10 | PromiseLike<T10>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>]): Promise<[T1, T2, T3, T4, T5, T6, T7]>; <T1, T2, T3, T4, T5, T6>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[T1, T2, T3, T4, T5, T6]>; <T1, T2, T3, T4, T5>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>]): Promise<[T1, T2, T3, T4, T5]>; <T1, T2, T3, T4>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[T1, T2, T3, T4]>; <T1, T2, T3>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>; <T1, T2>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>; <T>(values: (T | PromiseLike<T>)[]): Promise<T[]>; }
+>all : { <TAll>(values: Iterable<TAll | PromiseLike<TAll>>): Promise<TAll[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>, T10 | PromiseLike<T10>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>]): Promise<[T1, T2, T3, T4, T5, T6, T7]>; <T1, T2, T3, T4, T5, T6>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[T1, T2, T3, T4, T5, T6]>; <T1, T2, T3, T4, T5>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>]): Promise<[T1, T2, T3, T4, T5]>; <T1, T2, T3, T4>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[T1, T2, T3, T4]>; <T1, T2, T3>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>; <T1, T2>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>; <T>(values: readonly (T | PromiseLike<T>)[]): Promise<T[]>; }
 >[        {            name: "David Gomes",            age: 23,            position: "GOALKEEPER",        }, {            name: "Cristiano Ronaldo",            age: 33,            position: "STRIKER",        }    ] : [{ name: string; age: number; position: "GOALKEEPER"; }, { name: string; age: number; position: "STRIKER"; }]
         {
 >{            name: "David Gomes",            age: 23,            position: "GOALKEEPER",        } : { name: string; age: number; position: "GOALKEEPER"; }
diff --git a/tests/baselines/reference/inferenceLimit.types b/tests/baselines/reference/inferenceLimit.types
index 6aa7ab501ea..fc2836e6dea 100644
--- a/tests/baselines/reference/inferenceLimit.types
+++ b/tests/baselines/reference/inferenceLimit.types
@@ -76,9 +76,9 @@ export class BrokenClass {
 >Promise.all(result.map(populateItems))      .then((orders: Array<MyModule.MyModel>) => {        resolve(orders);      }) : Promise<void>
 >Promise.all(result.map(populateItems))      .then : <TResult1 = unknown[], TResult2 = never>(onfulfilled?: (value: unknown[]) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >Promise.all(result.map(populateItems)) : Promise<unknown[]>
->Promise.all : { <TAll>(values: Iterable<TAll | PromiseLike<TAll>>): Promise<TAll[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>, T10 | PromiseLike<T10>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>]): Promise<[T1, T2, T3, T4, T5, T6, T7]>; <T1, T2, T3, T4, T5, T6>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[T1, T2, T3, T4, T5, T6]>; <T1, T2, T3, T4, T5>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>]): Promise<[T1, T2, T3, T4, T5]>; <T1, T2, T3, T4>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[T1, T2, T3, T4]>; <T1, T2, T3>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>; <T1, T2>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>; <T>(values: (T | PromiseLike<T>)[]): Promise<T[]>; }
+>Promise.all : { <TAll>(values: Iterable<TAll | PromiseLike<TAll>>): Promise<TAll[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>, T10 | PromiseLike<T10>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>]): Promise<[T1, T2, T3, T4, T5, T6, T7]>; <T1, T2, T3, T4, T5, T6>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[T1, T2, T3, T4, T5, T6]>; <T1, T2, T3, T4, T5>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>]): Promise<[T1, T2, T3, T4, T5]>; <T1, T2, T3, T4>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[T1, T2, T3, T4]>; <T1, T2, T3>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>; <T1, T2>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>; <T>(values: readonly (T | PromiseLike<T>)[]): Promise<T[]>; }
 >Promise : PromiseConstructor
->all : { <TAll>(values: Iterable<TAll | PromiseLike<TAll>>): Promise<TAll[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>, T10 | PromiseLike<T10>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>]): Promise<[T1, T2, T3, T4, T5, T6, T7]>; <T1, T2, T3, T4, T5, T6>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[T1, T2, T3, T4, T5, T6]>; <T1, T2, T3, T4, T5>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>]): Promise<[T1, T2, T3, T4, T5]>; <T1, T2, T3, T4>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[T1, T2, T3, T4]>; <T1, T2, T3>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>; <T1, T2>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>; <T>(values: (T | PromiseLike<T>)[]): Promise<T[]>; }
+>all : { <TAll>(values: Iterable<TAll | PromiseLike<TAll>>): Promise<TAll[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>, T10 | PromiseLike<T10>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>]): Promise<[T1, T2, T3, T4, T5, T6, T7]>; <T1, T2, T3, T4, T5, T6>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[T1, T2, T3, T4, T5, T6]>; <T1, T2, T3, T4, T5>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>]): Promise<[T1, T2, T3, T4, T5]>; <T1, T2, T3, T4>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[T1, T2, T3, T4]>; <T1, T2, T3>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>; <T1, T2>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>; <T>(values: readonly (T | PromiseLike<T>)[]): Promise<T[]>; }
 >result.map(populateItems) : Promise<unknown>[]
 >result.map : <U>(callbackfn: (value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg?: any) => U[]
 >result : MyModule.MyModel[]
diff --git a/tests/baselines/reference/inheritedModuleMembersForClodule.errors.txt b/tests/baselines/reference/inheritedModuleMembersForClodule.errors.txt
index 0b7e00d95ce..e2b744d5a25 100644
--- a/tests/baselines/reference/inheritedModuleMembersForClodule.errors.txt
+++ b/tests/baselines/reference/inheritedModuleMembersForClodule.errors.txt
@@ -1,7 +1,6 @@
 tests/cases/compiler/inheritedModuleMembersForClodule.ts(7,7): error TS2417: Class static side 'typeof D' incorrectly extends base class static side 'typeof C'.
-  Types of property 'foo' are incompatible.
-    Type '() => number' is not assignable to type '() => string'.
-      Type 'number' is not assignable to type 'string'.
+  The types returned by 'foo()' are incompatible between these types.
+    Type 'number' is not assignable to type 'string'.
 
 
 ==== tests/cases/compiler/inheritedModuleMembersForClodule.ts (1 errors) ====
@@ -14,9 +13,8 @@ tests/cases/compiler/inheritedModuleMembersForClodule.ts(7,7): error TS2417: Cla
     class D extends C {
           ~
 !!! error TS2417: Class static side 'typeof D' incorrectly extends base class static side 'typeof C'.
-!!! error TS2417:   Types of property 'foo' are incompatible.
-!!! error TS2417:     Type '() => number' is not assignable to type '() => string'.
-!!! error TS2417:       Type 'number' is not assignable to type 'string'.
+!!! error TS2417:   The types returned by 'foo()' are incompatible between these types.
+!!! error TS2417:     Type 'number' is not assignable to type 'string'.
     }
     
     module D {
diff --git a/tests/baselines/reference/interfaceThatHidesBaseProperty2.errors.txt b/tests/baselines/reference/interfaceThatHidesBaseProperty2.errors.txt
index f66e13c0d9d..779a160c5a6 100644
--- a/tests/baselines/reference/interfaceThatHidesBaseProperty2.errors.txt
+++ b/tests/baselines/reference/interfaceThatHidesBaseProperty2.errors.txt
@@ -1,8 +1,6 @@
 tests/cases/conformance/interfaces/interfaceDeclarations/interfaceThatHidesBaseProperty2.ts(5,11): error TS2430: Interface 'Derived' incorrectly extends interface 'Base'.
-  Types of property 'x' are incompatible.
-    Type '{ a: string; }' is not assignable to type '{ a: number; }'.
-      Types of property 'a' are incompatible.
-        Type 'string' is not assignable to type 'number'.
+  The types of 'x.a' are incompatible between these types.
+    Type 'string' is not assignable to type 'number'.
 
 
 ==== tests/cases/conformance/interfaces/interfaceDeclarations/interfaceThatHidesBaseProperty2.ts (1 errors) ====
@@ -13,10 +11,8 @@ tests/cases/conformance/interfaces/interfaceDeclarations/interfaceThatHidesBaseP
     interface Derived extends Base { // error
               ~~~~~~~
 !!! error TS2430: Interface 'Derived' incorrectly extends interface 'Base'.
-!!! error TS2430:   Types of property 'x' are incompatible.
-!!! error TS2430:     Type '{ a: string; }' is not assignable to type '{ a: number; }'.
-!!! error TS2430:       Types of property 'a' are incompatible.
-!!! error TS2430:         Type 'string' is not assignable to type 'number'.
+!!! error TS2430:   The types of 'x.a' are incompatible between these types.
+!!! error TS2430:     Type 'string' is not assignable to type 'number'.
         x: {
             a: string;
         };
diff --git a/tests/baselines/reference/interfaceWithMultipleBaseTypes.errors.txt b/tests/baselines/reference/interfaceWithMultipleBaseTypes.errors.txt
index 138f3d92096..c885a7859d4 100644
--- a/tests/baselines/reference/interfaceWithMultipleBaseTypes.errors.txt
+++ b/tests/baselines/reference/interfaceWithMultipleBaseTypes.errors.txt
@@ -1,20 +1,14 @@
 tests/cases/conformance/interfaces/interfaceDeclarations/interfaceWithMultipleBaseTypes.ts(21,11): error TS2430: Interface 'Derived2' incorrectly extends interface 'Base2'.
-  Types of property 'x' are incompatible.
-    Type '{ a: string; b: number; }' is not assignable to type '{ b: string; }'.
-      Types of property 'b' are incompatible.
-        Type 'number' is not assignable to type 'string'.
+  The types of 'x.b' are incompatible between these types.
+    Type 'number' is not assignable to type 'string'.
 tests/cases/conformance/interfaces/interfaceDeclarations/interfaceWithMultipleBaseTypes.ts(52,15): error TS2320: Interface 'Derived3<T>' cannot simultaneously extend types 'Base1<number>' and 'Base2<number>'.
   Named property 'x' of types 'Base1<number>' and 'Base2<number>' are not identical.
 tests/cases/conformance/interfaces/interfaceDeclarations/interfaceWithMultipleBaseTypes.ts(54,15): error TS2430: Interface 'Derived4<T>' incorrectly extends interface 'Base1<number>'.
-  Types of property 'x' are incompatible.
-    Type '{ a: T; b: T; }' is not assignable to type '{ a: number; }'.
-      Types of property 'a' are incompatible.
-        Type 'T' is not assignable to type 'number'.
+  The types of 'x.a' are incompatible between these types.
+    Type 'T' is not assignable to type 'number'.
 tests/cases/conformance/interfaces/interfaceDeclarations/interfaceWithMultipleBaseTypes.ts(54,15): error TS2430: Interface 'Derived4<T>' incorrectly extends interface 'Base2<number>'.
-  Types of property 'x' are incompatible.
-    Type '{ a: T; b: T; }' is not assignable to type '{ b: number; }'.
-      Types of property 'b' are incompatible.
-        Type 'T' is not assignable to type 'number'.
+  The types of 'x.b' are incompatible between these types.
+    Type 'T' is not assignable to type 'number'.
 tests/cases/conformance/interfaces/interfaceDeclarations/interfaceWithMultipleBaseTypes.ts(60,15): error TS2430: Interface 'Derived5<T>' incorrectly extends interface 'Base1<T>'.
   Types of property 'x' are incompatible.
     Type 'T' is not assignable to type '{ a: T; }'.
@@ -47,10 +41,8 @@ tests/cases/conformance/interfaces/interfaceDeclarations/interfaceWithMultipleBa
     interface Derived2 extends Base1, Base2 { // error
               ~~~~~~~~
 !!! error TS2430: Interface 'Derived2' incorrectly extends interface 'Base2'.
-!!! error TS2430:   Types of property 'x' are incompatible.
-!!! error TS2430:     Type '{ a: string; b: number; }' is not assignable to type '{ b: string; }'.
-!!! error TS2430:       Types of property 'b' are incompatible.
-!!! error TS2430:         Type 'number' is not assignable to type 'string'.
+!!! error TS2430:   The types of 'x.b' are incompatible between these types.
+!!! error TS2430:     Type 'number' is not assignable to type 'string'.
         x: {
             a: string; b: number;
         }
@@ -89,16 +81,12 @@ tests/cases/conformance/interfaces/interfaceDeclarations/interfaceWithMultipleBa
         interface Derived4<T> extends Base1<number>, Base2<number> { // error
                   ~~~~~~~~
 !!! error TS2430: Interface 'Derived4<T>' incorrectly extends interface 'Base1<number>'.
-!!! error TS2430:   Types of property 'x' are incompatible.
-!!! error TS2430:     Type '{ a: T; b: T; }' is not assignable to type '{ a: number; }'.
-!!! error TS2430:       Types of property 'a' are incompatible.
-!!! error TS2430:         Type 'T' is not assignable to type 'number'.
+!!! error TS2430:   The types of 'x.a' are incompatible between these types.
+!!! error TS2430:     Type 'T' is not assignable to type 'number'.
                   ~~~~~~~~
 !!! error TS2430: Interface 'Derived4<T>' incorrectly extends interface 'Base2<number>'.
-!!! error TS2430:   Types of property 'x' are incompatible.
-!!! error TS2430:     Type '{ a: T; b: T; }' is not assignable to type '{ b: number; }'.
-!!! error TS2430:       Types of property 'b' are incompatible.
-!!! error TS2430:         Type 'T' is not assignable to type 'number'.
+!!! error TS2430:   The types of 'x.b' are incompatible between these types.
+!!! error TS2430:     Type 'T' is not assignable to type 'number'.
             x: {
                 a: T; b: T;
             }
diff --git a/tests/baselines/reference/interfaceWithMultipleBaseTypes2.errors.txt b/tests/baselines/reference/interfaceWithMultipleBaseTypes2.errors.txt
index b3459233923..9b7b2eff8ec 100644
--- a/tests/baselines/reference/interfaceWithMultipleBaseTypes2.errors.txt
+++ b/tests/baselines/reference/interfaceWithMultipleBaseTypes2.errors.txt
@@ -1,8 +1,6 @@
 tests/cases/conformance/interfaces/interfaceDeclarations/interfaceWithMultipleBaseTypes2.ts(17,11): error TS2430: Interface 'Derived2' incorrectly extends interface 'Base'.
-  Types of property 'x' are incompatible.
-    Type '{ a: number; b: string; }' is not assignable to type '{ a?: string; b: string; }'.
-      Types of property 'a' are incompatible.
-        Type 'number' is not assignable to type 'string'.
+  The types of 'x.a' are incompatible between these types.
+    Type 'number' is not assignable to type 'string'.
 
 
 ==== tests/cases/conformance/interfaces/interfaceDeclarations/interfaceWithMultipleBaseTypes2.ts (1 errors) ====
@@ -25,10 +23,8 @@ tests/cases/conformance/interfaces/interfaceDeclarations/interfaceWithMultipleBa
     interface Derived2 extends Base, Base2 { // error
               ~~~~~~~~
 !!! error TS2430: Interface 'Derived2' incorrectly extends interface 'Base'.
-!!! error TS2430:   Types of property 'x' are incompatible.
-!!! error TS2430:     Type '{ a: number; b: string; }' is not assignable to type '{ a?: string; b: string; }'.
-!!! error TS2430:       Types of property 'a' are incompatible.
-!!! error TS2430:         Type 'number' is not assignable to type 'string'.
+!!! error TS2430:   The types of 'x.a' are incompatible between these types.
+!!! error TS2430:     Type 'number' is not assignable to type 'string'.
         x: { a: number; b: string }
     }
     
diff --git a/tests/baselines/reference/intersectionWithUnionConstraint.errors.txt b/tests/baselines/reference/intersectionWithUnionConstraint.errors.txt
index 97ed1cf4895..7bc436915a1 100644
--- a/tests/baselines/reference/intersectionWithUnionConstraint.errors.txt
+++ b/tests/baselines/reference/intersectionWithUnionConstraint.errors.txt
@@ -1,23 +1,13 @@
 tests/cases/conformance/types/intersection/intersectionWithUnionConstraint.ts(7,9): error TS2322: Type 'T & U' is not assignable to type 'string | number'.
-  Type 'string | undefined' is not assignable to type 'string | number'.
-    Type 'undefined' is not assignable to type 'string | number'.
-      Type 'T & U' is not assignable to type 'number'.
+  Type 'T & U' is not assignable to type 'number'.
 tests/cases/conformance/types/intersection/intersectionWithUnionConstraint.ts(8,9): error TS2322: Type 'T & U' is not assignable to type 'string | null'.
-  Type 'string | undefined' is not assignable to type 'string | null'.
-    Type 'undefined' is not assignable to type 'string | null'.
-      Type 'T & U' is not assignable to type 'string'.
+  Type 'T & U' is not assignable to type 'string'.
 tests/cases/conformance/types/intersection/intersectionWithUnionConstraint.ts(10,9): error TS2322: Type 'T & U' is not assignable to type 'number | null'.
-  Type 'string | undefined' is not assignable to type 'number | null'.
-    Type 'undefined' is not assignable to type 'number | null'.
-      Type 'T & U' is not assignable to type 'number'.
+  Type 'T & U' is not assignable to type 'number'.
 tests/cases/conformance/types/intersection/intersectionWithUnionConstraint.ts(11,9): error TS2322: Type 'T & U' is not assignable to type 'number | undefined'.
-  Type 'string | undefined' is not assignable to type 'number | undefined'.
-    Type 'string' is not assignable to type 'number | undefined'.
-      Type 'T & U' is not assignable to type 'number'.
+  Type 'T & U' is not assignable to type 'number'.
 tests/cases/conformance/types/intersection/intersectionWithUnionConstraint.ts(12,9): error TS2322: Type 'T & U' is not assignable to type 'null | undefined'.
-  Type 'string | undefined' is not assignable to type 'null | undefined'.
-    Type 'string' is not assignable to type 'null | undefined'.
-      Type 'T & U' is not assignable to type 'null'.
+  Type 'T & U' is not assignable to type 'null'.
 
 
 ==== tests/cases/conformance/types/intersection/intersectionWithUnionConstraint.ts (5 errors) ====
@@ -30,34 +20,24 @@ tests/cases/conformance/types/intersection/intersectionWithUnionConstraint.ts(12
         let y1: string | number = x;     // Error
             ~~
 !!! error TS2322: Type 'T & U' is not assignable to type 'string | number'.
-!!! error TS2322:   Type 'string | undefined' is not assignable to type 'string | number'.
-!!! error TS2322:     Type 'undefined' is not assignable to type 'string | number'.
-!!! error TS2322:       Type 'T & U' is not assignable to type 'number'.
+!!! error TS2322:   Type 'T & U' is not assignable to type 'number'.
         let y2: string | null = x;       // Error
             ~~
 !!! error TS2322: Type 'T & U' is not assignable to type 'string | null'.
-!!! error TS2322:   Type 'string | undefined' is not assignable to type 'string | null'.
-!!! error TS2322:     Type 'undefined' is not assignable to type 'string | null'.
-!!! error TS2322:       Type 'T & U' is not assignable to type 'string'.
+!!! error TS2322:   Type 'T & U' is not assignable to type 'string'.
         let y3: string | undefined = x;
         let y4: number | null = x;       // Error
             ~~
 !!! error TS2322: Type 'T & U' is not assignable to type 'number | null'.
-!!! error TS2322:   Type 'string | undefined' is not assignable to type 'number | null'.
-!!! error TS2322:     Type 'undefined' is not assignable to type 'number | null'.
-!!! error TS2322:       Type 'T & U' is not assignable to type 'number'.
+!!! error TS2322:   Type 'T & U' is not assignable to type 'number'.
         let y5: number | undefined = x;  // Error
             ~~
 !!! error TS2322: Type 'T & U' is not assignable to type 'number | undefined'.
-!!! error TS2322:   Type 'string | undefined' is not assignable to type 'number | undefined'.
-!!! error TS2322:     Type 'string' is not assignable to type 'number | undefined'.
-!!! error TS2322:       Type 'T & U' is not assignable to type 'number'.
+!!! error TS2322:   Type 'T & U' is not assignable to type 'number'.
         let y6: null | undefined = x;    // Error
             ~~
 !!! error TS2322: Type 'T & U' is not assignable to type 'null | undefined'.
-!!! error TS2322:   Type 'string | undefined' is not assignable to type 'null | undefined'.
-!!! error TS2322:     Type 'string' is not assignable to type 'null | undefined'.
-!!! error TS2322:       Type 'T & U' is not assignable to type 'null'.
+!!! error TS2322:   Type 'T & U' is not assignable to type 'null'.
     }
     
     type T1 = (string | number | undefined) & (string | null | undefined);  // string | undefined
diff --git a/tests/baselines/reference/invariantGenericErrorElaboration.errors.txt b/tests/baselines/reference/invariantGenericErrorElaboration.errors.txt
index 0bd79bcf11d..7ab83c61bcd 100644
--- a/tests/baselines/reference/invariantGenericErrorElaboration.errors.txt
+++ b/tests/baselines/reference/invariantGenericErrorElaboration.errors.txt
@@ -1,13 +1,7 @@
 tests/cases/compiler/invariantGenericErrorElaboration.ts(3,7): error TS2322: Type 'Num' is not assignable to type 'Runtype<any>'.
-  Types of property 'constraint' are incompatible.
-    Type 'Constraint<Num>' is not assignable to type 'Constraint<Runtype<any>>'.
-      Types of property 'constraint' are incompatible.
-        Type 'Constraint<Constraint<Num>>' is not assignable to type 'Constraint<Constraint<Runtype<any>>>'.
-          Types of property 'constraint' are incompatible.
-            Type 'Constraint<Constraint<Constraint<Num>>>' is not assignable to type 'Constraint<Constraint<Constraint<Runtype<any>>>>'.
-              Type 'Constraint<Constraint<Runtype<any>>>' is not assignable to type 'Constraint<Constraint<Num>>'.
-                Types of property 'underlying' are incompatible.
-                  Type 'Constraint<Runtype<any>>' is not assignable to type 'Constraint<Num>'.
+  The types of 'constraint.constraint.constraint' are incompatible between these types.
+    Type 'Constraint<Constraint<Constraint<Num>>>' is not assignable to type 'Constraint<Constraint<Constraint<Runtype<any>>>>'.
+      Type 'Constraint<Runtype<any>>' is not assignable to type 'Constraint<Num>'.
 tests/cases/compiler/invariantGenericErrorElaboration.ts(4,19): error TS2322: Type 'Num' is not assignable to type 'Runtype<any>'.
 
 
@@ -17,16 +11,9 @@ tests/cases/compiler/invariantGenericErrorElaboration.ts(4,19): error TS2322: Ty
     const wat: Runtype<any> = Num;
           ~~~
 !!! error TS2322: Type 'Num' is not assignable to type 'Runtype<any>'.
-!!! error TS2322:   Types of property 'constraint' are incompatible.
-!!! error TS2322:     Type 'Constraint<Num>' is not assignable to type 'Constraint<Runtype<any>>'.
-!!! error TS2322:       Types of property 'constraint' are incompatible.
-!!! error TS2322:         Type 'Constraint<Constraint<Num>>' is not assignable to type 'Constraint<Constraint<Runtype<any>>>'.
-!!! error TS2322:           Types of property 'constraint' are incompatible.
-!!! error TS2322:             Type 'Constraint<Constraint<Constraint<Num>>>' is not assignable to type 'Constraint<Constraint<Constraint<Runtype<any>>>>'.
-!!! error TS2322:               Type 'Constraint<Constraint<Runtype<any>>>' is not assignable to type 'Constraint<Constraint<Num>>'.
-!!! error TS2322:                 Types of property 'underlying' are incompatible.
-!!! error TS2322:                   Type 'Constraint<Runtype<any>>' is not assignable to type 'Constraint<Num>'.
-!!! related TS2728 tests/cases/compiler/invariantGenericErrorElaboration.ts:12:3: 'tag' is declared here.
+!!! error TS2322:   The types of 'constraint.constraint.constraint' are incompatible between these types.
+!!! error TS2322:     Type 'Constraint<Constraint<Constraint<Num>>>' is not assignable to type 'Constraint<Constraint<Constraint<Runtype<any>>>>'.
+!!! error TS2322:       Type 'Constraint<Runtype<any>>' is not assignable to type 'Constraint<Num>'.
     const Foo = Obj({ foo: Num })
                       ~~~
 !!! error TS2322: Type 'Num' is not assignable to type 'Runtype<any>'.
diff --git a/tests/baselines/reference/iterableArrayPattern28.errors.txt b/tests/baselines/reference/iterableArrayPattern28.errors.txt
index 7a1ff6cf42c..605c6feb405 100644
--- a/tests/baselines/reference/iterableArrayPattern28.errors.txt
+++ b/tests/baselines/reference/iterableArrayPattern28.errors.txt
@@ -1,18 +1,14 @@
 tests/cases/conformance/es6/destructuring/iterableArrayPattern28.ts(2,24): error TS2769: No overload matches this call.
   Overload 1 of 3, '(iterable: Iterable<readonly [string, number]>): Map<string, number>', gave the following error.
     Argument of type '([string, number] | [string, boolean])[]' is not assignable to parameter of type 'Iterable<readonly [string, number]>'.
-      Types of property '[Symbol.iterator]' are incompatible.
-        Type '() => IterableIterator<[string, number] | [string, boolean]>' is not assignable to type '() => Iterator<readonly [string, number], any, undefined>'.
-          Type 'IterableIterator<[string, number] | [string, boolean]>' is not assignable to type 'Iterator<readonly [string, number], any, undefined>'.
-            Types of property 'next' are incompatible.
-              Type '(...args: [] | [undefined]) => IteratorResult<[string, number] | [string, boolean], any>' is not assignable to type '(...args: [] | [undefined]) => IteratorResult<readonly [string, number], any>'.
-                Type 'IteratorResult<[string, number] | [string, boolean], any>' is not assignable to type 'IteratorResult<readonly [string, number], any>'.
-                  Type 'IteratorYieldResult<[string, number] | [string, boolean]>' is not assignable to type 'IteratorResult<readonly [string, number], any>'.
-                    Type 'IteratorYieldResult<[string, number] | [string, boolean]>' is not assignable to type 'IteratorYieldResult<readonly [string, number]>'.
-                      Type '[string, number] | [string, boolean]' is not assignable to type 'readonly [string, number]'.
-                        Type '[string, boolean]' is not assignable to type 'readonly [string, number]'.
-                          Types of property '1' are incompatible.
-                            Type 'boolean' is not assignable to type 'number'.
+      The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types.
+        Type 'IteratorResult<[string, number] | [string, boolean], any>' is not assignable to type 'IteratorResult<readonly [string, number], any>'.
+          Type 'IteratorYieldResult<[string, number] | [string, boolean]>' is not assignable to type 'IteratorResult<readonly [string, number], any>'.
+            Type 'IteratorYieldResult<[string, number] | [string, boolean]>' is not assignable to type 'IteratorYieldResult<readonly [string, number]>'.
+              Type '[string, number] | [string, boolean]' is not assignable to type 'readonly [string, number]'.
+                Type '[string, boolean]' is not assignable to type 'readonly [string, number]'.
+                  Types of property '1' are incompatible.
+                    Type 'boolean' is not assignable to type 'number'.
   Overload 2 of 3, '(entries?: readonly (readonly [string, number])[]): Map<string, number>', gave the following error.
     Type 'true' is not assignable to type 'number'.
 
@@ -24,17 +20,13 @@ tests/cases/conformance/es6/destructuring/iterableArrayPattern28.ts(2,24): error
 !!! error TS2769: No overload matches this call.
 !!! error TS2769:   Overload 1 of 3, '(iterable: Iterable<readonly [string, number]>): Map<string, number>', gave the following error.
 !!! error TS2769:     Argument of type '([string, number] | [string, boolean])[]' is not assignable to parameter of type 'Iterable<readonly [string, number]>'.
-!!! error TS2769:       Types of property '[Symbol.iterator]' are incompatible.
-!!! error TS2769:         Type '() => IterableIterator<[string, number] | [string, boolean]>' is not assignable to type '() => Iterator<readonly [string, number], any, undefined>'.
-!!! error TS2769:           Type 'IterableIterator<[string, number] | [string, boolean]>' is not assignable to type 'Iterator<readonly [string, number], any, undefined>'.
-!!! error TS2769:             Types of property 'next' are incompatible.
-!!! error TS2769:               Type '(...args: [] | [undefined]) => IteratorResult<[string, number] | [string, boolean], any>' is not assignable to type '(...args: [] | [undefined]) => IteratorResult<readonly [string, number], any>'.
-!!! error TS2769:                 Type 'IteratorResult<[string, number] | [string, boolean], any>' is not assignable to type 'IteratorResult<readonly [string, number], any>'.
-!!! error TS2769:                   Type 'IteratorYieldResult<[string, number] | [string, boolean]>' is not assignable to type 'IteratorResult<readonly [string, number], any>'.
-!!! error TS2769:                     Type 'IteratorYieldResult<[string, number] | [string, boolean]>' is not assignable to type 'IteratorYieldResult<readonly [string, number]>'.
-!!! error TS2769:                       Type '[string, number] | [string, boolean]' is not assignable to type 'readonly [string, number]'.
-!!! error TS2769:                         Type '[string, boolean]' is not assignable to type 'readonly [string, number]'.
-!!! error TS2769:                           Types of property '1' are incompatible.
-!!! error TS2769:                             Type 'boolean' is not assignable to type 'number'.
+!!! error TS2769:       The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types.
+!!! error TS2769:         Type 'IteratorResult<[string, number] | [string, boolean], any>' is not assignable to type 'IteratorResult<readonly [string, number], any>'.
+!!! error TS2769:           Type 'IteratorYieldResult<[string, number] | [string, boolean]>' is not assignable to type 'IteratorResult<readonly [string, number], any>'.
+!!! error TS2769:             Type 'IteratorYieldResult<[string, number] | [string, boolean]>' is not assignable to type 'IteratorYieldResult<readonly [string, number]>'.
+!!! error TS2769:               Type '[string, number] | [string, boolean]' is not assignable to type 'readonly [string, number]'.
+!!! error TS2769:                 Type '[string, boolean]' is not assignable to type 'readonly [string, number]'.
+!!! error TS2769:                   Types of property '1' are incompatible.
+!!! error TS2769:                     Type 'boolean' is not assignable to type 'number'.
 !!! error TS2769:   Overload 2 of 3, '(entries?: readonly (readonly [string, number])[]): Map<string, number>', gave the following error.
 !!! error TS2769:     Type 'true' is not assignable to type 'number'.
\ No newline at end of file
diff --git a/tests/baselines/reference/iteratorSpreadInArray6.errors.txt b/tests/baselines/reference/iteratorSpreadInArray6.errors.txt
index 0b114bc6477..202c0ab3bf2 100644
--- a/tests/baselines/reference/iteratorSpreadInArray6.errors.txt
+++ b/tests/baselines/reference/iteratorSpreadInArray6.errors.txt
@@ -1,10 +1,9 @@
 tests/cases/conformance/es6/spread/iteratorSpreadInArray6.ts(15,14): error TS2769: No overload matches this call.
   Overload 1 of 2, '(...items: ConcatArray<number>[]): number[]', gave the following error.
     Argument of type 'symbol[]' is not assignable to parameter of type 'ConcatArray<number>'.
-      Types of property 'slice' are incompatible.
-        Type '(start?: number, end?: number) => symbol[]' is not assignable to type '(start?: number, end?: number) => number[]'.
-          Type 'symbol[]' is not assignable to type 'number[]'.
-            Type 'symbol' is not assignable to type 'number'.
+      The types returned by 'slice(...)' are incompatible between these types.
+        Type 'symbol[]' is not assignable to type 'number[]'.
+          Type 'symbol' is not assignable to type 'number'.
   Overload 2 of 2, '(...items: (number | ConcatArray<number>)[]): number[]', gave the following error.
     Argument of type 'symbol[]' is not assignable to parameter of type 'number | ConcatArray<number>'.
       Type 'symbol[]' is not assignable to type 'ConcatArray<number>'.
@@ -30,10 +29,9 @@ tests/cases/conformance/es6/spread/iteratorSpreadInArray6.ts(15,14): error TS276
 !!! error TS2769: No overload matches this call.
 !!! error TS2769:   Overload 1 of 2, '(...items: ConcatArray<number>[]): number[]', gave the following error.
 !!! error TS2769:     Argument of type 'symbol[]' is not assignable to parameter of type 'ConcatArray<number>'.
-!!! error TS2769:       Types of property 'slice' are incompatible.
-!!! error TS2769:         Type '(start?: number, end?: number) => symbol[]' is not assignable to type '(start?: number, end?: number) => number[]'.
-!!! error TS2769:           Type 'symbol[]' is not assignable to type 'number[]'.
-!!! error TS2769:             Type 'symbol' is not assignable to type 'number'.
+!!! error TS2769:       The types returned by 'slice(...)' are incompatible between these types.
+!!! error TS2769:         Type 'symbol[]' is not assignable to type 'number[]'.
+!!! error TS2769:           Type 'symbol' is not assignable to type 'number'.
 !!! error TS2769:   Overload 2 of 2, '(...items: (number | ConcatArray<number>)[]): number[]', gave the following error.
 !!! error TS2769:     Argument of type 'symbol[]' is not assignable to parameter of type 'number | ConcatArray<number>'.
 !!! error TS2769:       Type 'symbol[]' is not assignable to type 'ConcatArray<number>'.
\ No newline at end of file
diff --git a/tests/baselines/reference/keyofAndIndexedAccessErrors.errors.txt b/tests/baselines/reference/keyofAndIndexedAccessErrors.errors.txt
index 69f992447e8..bb628d4f4fb 100644
--- a/tests/baselines/reference/keyofAndIndexedAccessErrors.errors.txt
+++ b/tests/baselines/reference/keyofAndIndexedAccessErrors.errors.txt
@@ -48,8 +48,6 @@ tests/cases/conformance/types/keyof/keyofAndIndexedAccessErrors.ts(103,9): error
       'string & keyof T' is assignable to the constraint of type 'K', but 'K' could be instantiated with a different subtype of constraint 'string'.
         Type 'string' is not assignable to type 'K'.
           'string' is assignable to the constraint of type 'K', but 'K' could be instantiated with a different subtype of constraint 'string'.
-            Type 'string' is not assignable to type 'K'.
-              'string' is assignable to the constraint of type 'K', but 'K' could be instantiated with a different subtype of constraint 'string'.
 tests/cases/conformance/types/keyof/keyofAndIndexedAccessErrors.ts(105,9): error TS2322: Type 'T[Extract<keyof T, string>]' is not assignable to type 'T[K]'.
   Type 'Extract<keyof T, string>' is not assignable to type 'K'.
     'Extract<keyof T, string>' is assignable to the constraint of type 'K', but 'K' could be instantiated with a different subtype of constraint 'string'.
@@ -68,8 +66,6 @@ tests/cases/conformance/types/keyof/keyofAndIndexedAccessErrors.ts(114,5): error
             'string & keyof T' is assignable to the constraint of type 'J', but 'J' could be instantiated with a different subtype of constraint 'string'.
               Type 'string' is not assignable to type 'J'.
                 'string' is assignable to the constraint of type 'J', but 'J' could be instantiated with a different subtype of constraint 'string'.
-                  Type 'string' is not assignable to type 'J'.
-                    'string' is assignable to the constraint of type 'J', but 'J' could be instantiated with a different subtype of constraint 'string'.
 tests/cases/conformance/types/keyof/keyofAndIndexedAccessErrors.ts(117,5): error TS2322: Type 'T[K]' is not assignable to type 'U[J]'.
   Type 'T' is not assignable to type 'U'.
     'T' is assignable to the constraint of type 'U', but 'U' could be instantiated with a different subtype of constraint '{}'.
@@ -264,8 +260,6 @@ tests/cases/conformance/types/keyof/keyofAndIndexedAccessErrors.ts(142,5): error
 !!! error TS2322:       'string & keyof T' is assignable to the constraint of type 'K', but 'K' could be instantiated with a different subtype of constraint 'string'.
 !!! error TS2322:         Type 'string' is not assignable to type 'K'.
 !!! error TS2322:           'string' is assignable to the constraint of type 'K', but 'K' could be instantiated with a different subtype of constraint 'string'.
-!!! error TS2322:             Type 'string' is not assignable to type 'K'.
-!!! error TS2322:               'string' is assignable to the constraint of type 'K', but 'K' could be instantiated with a different subtype of constraint 'string'.
             t[key] = tk; // ok, T[K] ==> T[keyof T]
             tk = t[key]; // error, T[keyof T] =/=> T[K]
             ~~
@@ -299,8 +293,6 @@ tests/cases/conformance/types/keyof/keyofAndIndexedAccessErrors.ts(142,5): error
 !!! error TS2322:             'string & keyof T' is assignable to the constraint of type 'J', but 'J' could be instantiated with a different subtype of constraint 'string'.
 !!! error TS2322:               Type 'string' is not assignable to type 'J'.
 !!! error TS2322:                 'string' is assignable to the constraint of type 'J', but 'J' could be instantiated with a different subtype of constraint 'string'.
-!!! error TS2322:                   Type 'string' is not assignable to type 'J'.
-!!! error TS2322:                     'string' is assignable to the constraint of type 'J', but 'J' could be instantiated with a different subtype of constraint 'string'.
     
         tk = uj;
         uj = tk; // error
diff --git a/tests/baselines/reference/mergedDeclarations7.errors.txt b/tests/baselines/reference/mergedDeclarations7.errors.txt
index cd9b3a5e939..bc09ea081a3 100644
--- a/tests/baselines/reference/mergedDeclarations7.errors.txt
+++ b/tests/baselines/reference/mergedDeclarations7.errors.txt
@@ -1,7 +1,6 @@
 tests/cases/compiler/test.ts(4,5): error TS2322: Type 'PassportStatic' is not assignable to type 'Passport'.
-  Types of property 'use' are incompatible.
-    Type '() => PassportStatic' is not assignable to type '() => this'.
-      Type 'PassportStatic' is not assignable to type 'this'.
+  The types returned by 'use()' are incompatible between these types.
+    Type 'PassportStatic' is not assignable to type 'this'.
 
 
 ==== tests/cases/compiler/passport.d.ts (0 errors) ====
@@ -27,6 +26,5 @@ tests/cases/compiler/test.ts(4,5): error TS2322: Type 'PassportStatic' is not as
     let p: Passport = passport.use();
         ~
 !!! error TS2322: Type 'PassportStatic' is not assignable to type 'Passport'.
-!!! error TS2322:   Types of property 'use' are incompatible.
-!!! error TS2322:     Type '() => PassportStatic' is not assignable to type '() => this'.
-!!! error TS2322:       Type 'PassportStatic' is not assignable to type 'this'.
\ No newline at end of file
+!!! error TS2322:   The types returned by 'use()' are incompatible between these types.
+!!! error TS2322:     Type 'PassportStatic' is not assignable to type 'this'.
\ No newline at end of file
diff --git a/tests/baselines/reference/mixinIntersectionIsValidbaseType.js b/tests/baselines/reference/mixinIntersectionIsValidbaseType.js
new file mode 100644
index 00000000000..ed02aecd53f
--- /dev/null
+++ b/tests/baselines/reference/mixinIntersectionIsValidbaseType.js
@@ -0,0 +1,77 @@
+//// [mixinIntersectionIsValidbaseType.ts]
+export type Constructor<T extends object = object> = new (...args: any[]) => T;
+
+export interface Initable {
+    init(...args: any[]): void;
+}
+
+/**
+ * Plain mixin where the superclass must be Initable
+ */
+export const Serializable = <K extends Constructor<Initable> & Initable>(
+    SuperClass: K
+) => {
+    const LocalMixin = (InnerSuperClass: K) => {
+        return class SerializableLocal extends InnerSuperClass {
+        }
+    };
+    let ResultClass = LocalMixin(SuperClass);
+    return ResultClass;
+};
+
+const AMixin = <K extends Constructor<Initable> & Initable>(SuperClass: K) => {
+    let SomeHowOkay = class A extends SuperClass {
+    };
+
+    let SomeHowNotOkay = class A extends Serializable(SuperClass) {
+    };
+};
+
+//// [mixinIntersectionIsValidbaseType.js]
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+exports.__esModule = true;
+/**
+ * Plain mixin where the superclass must be Initable
+ */
+exports.Serializable = function (SuperClass) {
+    var LocalMixin = function (InnerSuperClass) {
+        return /** @class */ (function (_super) {
+            __extends(SerializableLocal, _super);
+            function SerializableLocal() {
+                return _super !== null && _super.apply(this, arguments) || this;
+            }
+            return SerializableLocal;
+        }(InnerSuperClass));
+    };
+    var ResultClass = LocalMixin(SuperClass);
+    return ResultClass;
+};
+var AMixin = function (SuperClass) {
+    var SomeHowOkay = /** @class */ (function (_super) {
+        __extends(A, _super);
+        function A() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        return A;
+    }(SuperClass));
+    var SomeHowNotOkay = /** @class */ (function (_super) {
+        __extends(A, _super);
+        function A() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        return A;
+    }(exports.Serializable(SuperClass)));
+};
diff --git a/tests/baselines/reference/mixinIntersectionIsValidbaseType.symbols b/tests/baselines/reference/mixinIntersectionIsValidbaseType.symbols
new file mode 100644
index 00000000000..69fe63bab23
--- /dev/null
+++ b/tests/baselines/reference/mixinIntersectionIsValidbaseType.symbols
@@ -0,0 +1,74 @@
+=== tests/cases/compiler/mixinIntersectionIsValidbaseType.ts ===
+export type Constructor<T extends object = object> = new (...args: any[]) => T;
+>Constructor : Symbol(Constructor, Decl(mixinIntersectionIsValidbaseType.ts, 0, 0))
+>T : Symbol(T, Decl(mixinIntersectionIsValidbaseType.ts, 0, 24))
+>args : Symbol(args, Decl(mixinIntersectionIsValidbaseType.ts, 0, 58))
+>T : Symbol(T, Decl(mixinIntersectionIsValidbaseType.ts, 0, 24))
+
+export interface Initable {
+>Initable : Symbol(Initable, Decl(mixinIntersectionIsValidbaseType.ts, 0, 79))
+
+    init(...args: any[]): void;
+>init : Symbol(Initable.init, Decl(mixinIntersectionIsValidbaseType.ts, 2, 27))
+>args : Symbol(args, Decl(mixinIntersectionIsValidbaseType.ts, 3, 9))
+}
+
+/**
+ * Plain mixin where the superclass must be Initable
+ */
+export const Serializable = <K extends Constructor<Initable> & Initable>(
+>Serializable : Symbol(Serializable, Decl(mixinIntersectionIsValidbaseType.ts, 9, 12))
+>K : Symbol(K, Decl(mixinIntersectionIsValidbaseType.ts, 9, 29))
+>Constructor : Symbol(Constructor, Decl(mixinIntersectionIsValidbaseType.ts, 0, 0))
+>Initable : Symbol(Initable, Decl(mixinIntersectionIsValidbaseType.ts, 0, 79))
+>Initable : Symbol(Initable, Decl(mixinIntersectionIsValidbaseType.ts, 0, 79))
+
+    SuperClass: K
+>SuperClass : Symbol(SuperClass, Decl(mixinIntersectionIsValidbaseType.ts, 9, 73))
+>K : Symbol(K, Decl(mixinIntersectionIsValidbaseType.ts, 9, 29))
+
+) => {
+    const LocalMixin = (InnerSuperClass: K) => {
+>LocalMixin : Symbol(LocalMixin, Decl(mixinIntersectionIsValidbaseType.ts, 12, 9))
+>InnerSuperClass : Symbol(InnerSuperClass, Decl(mixinIntersectionIsValidbaseType.ts, 12, 24))
+>K : Symbol(K, Decl(mixinIntersectionIsValidbaseType.ts, 9, 29))
+
+        return class SerializableLocal extends InnerSuperClass {
+>SerializableLocal : Symbol(SerializableLocal, Decl(mixinIntersectionIsValidbaseType.ts, 13, 14))
+>InnerSuperClass : Symbol(InnerSuperClass, Decl(mixinIntersectionIsValidbaseType.ts, 12, 24))
+        }
+    };
+    let ResultClass = LocalMixin(SuperClass);
+>ResultClass : Symbol(ResultClass, Decl(mixinIntersectionIsValidbaseType.ts, 16, 7))
+>LocalMixin : Symbol(LocalMixin, Decl(mixinIntersectionIsValidbaseType.ts, 12, 9))
+>SuperClass : Symbol(SuperClass, Decl(mixinIntersectionIsValidbaseType.ts, 9, 73))
+
+    return ResultClass;
+>ResultClass : Symbol(ResultClass, Decl(mixinIntersectionIsValidbaseType.ts, 16, 7))
+
+};
+
+const AMixin = <K extends Constructor<Initable> & Initable>(SuperClass: K) => {
+>AMixin : Symbol(AMixin, Decl(mixinIntersectionIsValidbaseType.ts, 20, 5))
+>K : Symbol(K, Decl(mixinIntersectionIsValidbaseType.ts, 20, 16))
+>Constructor : Symbol(Constructor, Decl(mixinIntersectionIsValidbaseType.ts, 0, 0))
+>Initable : Symbol(Initable, Decl(mixinIntersectionIsValidbaseType.ts, 0, 79))
+>Initable : Symbol(Initable, Decl(mixinIntersectionIsValidbaseType.ts, 0, 79))
+>SuperClass : Symbol(SuperClass, Decl(mixinIntersectionIsValidbaseType.ts, 20, 60))
+>K : Symbol(K, Decl(mixinIntersectionIsValidbaseType.ts, 20, 16))
+
+    let SomeHowOkay = class A extends SuperClass {
+>SomeHowOkay : Symbol(SomeHowOkay, Decl(mixinIntersectionIsValidbaseType.ts, 21, 7))
+>A : Symbol(A, Decl(mixinIntersectionIsValidbaseType.ts, 21, 21))
+>SuperClass : Symbol(SuperClass, Decl(mixinIntersectionIsValidbaseType.ts, 20, 60))
+
+    };
+
+    let SomeHowNotOkay = class A extends Serializable(SuperClass) {
+>SomeHowNotOkay : Symbol(SomeHowNotOkay, Decl(mixinIntersectionIsValidbaseType.ts, 24, 7))
+>A : Symbol(A, Decl(mixinIntersectionIsValidbaseType.ts, 24, 24))
+>Serializable : Symbol(Serializable, Decl(mixinIntersectionIsValidbaseType.ts, 9, 12))
+>SuperClass : Symbol(SuperClass, Decl(mixinIntersectionIsValidbaseType.ts, 20, 60))
+
+    };
+};
diff --git a/tests/baselines/reference/mixinIntersectionIsValidbaseType.types b/tests/baselines/reference/mixinIntersectionIsValidbaseType.types
new file mode 100644
index 00000000000..c828188dcd6
--- /dev/null
+++ b/tests/baselines/reference/mixinIntersectionIsValidbaseType.types
@@ -0,0 +1,67 @@
+=== tests/cases/compiler/mixinIntersectionIsValidbaseType.ts ===
+export type Constructor<T extends object = object> = new (...args: any[]) => T;
+>Constructor : Constructor<T>
+>args : any[]
+
+export interface Initable {
+    init(...args: any[]): void;
+>init : (...args: any[]) => void
+>args : any[]
+}
+
+/**
+ * Plain mixin where the superclass must be Initable
+ */
+export const Serializable = <K extends Constructor<Initable> & Initable>(
+>Serializable : <K extends Constructor<Initable> & Initable>(SuperClass: K) => { new (...args: any[]): SerializableLocal; prototype: Serializable<any>.SerializableLocal; init(...args: any[]): void; } & K
+><K extends Constructor<Initable> & Initable>(    SuperClass: K) => {    const LocalMixin = (InnerSuperClass: K) => {        return class SerializableLocal extends InnerSuperClass {        }    };    let ResultClass = LocalMixin(SuperClass);    return ResultClass;} : <K extends Constructor<Initable> & Initable>(SuperClass: K) => { new (...args: any[]): SerializableLocal; prototype: Serializable<any>.SerializableLocal; init(...args: any[]): void; } & K
+
+    SuperClass: K
+>SuperClass : K
+
+) => {
+    const LocalMixin = (InnerSuperClass: K) => {
+>LocalMixin : (InnerSuperClass: K) => { new (...args: any[]): SerializableLocal; prototype: Serializable<any>.SerializableLocal; init(...args: any[]): void; } & K
+>(InnerSuperClass: K) => {        return class SerializableLocal extends InnerSuperClass {        }    } : (InnerSuperClass: K) => { new (...args: any[]): SerializableLocal; prototype: Serializable<any>.SerializableLocal; init(...args: any[]): void; } & K
+>InnerSuperClass : K
+
+        return class SerializableLocal extends InnerSuperClass {
+>class SerializableLocal extends InnerSuperClass {        } : { new (...args: any[]): SerializableLocal; prototype: Serializable<any>.SerializableLocal; init(...args: any[]): void; } & K
+>SerializableLocal : { new (...args: any[]): SerializableLocal; prototype: Serializable<any>.SerializableLocal; init(...args: any[]): void; } & K
+>InnerSuperClass : Initable
+        }
+    };
+    let ResultClass = LocalMixin(SuperClass);
+>ResultClass : { new (...args: any[]): SerializableLocal; prototype: Serializable<any>.SerializableLocal; init(...args: any[]): void; } & K
+>LocalMixin(SuperClass) : { new (...args: any[]): SerializableLocal; prototype: Serializable<any>.SerializableLocal; init(...args: any[]): void; } & K
+>LocalMixin : (InnerSuperClass: K) => { new (...args: any[]): SerializableLocal; prototype: Serializable<any>.SerializableLocal; init(...args: any[]): void; } & K
+>SuperClass : K
+
+    return ResultClass;
+>ResultClass : { new (...args: any[]): SerializableLocal; prototype: Serializable<any>.SerializableLocal; init(...args: any[]): void; } & K
+
+};
+
+const AMixin = <K extends Constructor<Initable> & Initable>(SuperClass: K) => {
+>AMixin : <K extends Constructor<Initable> & Initable>(SuperClass: K) => void
+><K extends Constructor<Initable> & Initable>(SuperClass: K) => {    let SomeHowOkay = class A extends SuperClass {    };    let SomeHowNotOkay = class A extends Serializable(SuperClass) {    };} : <K extends Constructor<Initable> & Initable>(SuperClass: K) => void
+>SuperClass : K
+
+    let SomeHowOkay = class A extends SuperClass {
+>SomeHowOkay : { new (...args: any[]): A; prototype: AMixin<any>.A; init(...args: any[]): void; } & K
+>class A extends SuperClass {    } : { new (...args: any[]): A; prototype: AMixin<any>.A; init(...args: any[]): void; } & K
+>A : { new (...args: any[]): A; prototype: AMixin<any>.A; init(...args: any[]): void; } & K
+>SuperClass : Initable
+
+    };
+
+    let SomeHowNotOkay = class A extends Serializable(SuperClass) {
+>SomeHowNotOkay : { new (...args: any[]): A; prototype: AMixin<any>.A; init: (...args: any[]) => void; } & K
+>class A extends Serializable(SuperClass) {    } : { new (...args: any[]): A; prototype: AMixin<any>.A; init: (...args: any[]) => void; } & K
+>A : { new (...args: any[]): A; prototype: AMixin<any>.A; init: (...args: any[]) => void; } & K
+>Serializable(SuperClass) : Serializable<K>.SerializableLocal & Initable
+>Serializable : <K extends Constructor<Initable> & Initable>(SuperClass: K) => { new (...args: any[]): SerializableLocal; prototype: Serializable<any>.SerializableLocal; init(...args: any[]): void; } & K
+>SuperClass : K
+
+    };
+};
diff --git a/tests/baselines/reference/multiLineErrors.errors.txt b/tests/baselines/reference/multiLineErrors.errors.txt
index 70366aeabed..851425baef4 100644
--- a/tests/baselines/reference/multiLineErrors.errors.txt
+++ b/tests/baselines/reference/multiLineErrors.errors.txt
@@ -1,9 +1,7 @@
 tests/cases/compiler/multiLineErrors.ts(3,22): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
 tests/cases/compiler/multiLineErrors.ts(21,1): error TS2322: Type 'A2' is not assignable to type 'A1'.
-  Types of property 'x' are incompatible.
-    Type '{ y: string; }' is not assignable to type '{ y: number; }'.
-      Types of property 'y' are incompatible.
-        Type 'string' is not assignable to type 'number'.
+  The types of 'x.y' are incompatible between these types.
+    Type 'string' is not assignable to type 'number'.
 
 
 ==== tests/cases/compiler/multiLineErrors.ts (2 errors) ====
@@ -35,8 +33,6 @@ tests/cases/compiler/multiLineErrors.ts(21,1): error TS2322: Type 'A2' is not as
     t1 = t2;
     ~~
 !!! error TS2322: Type 'A2' is not assignable to type 'A1'.
-!!! error TS2322:   Types of property 'x' are incompatible.
-!!! error TS2322:     Type '{ y: string; }' is not assignable to type '{ y: number; }'.
-!!! error TS2322:       Types of property 'y' are incompatible.
-!!! error TS2322:         Type 'string' is not assignable to type 'number'.
+!!! error TS2322:   The types of 'x.y' are incompatible between these types.
+!!! error TS2322:     Type 'string' is not assignable to type 'number'.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/mutuallyRecursiveCallbacks.errors.txt b/tests/baselines/reference/mutuallyRecursiveCallbacks.errors.txt
index bb90bcee999..63a568bf10a 100644
--- a/tests/baselines/reference/mutuallyRecursiveCallbacks.errors.txt
+++ b/tests/baselines/reference/mutuallyRecursiveCallbacks.errors.txt
@@ -1,9 +1,8 @@
 tests/cases/compiler/mutuallyRecursiveCallbacks.ts(7,1): error TS2322: Type '<T>(bar: Bar<T>) => void' is not assignable to type 'Bar<{}>'.
   Types of parameters 'bar' and 'foo' are incompatible.
     Types of parameters 'bar' and 'foo' are incompatible.
-      Type 'Foo<unknown>' is not assignable to type 'Bar<{}>'.
-        Types of parameters 'bar' and 'foo' are incompatible.
-          Type 'void' is not assignable to type 'Foo<unknown>'.
+      Types of parameters 'bar' and 'foo' are incompatible.
+        Type 'void' is not assignable to type 'Foo<unknown>'.
 
 
 ==== tests/cases/compiler/mutuallyRecursiveCallbacks.ts (1 errors) ====
@@ -18,7 +17,6 @@ tests/cases/compiler/mutuallyRecursiveCallbacks.ts(7,1): error TS2322: Type '<T>
 !!! error TS2322: Type '<T>(bar: Bar<T>) => void' is not assignable to type 'Bar<{}>'.
 !!! error TS2322:   Types of parameters 'bar' and 'foo' are incompatible.
 !!! error TS2322:     Types of parameters 'bar' and 'foo' are incompatible.
-!!! error TS2322:       Type 'Foo<unknown>' is not assignable to type 'Bar<{}>'.
-!!! error TS2322:         Types of parameters 'bar' and 'foo' are incompatible.
-!!! error TS2322:           Type 'void' is not assignable to type 'Foo<unknown>'.
+!!! error TS2322:       Types of parameters 'bar' and 'foo' are incompatible.
+!!! error TS2322:         Type 'void' is not assignable to type 'Foo<unknown>'.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/nestedCallbackErrorNotFlattened.errors.txt b/tests/baselines/reference/nestedCallbackErrorNotFlattened.errors.txt
new file mode 100644
index 00000000000..3749d3765b0
--- /dev/null
+++ b/tests/baselines/reference/nestedCallbackErrorNotFlattened.errors.txt
@@ -0,0 +1,20 @@
+tests/cases/compiler/nestedCallbackErrorNotFlattened.ts(6,1): error TS2322: Type '() => () => () => () => number' is not assignable to type '() => () => () => () => string'.
+  Call signature return types '() => () => () => number' and '() => () => () => string' are incompatible.
+    Call signature return types '() => () => number' and '() => () => string' are incompatible.
+      Call signature return types '() => number' and '() => string' are incompatible.
+        Type 'number' is not assignable to type 'string'.
+
+
+==== tests/cases/compiler/nestedCallbackErrorNotFlattened.ts (1 errors) ====
+    type Cb<T> = {noAlias: () => T}["noAlias"]; // `"noAlias"` here prevents an alias symbol from being made
+    // which means the comparison will definitely be structural, rather than by variance
+    
+    declare const x: Cb<Cb<Cb<Cb<number>>>>; // one more layer of `Cb` adn we'd get a `true` from the deeply-nested symbol check
+    declare let y: Cb<Cb<Cb<Cb<string>>>>;
+    y = x;
+    ~
+!!! error TS2322: Type '() => () => () => () => number' is not assignable to type '() => () => () => () => string'.
+!!! error TS2322:   Call signature return types '() => () => () => number' and '() => () => () => string' are incompatible.
+!!! error TS2322:     Call signature return types '() => () => number' and '() => () => string' are incompatible.
+!!! error TS2322:       Call signature return types '() => number' and '() => string' are incompatible.
+!!! error TS2322:         Type 'number' is not assignable to type 'string'.
\ No newline at end of file
diff --git a/tests/baselines/reference/nestedCallbackErrorNotFlattened.js b/tests/baselines/reference/nestedCallbackErrorNotFlattened.js
new file mode 100644
index 00000000000..0c5edf9760b
--- /dev/null
+++ b/tests/baselines/reference/nestedCallbackErrorNotFlattened.js
@@ -0,0 +1,11 @@
+//// [nestedCallbackErrorNotFlattened.ts]
+type Cb<T> = {noAlias: () => T}["noAlias"]; // `"noAlias"` here prevents an alias symbol from being made
+// which means the comparison will definitely be structural, rather than by variance
+
+declare const x: Cb<Cb<Cb<Cb<number>>>>; // one more layer of `Cb` adn we'd get a `true` from the deeply-nested symbol check
+declare let y: Cb<Cb<Cb<Cb<string>>>>;
+y = x;
+
+//// [nestedCallbackErrorNotFlattened.js]
+"use strict";
+y = x;
diff --git a/tests/baselines/reference/nestedCallbackErrorNotFlattened.symbols b/tests/baselines/reference/nestedCallbackErrorNotFlattened.symbols
new file mode 100644
index 00000000000..2019b787822
--- /dev/null
+++ b/tests/baselines/reference/nestedCallbackErrorNotFlattened.symbols
@@ -0,0 +1,27 @@
+=== tests/cases/compiler/nestedCallbackErrorNotFlattened.ts ===
+type Cb<T> = {noAlias: () => T}["noAlias"]; // `"noAlias"` here prevents an alias symbol from being made
+>Cb : Symbol(Cb, Decl(nestedCallbackErrorNotFlattened.ts, 0, 0))
+>T : Symbol(T, Decl(nestedCallbackErrorNotFlattened.ts, 0, 8))
+>noAlias : Symbol(noAlias, Decl(nestedCallbackErrorNotFlattened.ts, 0, 14))
+>T : Symbol(T, Decl(nestedCallbackErrorNotFlattened.ts, 0, 8))
+
+// which means the comparison will definitely be structural, rather than by variance
+
+declare const x: Cb<Cb<Cb<Cb<number>>>>; // one more layer of `Cb` adn we'd get a `true` from the deeply-nested symbol check
+>x : Symbol(x, Decl(nestedCallbackErrorNotFlattened.ts, 3, 13))
+>Cb : Symbol(Cb, Decl(nestedCallbackErrorNotFlattened.ts, 0, 0))
+>Cb : Symbol(Cb, Decl(nestedCallbackErrorNotFlattened.ts, 0, 0))
+>Cb : Symbol(Cb, Decl(nestedCallbackErrorNotFlattened.ts, 0, 0))
+>Cb : Symbol(Cb, Decl(nestedCallbackErrorNotFlattened.ts, 0, 0))
+
+declare let y: Cb<Cb<Cb<Cb<string>>>>;
+>y : Symbol(y, Decl(nestedCallbackErrorNotFlattened.ts, 4, 11))
+>Cb : Symbol(Cb, Decl(nestedCallbackErrorNotFlattened.ts, 0, 0))
+>Cb : Symbol(Cb, Decl(nestedCallbackErrorNotFlattened.ts, 0, 0))
+>Cb : Symbol(Cb, Decl(nestedCallbackErrorNotFlattened.ts, 0, 0))
+>Cb : Symbol(Cb, Decl(nestedCallbackErrorNotFlattened.ts, 0, 0))
+
+y = x;
+>y : Symbol(y, Decl(nestedCallbackErrorNotFlattened.ts, 4, 11))
+>x : Symbol(x, Decl(nestedCallbackErrorNotFlattened.ts, 3, 13))
+
diff --git a/tests/baselines/reference/nestedCallbackErrorNotFlattened.types b/tests/baselines/reference/nestedCallbackErrorNotFlattened.types
new file mode 100644
index 00000000000..5e753714b34
--- /dev/null
+++ b/tests/baselines/reference/nestedCallbackErrorNotFlattened.types
@@ -0,0 +1,18 @@
+=== tests/cases/compiler/nestedCallbackErrorNotFlattened.ts ===
+type Cb<T> = {noAlias: () => T}["noAlias"]; // `"noAlias"` here prevents an alias symbol from being made
+>Cb : () => T
+>noAlias : () => T
+
+// which means the comparison will definitely be structural, rather than by variance
+
+declare const x: Cb<Cb<Cb<Cb<number>>>>; // one more layer of `Cb` adn we'd get a `true` from the deeply-nested symbol check
+>x : () => () => () => () => number
+
+declare let y: Cb<Cb<Cb<Cb<string>>>>;
+>y : () => () => () => () => string
+
+y = x;
+>y = x : () => () => () => () => number
+>y : () => () => () => () => string
+>x : () => () => () => () => number
+
diff --git a/tests/baselines/reference/nestedRecursiveArraysOrObjectsError01.errors.txt b/tests/baselines/reference/nestedRecursiveArraysOrObjectsError01.errors.txt
index 138a4a84158..650a808e598 100644
--- a/tests/baselines/reference/nestedRecursiveArraysOrObjectsError01.errors.txt
+++ b/tests/baselines/reference/nestedRecursiveArraysOrObjectsError01.errors.txt
@@ -1,17 +1,14 @@
 tests/cases/compiler/nestedRecursiveArraysOrObjectsError01.ts(10,9): error TS2322: Type '{ foo: string; jj: number; }[][][]' is not assignable to type 'Style'.
   Type '{ foo: string; jj: number; }[][][]' is not assignable to type 'StyleArray'.
-    Types of property 'pop' are incompatible.
-      Type '() => { foo: string; jj: number; }[][]' is not assignable to type '() => Style'.
-        Type '{ foo: string; jj: number; }[][]' is not assignable to type 'Style'.
-          Type '{ foo: string; jj: number; }[][]' is not assignable to type 'StyleArray'.
-            Types of property 'pop' are incompatible.
-              Type '() => { foo: string; jj: number; }[]' is not assignable to type '() => Style'.
-                Type '{ foo: string; jj: number; }[]' is not assignable to type 'Style'.
-                  Type '{ foo: string; jj: number; }[]' is not assignable to type 'StyleArray'.
-                    Types of property 'pop' are incompatible.
-                      Type '() => { foo: string; jj: number; }' is not assignable to type '() => Style'.
-                        Type '{ foo: string; jj: number; }' is not assignable to type 'Style'.
-                          Object literal may only specify known properties, and 'jj' does not exist in type 'Style'.
+    The types returned by 'pop()' are incompatible between these types.
+      Type '{ foo: string; jj: number; }[][]' is not assignable to type 'Style'.
+        Type '{ foo: string; jj: number; }[][]' is not assignable to type 'StyleArray'.
+          The types returned by 'pop()' are incompatible between these types.
+            Type '{ foo: string; jj: number; }[]' is not assignable to type 'Style'.
+              Type '{ foo: string; jj: number; }[]' is not assignable to type 'StyleArray'.
+                The types returned by 'pop()' are incompatible between these types.
+                  Type '{ foo: string; jj: number; }' is not assignable to type 'Style'.
+                    Object literal may only specify known properties, and 'jj' does not exist in type 'Style'.
 
 
 ==== tests/cases/compiler/nestedRecursiveArraysOrObjectsError01.ts (1 errors) ====
@@ -28,18 +25,15 @@ tests/cases/compiler/nestedRecursiveArraysOrObjectsError01.ts(10,9): error TS232
             ~~~~~
 !!! error TS2322: Type '{ foo: string; jj: number; }[][][]' is not assignable to type 'Style'.
 !!! error TS2322:   Type '{ foo: string; jj: number; }[][][]' is not assignable to type 'StyleArray'.
-!!! error TS2322:     Types of property 'pop' are incompatible.
-!!! error TS2322:       Type '() => { foo: string; jj: number; }[][]' is not assignable to type '() => Style'.
-!!! error TS2322:         Type '{ foo: string; jj: number; }[][]' is not assignable to type 'Style'.
-!!! error TS2322:           Type '{ foo: string; jj: number; }[][]' is not assignable to type 'StyleArray'.
-!!! error TS2322:             Types of property 'pop' are incompatible.
-!!! error TS2322:               Type '() => { foo: string; jj: number; }[]' is not assignable to type '() => Style'.
-!!! error TS2322:                 Type '{ foo: string; jj: number; }[]' is not assignable to type 'Style'.
-!!! error TS2322:                   Type '{ foo: string; jj: number; }[]' is not assignable to type 'StyleArray'.
-!!! error TS2322:                     Types of property 'pop' are incompatible.
-!!! error TS2322:                       Type '() => { foo: string; jj: number; }' is not assignable to type '() => Style'.
-!!! error TS2322:                         Type '{ foo: string; jj: number; }' is not assignable to type 'Style'.
-!!! error TS2322:                           Object literal may only specify known properties, and 'jj' does not exist in type 'Style'.
+!!! error TS2322:     The types returned by 'pop()' are incompatible between these types.
+!!! error TS2322:       Type '{ foo: string; jj: number; }[][]' is not assignable to type 'Style'.
+!!! error TS2322:         Type '{ foo: string; jj: number; }[][]' is not assignable to type 'StyleArray'.
+!!! error TS2322:           The types returned by 'pop()' are incompatible between these types.
+!!! error TS2322:             Type '{ foo: string; jj: number; }[]' is not assignable to type 'Style'.
+!!! error TS2322:               Type '{ foo: string; jj: number; }[]' is not assignable to type 'StyleArray'.
+!!! error TS2322:                 The types returned by 'pop()' are incompatible between these types.
+!!! error TS2322:                   Type '{ foo: string; jj: number; }' is not assignable to type 'Style'.
+!!! error TS2322:                     Object literal may only specify known properties, and 'jj' does not exist in type 'Style'.
         }]]
     ];
     
diff --git a/tests/baselines/reference/neverReturningFunctions1.errors.txt b/tests/baselines/reference/neverReturningFunctions1.errors.txt
new file mode 100644
index 00000000000..f8656bbed08
--- /dev/null
+++ b/tests/baselines/reference/neverReturningFunctions1.errors.txt
@@ -0,0 +1,227 @@
+tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(13,5): error TS7027: Unreachable code detected.
+tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(19,5): error TS7027: Unreachable code detected.
+tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(30,5): error TS7027: Unreachable code detected.
+tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(36,5): error TS7027: Unreachable code detected.
+tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(51,5): error TS7027: Unreachable code detected.
+tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(57,5): error TS7027: Unreachable code detected.
+tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(63,5): error TS7027: Unreachable code detected.
+tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(77,9): error TS7027: Unreachable code detected.
+tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(82,9): error TS7027: Unreachable code detected.
+tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(89,9): error TS7027: Unreachable code detected.
+tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(96,13): error TS7027: Unreachable code detected.
+tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(101,13): error TS7027: Unreachable code detected.
+tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(103,9): error TS7027: Unreachable code detected.
+tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(105,5): error TS7027: Unreachable code detected.
+tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(111,9): error TS7027: Unreachable code detected.
+tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(112,9): error TS7027: Unreachable code detected.
+tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(122,9): error TS7027: Unreachable code detected.
+tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(127,9): error TS7027: Unreachable code detected.
+tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(129,5): error TS7027: Unreachable code detected.
+tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(139,9): error TS7027: Unreachable code detected.
+tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(141,5): error TS7027: Unreachable code detected.
+tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(148,9): error TS7027: Unreachable code detected.
+tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(153,5): error TS7027: Unreachable code detected.
+
+
+==== tests/cases/conformance/controlFlow/neverReturningFunctions1.ts (23 errors) ====
+    function fail(message?: string): never {
+        throw new Error(message);
+    }
+    
+    function f01(x: string | undefined) {
+        if (x === undefined) fail("undefined argument");
+        x.length;  // string
+    }
+    
+    function f02(x: number): number {
+        if (x >= 0) return x;
+        fail("negative number");
+        x;  // Unreachable
+        ~~
+!!! error TS7027: Unreachable code detected.
+    }
+    
+    function f03(x: string) {
+        x;  // string
+        fail();
+        x;  // Unreachable
+        ~~
+!!! error TS7027: Unreachable code detected.
+    }
+    
+    function f11(x: string | undefined, fail: (message?: string) => never) {
+        if (x === undefined) fail("undefined argument");
+        x.length;  // string
+    }
+    
+    function f12(x: number, fail: (message?: string) => never): number {
+        if (x >= 0) return x;
+        fail("negative number");
+        x;  // Unreachable
+        ~~
+!!! error TS7027: Unreachable code detected.
+    }
+    
+    function f13(x: string, fail: (message?: string) => never) {
+        x;  // string
+        fail();
+        x;  // Unreachable
+        ~~
+!!! error TS7027: Unreachable code detected.
+    }
+    
+    namespace Debug {
+        export declare function fail(message?: string): never;
+    }
+    
+    function f21(x: string | undefined) {
+        if (x === undefined) Debug.fail("undefined argument");
+        x.length;  // string
+    }
+    
+    function f22(x: number): number {
+        if (x >= 0) return x;
+        Debug.fail("negative number");
+        x;  // Unreachable
+        ~~
+!!! error TS7027: Unreachable code detected.
+    }
+    
+    function f23(x: string) {
+        x;  // string
+        Debug.fail();
+        x;  // Unreachable
+        ~~
+!!! error TS7027: Unreachable code detected.
+    }
+    
+    function f24(x: string) {
+        x;  // string
+        ((Debug).fail)();
+        x;  // Unreachable
+        ~~
+!!! error TS7027: Unreachable code detected.
+    }
+    
+    class Test {
+        fail(message?: string): never {
+            throw new Error(message);
+        }
+        f1(x: string | undefined) {
+            if (x === undefined) this.fail("undefined argument");
+            x.length;  // string
+        }
+        f2(x: number): number {
+            if (x >= 0) return x;
+            this.fail("negative number");
+            x;  // Unreachable
+            ~~
+!!! error TS7027: Unreachable code detected.
+        }
+        f3(x: string) {
+            x;  // string
+            this.fail();
+            x;  // Unreachable
+            ~~
+!!! error TS7027: Unreachable code detected.
+        }
+    }
+    
+    function f30(x: string | number | undefined) {
+        if (typeof x === "string") {
+            fail();
+            x;  // Unreachable
+            ~~
+!!! error TS7027: Unreachable code detected.
+        }
+        else {
+            x;  // number | undefined
+            if (x !== undefined) {
+                x;  // number
+                fail();
+                x;  // Unreachable
+                ~~
+!!! error TS7027: Unreachable code detected.
+            }
+            else {
+                x;  // undefined
+                fail();
+                x;  // Unreachable
+                ~~
+!!! error TS7027: Unreachable code detected.
+            }
+            x;  // Unreachable
+            ~~
+!!! error TS7027: Unreachable code detected.
+        }
+        x;  // Unreachable
+        ~~
+!!! error TS7027: Unreachable code detected.
+    }
+    
+    function f31(x: { a: string | number }) {
+        if (typeof x.a === "string") {
+            fail();
+            x;    // Unreachable
+            ~~
+!!! error TS7027: Unreachable code detected.
+            x.a;  // Unreachable
+            ~~~~
+!!! error TS7027: Unreachable code detected.
+        }
+        x;    // { a: string | number }
+        x.a;  // number
+    }
+    
+    function f40(x: number) {
+        try {
+            x;
+            fail();
+            x;  // Unreachable
+            ~~
+!!! error TS7027: Unreachable code detected.
+        }
+        finally {
+            x;
+            fail();
+            x;  // Unreachable
+            ~~
+!!! error TS7027: Unreachable code detected.
+        }
+        x;  // Unreachable
+        ~~
+!!! error TS7027: Unreachable code detected.
+    }
+    
+    function f41(x: number) {
+        try {
+            x;
+        }
+        finally {
+            x;
+            fail();
+            x;  // Unreachable
+            ~~
+!!! error TS7027: Unreachable code detected.
+        }
+        x;  // Unreachable
+        ~~
+!!! error TS7027: Unreachable code detected.
+    }
+    
+    function f42(x: number) {
+        try {
+            x;
+            fail();
+            x;  // Unreachable
+            ~~
+!!! error TS7027: Unreachable code detected.
+        }
+        finally {
+            x;
+        }
+        x;  // Unreachable
+        ~~
+!!! error TS7027: Unreachable code detected.
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/neverReturningFunctions1.js b/tests/baselines/reference/neverReturningFunctions1.js
new file mode 100644
index 00000000000..cce75c6668a
--- /dev/null
+++ b/tests/baselines/reference/neverReturningFunctions1.js
@@ -0,0 +1,337 @@
+//// [neverReturningFunctions1.ts]
+function fail(message?: string): never {
+    throw new Error(message);
+}
+
+function f01(x: string | undefined) {
+    if (x === undefined) fail("undefined argument");
+    x.length;  // string
+}
+
+function f02(x: number): number {
+    if (x >= 0) return x;
+    fail("negative number");
+    x;  // Unreachable
+}
+
+function f03(x: string) {
+    x;  // string
+    fail();
+    x;  // Unreachable
+}
+
+function f11(x: string | undefined, fail: (message?: string) => never) {
+    if (x === undefined) fail("undefined argument");
+    x.length;  // string
+}
+
+function f12(x: number, fail: (message?: string) => never): number {
+    if (x >= 0) return x;
+    fail("negative number");
+    x;  // Unreachable
+}
+
+function f13(x: string, fail: (message?: string) => never) {
+    x;  // string
+    fail();
+    x;  // Unreachable
+}
+
+namespace Debug {
+    export declare function fail(message?: string): never;
+}
+
+function f21(x: string | undefined) {
+    if (x === undefined) Debug.fail("undefined argument");
+    x.length;  // string
+}
+
+function f22(x: number): number {
+    if (x >= 0) return x;
+    Debug.fail("negative number");
+    x;  // Unreachable
+}
+
+function f23(x: string) {
+    x;  // string
+    Debug.fail();
+    x;  // Unreachable
+}
+
+function f24(x: string) {
+    x;  // string
+    ((Debug).fail)();
+    x;  // Unreachable
+}
+
+class Test {
+    fail(message?: string): never {
+        throw new Error(message);
+    }
+    f1(x: string | undefined) {
+        if (x === undefined) this.fail("undefined argument");
+        x.length;  // string
+    }
+    f2(x: number): number {
+        if (x >= 0) return x;
+        this.fail("negative number");
+        x;  // Unreachable
+    }
+    f3(x: string) {
+        x;  // string
+        this.fail();
+        x;  // Unreachable
+    }
+}
+
+function f30(x: string | number | undefined) {
+    if (typeof x === "string") {
+        fail();
+        x;  // Unreachable
+    }
+    else {
+        x;  // number | undefined
+        if (x !== undefined) {
+            x;  // number
+            fail();
+            x;  // Unreachable
+        }
+        else {
+            x;  // undefined
+            fail();
+            x;  // Unreachable
+        }
+        x;  // Unreachable
+    }
+    x;  // Unreachable
+}
+
+function f31(x: { a: string | number }) {
+    if (typeof x.a === "string") {
+        fail();
+        x;    // Unreachable
+        x.a;  // Unreachable
+    }
+    x;    // { a: string | number }
+    x.a;  // number
+}
+
+function f40(x: number) {
+    try {
+        x;
+        fail();
+        x;  // Unreachable
+    }
+    finally {
+        x;
+        fail();
+        x;  // Unreachable
+    }
+    x;  // Unreachable
+}
+
+function f41(x: number) {
+    try {
+        x;
+    }
+    finally {
+        x;
+        fail();
+        x;  // Unreachable
+    }
+    x;  // Unreachable
+}
+
+function f42(x: number) {
+    try {
+        x;
+        fail();
+        x;  // Unreachable
+    }
+    finally {
+        x;
+    }
+    x;  // Unreachable
+}
+
+
+//// [neverReturningFunctions1.js]
+"use strict";
+function fail(message) {
+    throw new Error(message);
+}
+function f01(x) {
+    if (x === undefined)
+        fail("undefined argument");
+    x.length; // string
+}
+function f02(x) {
+    if (x >= 0)
+        return x;
+    fail("negative number");
+    x; // Unreachable
+}
+function f03(x) {
+    x; // string
+    fail();
+    x; // Unreachable
+}
+function f11(x, fail) {
+    if (x === undefined)
+        fail("undefined argument");
+    x.length; // string
+}
+function f12(x, fail) {
+    if (x >= 0)
+        return x;
+    fail("negative number");
+    x; // Unreachable
+}
+function f13(x, fail) {
+    x; // string
+    fail();
+    x; // Unreachable
+}
+var Debug;
+(function (Debug) {
+})(Debug || (Debug = {}));
+function f21(x) {
+    if (x === undefined)
+        Debug.fail("undefined argument");
+    x.length; // string
+}
+function f22(x) {
+    if (x >= 0)
+        return x;
+    Debug.fail("negative number");
+    x; // Unreachable
+}
+function f23(x) {
+    x; // string
+    Debug.fail();
+    x; // Unreachable
+}
+function f24(x) {
+    x; // string
+    ((Debug).fail)();
+    x; // Unreachable
+}
+var Test = /** @class */ (function () {
+    function Test() {
+    }
+    Test.prototype.fail = function (message) {
+        throw new Error(message);
+    };
+    Test.prototype.f1 = function (x) {
+        if (x === undefined)
+            this.fail("undefined argument");
+        x.length; // string
+    };
+    Test.prototype.f2 = function (x) {
+        if (x >= 0)
+            return x;
+        this.fail("negative number");
+        x; // Unreachable
+    };
+    Test.prototype.f3 = function (x) {
+        x; // string
+        this.fail();
+        x; // Unreachable
+    };
+    return Test;
+}());
+function f30(x) {
+    if (typeof x === "string") {
+        fail();
+        x; // Unreachable
+    }
+    else {
+        x; // number | undefined
+        if (x !== undefined) {
+            x; // number
+            fail();
+            x; // Unreachable
+        }
+        else {
+            x; // undefined
+            fail();
+            x; // Unreachable
+        }
+        x; // Unreachable
+    }
+    x; // Unreachable
+}
+function f31(x) {
+    if (typeof x.a === "string") {
+        fail();
+        x; // Unreachable
+        x.a; // Unreachable
+    }
+    x; // { a: string | number }
+    x.a; // number
+}
+function f40(x) {
+    try {
+        x;
+        fail();
+        x; // Unreachable
+    }
+    finally {
+        x;
+        fail();
+        x; // Unreachable
+    }
+    x; // Unreachable
+}
+function f41(x) {
+    try {
+        x;
+    }
+    finally {
+        x;
+        fail();
+        x; // Unreachable
+    }
+    x; // Unreachable
+}
+function f42(x) {
+    try {
+        x;
+        fail();
+        x; // Unreachable
+    }
+    finally {
+        x;
+    }
+    x; // Unreachable
+}
+
+
+//// [neverReturningFunctions1.d.ts]
+declare function fail(message?: string): never;
+declare function f01(x: string | undefined): void;
+declare function f02(x: number): number;
+declare function f03(x: string): void;
+declare function f11(x: string | undefined, fail: (message?: string) => never): void;
+declare function f12(x: number, fail: (message?: string) => never): number;
+declare function f13(x: string, fail: (message?: string) => never): void;
+declare namespace Debug {
+    function fail(message?: string): never;
+}
+declare function f21(x: string | undefined): void;
+declare function f22(x: number): number;
+declare function f23(x: string): void;
+declare function f24(x: string): void;
+declare class Test {
+    fail(message?: string): never;
+    f1(x: string | undefined): void;
+    f2(x: number): number;
+    f3(x: string): void;
+}
+declare function f30(x: string | number | undefined): void;
+declare function f31(x: {
+    a: string | number;
+}): void;
+declare function f40(x: number): void;
+declare function f41(x: number): void;
+declare function f42(x: number): void;
diff --git a/tests/baselines/reference/neverReturningFunctions1.symbols b/tests/baselines/reference/neverReturningFunctions1.symbols
new file mode 100644
index 00000000000..7f1b5c489ac
--- /dev/null
+++ b/tests/baselines/reference/neverReturningFunctions1.symbols
@@ -0,0 +1,387 @@
+=== tests/cases/conformance/controlFlow/neverReturningFunctions1.ts ===
+function fail(message?: string): never {
+>fail : Symbol(fail, Decl(neverReturningFunctions1.ts, 0, 0))
+>message : Symbol(message, Decl(neverReturningFunctions1.ts, 0, 14))
+
+    throw new Error(message);
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>message : Symbol(message, Decl(neverReturningFunctions1.ts, 0, 14))
+}
+
+function f01(x: string | undefined) {
+>f01 : Symbol(f01, Decl(neverReturningFunctions1.ts, 2, 1))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 4, 13))
+
+    if (x === undefined) fail("undefined argument");
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 4, 13))
+>undefined : Symbol(undefined)
+>fail : Symbol(fail, Decl(neverReturningFunctions1.ts, 0, 0))
+
+    x.length;  // string
+>x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 4, 13))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+}
+
+function f02(x: number): number {
+>f02 : Symbol(f02, Decl(neverReturningFunctions1.ts, 7, 1))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 9, 13))
+
+    if (x >= 0) return x;
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 9, 13))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 9, 13))
+
+    fail("negative number");
+>fail : Symbol(fail, Decl(neverReturningFunctions1.ts, 0, 0))
+
+    x;  // Unreachable
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 9, 13))
+}
+
+function f03(x: string) {
+>f03 : Symbol(f03, Decl(neverReturningFunctions1.ts, 13, 1))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 15, 13))
+
+    x;  // string
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 15, 13))
+
+    fail();
+>fail : Symbol(fail, Decl(neverReturningFunctions1.ts, 0, 0))
+
+    x;  // Unreachable
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 15, 13))
+}
+
+function f11(x: string | undefined, fail: (message?: string) => never) {
+>f11 : Symbol(f11, Decl(neverReturningFunctions1.ts, 19, 1))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 21, 13))
+>fail : Symbol(fail, Decl(neverReturningFunctions1.ts, 21, 35))
+>message : Symbol(message, Decl(neverReturningFunctions1.ts, 21, 43))
+
+    if (x === undefined) fail("undefined argument");
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 21, 13))
+>undefined : Symbol(undefined)
+>fail : Symbol(fail, Decl(neverReturningFunctions1.ts, 21, 35))
+
+    x.length;  // string
+>x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 21, 13))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+}
+
+function f12(x: number, fail: (message?: string) => never): number {
+>f12 : Symbol(f12, Decl(neverReturningFunctions1.ts, 24, 1))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 26, 13))
+>fail : Symbol(fail, Decl(neverReturningFunctions1.ts, 26, 23))
+>message : Symbol(message, Decl(neverReturningFunctions1.ts, 26, 31))
+
+    if (x >= 0) return x;
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 26, 13))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 26, 13))
+
+    fail("negative number");
+>fail : Symbol(fail, Decl(neverReturningFunctions1.ts, 26, 23))
+
+    x;  // Unreachable
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 26, 13))
+}
+
+function f13(x: string, fail: (message?: string) => never) {
+>f13 : Symbol(f13, Decl(neverReturningFunctions1.ts, 30, 1))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 32, 13))
+>fail : Symbol(fail, Decl(neverReturningFunctions1.ts, 32, 23))
+>message : Symbol(message, Decl(neverReturningFunctions1.ts, 32, 31))
+
+    x;  // string
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 32, 13))
+
+    fail();
+>fail : Symbol(fail, Decl(neverReturningFunctions1.ts, 32, 23))
+
+    x;  // Unreachable
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 32, 13))
+}
+
+namespace Debug {
+>Debug : Symbol(Debug, Decl(neverReturningFunctions1.ts, 36, 1))
+
+    export declare function fail(message?: string): never;
+>fail : Symbol(fail, Decl(neverReturningFunctions1.ts, 38, 17))
+>message : Symbol(message, Decl(neverReturningFunctions1.ts, 39, 33))
+}
+
+function f21(x: string | undefined) {
+>f21 : Symbol(f21, Decl(neverReturningFunctions1.ts, 40, 1))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 42, 13))
+
+    if (x === undefined) Debug.fail("undefined argument");
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 42, 13))
+>undefined : Symbol(undefined)
+>Debug.fail : Symbol(Debug.fail, Decl(neverReturningFunctions1.ts, 38, 17))
+>Debug : Symbol(Debug, Decl(neverReturningFunctions1.ts, 36, 1))
+>fail : Symbol(Debug.fail, Decl(neverReturningFunctions1.ts, 38, 17))
+
+    x.length;  // string
+>x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 42, 13))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+}
+
+function f22(x: number): number {
+>f22 : Symbol(f22, Decl(neverReturningFunctions1.ts, 45, 1))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 47, 13))
+
+    if (x >= 0) return x;
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 47, 13))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 47, 13))
+
+    Debug.fail("negative number");
+>Debug.fail : Symbol(Debug.fail, Decl(neverReturningFunctions1.ts, 38, 17))
+>Debug : Symbol(Debug, Decl(neverReturningFunctions1.ts, 36, 1))
+>fail : Symbol(Debug.fail, Decl(neverReturningFunctions1.ts, 38, 17))
+
+    x;  // Unreachable
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 47, 13))
+}
+
+function f23(x: string) {
+>f23 : Symbol(f23, Decl(neverReturningFunctions1.ts, 51, 1))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 53, 13))
+
+    x;  // string
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 53, 13))
+
+    Debug.fail();
+>Debug.fail : Symbol(Debug.fail, Decl(neverReturningFunctions1.ts, 38, 17))
+>Debug : Symbol(Debug, Decl(neverReturningFunctions1.ts, 36, 1))
+>fail : Symbol(Debug.fail, Decl(neverReturningFunctions1.ts, 38, 17))
+
+    x;  // Unreachable
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 53, 13))
+}
+
+function f24(x: string) {
+>f24 : Symbol(f24, Decl(neverReturningFunctions1.ts, 57, 1))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 59, 13))
+
+    x;  // string
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 59, 13))
+
+    ((Debug).fail)();
+>(Debug).fail : Symbol(Debug.fail, Decl(neverReturningFunctions1.ts, 38, 17))
+>Debug : Symbol(Debug, Decl(neverReturningFunctions1.ts, 36, 1))
+>fail : Symbol(Debug.fail, Decl(neverReturningFunctions1.ts, 38, 17))
+
+    x;  // Unreachable
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 59, 13))
+}
+
+class Test {
+>Test : Symbol(Test, Decl(neverReturningFunctions1.ts, 63, 1))
+
+    fail(message?: string): never {
+>fail : Symbol(Test.fail, Decl(neverReturningFunctions1.ts, 65, 12))
+>message : Symbol(message, Decl(neverReturningFunctions1.ts, 66, 9))
+
+        throw new Error(message);
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>message : Symbol(message, Decl(neverReturningFunctions1.ts, 66, 9))
+    }
+    f1(x: string | undefined) {
+>f1 : Symbol(Test.f1, Decl(neverReturningFunctions1.ts, 68, 5))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 69, 7))
+
+        if (x === undefined) this.fail("undefined argument");
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 69, 7))
+>undefined : Symbol(undefined)
+>this.fail : Symbol(Test.fail, Decl(neverReturningFunctions1.ts, 65, 12))
+>this : Symbol(Test, Decl(neverReturningFunctions1.ts, 63, 1))
+>fail : Symbol(Test.fail, Decl(neverReturningFunctions1.ts, 65, 12))
+
+        x.length;  // string
+>x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 69, 7))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+    }
+    f2(x: number): number {
+>f2 : Symbol(Test.f2, Decl(neverReturningFunctions1.ts, 72, 5))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 73, 7))
+
+        if (x >= 0) return x;
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 73, 7))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 73, 7))
+
+        this.fail("negative number");
+>this.fail : Symbol(Test.fail, Decl(neverReturningFunctions1.ts, 65, 12))
+>this : Symbol(Test, Decl(neverReturningFunctions1.ts, 63, 1))
+>fail : Symbol(Test.fail, Decl(neverReturningFunctions1.ts, 65, 12))
+
+        x;  // Unreachable
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 73, 7))
+    }
+    f3(x: string) {
+>f3 : Symbol(Test.f3, Decl(neverReturningFunctions1.ts, 77, 5))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 78, 7))
+
+        x;  // string
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 78, 7))
+
+        this.fail();
+>this.fail : Symbol(Test.fail, Decl(neverReturningFunctions1.ts, 65, 12))
+>this : Symbol(Test, Decl(neverReturningFunctions1.ts, 63, 1))
+>fail : Symbol(Test.fail, Decl(neverReturningFunctions1.ts, 65, 12))
+
+        x;  // Unreachable
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 78, 7))
+    }
+}
+
+function f30(x: string | number | undefined) {
+>f30 : Symbol(f30, Decl(neverReturningFunctions1.ts, 83, 1))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 85, 13))
+
+    if (typeof x === "string") {
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 85, 13))
+
+        fail();
+>fail : Symbol(fail, Decl(neverReturningFunctions1.ts, 0, 0))
+
+        x;  // Unreachable
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 85, 13))
+    }
+    else {
+        x;  // number | undefined
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 85, 13))
+
+        if (x !== undefined) {
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 85, 13))
+>undefined : Symbol(undefined)
+
+            x;  // number
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 85, 13))
+
+            fail();
+>fail : Symbol(fail, Decl(neverReturningFunctions1.ts, 0, 0))
+
+            x;  // Unreachable
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 85, 13))
+        }
+        else {
+            x;  // undefined
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 85, 13))
+
+            fail();
+>fail : Symbol(fail, Decl(neverReturningFunctions1.ts, 0, 0))
+
+            x;  // Unreachable
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 85, 13))
+        }
+        x;  // Unreachable
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 85, 13))
+    }
+    x;  // Unreachable
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 85, 13))
+}
+
+function f31(x: { a: string | number }) {
+>f31 : Symbol(f31, Decl(neverReturningFunctions1.ts, 105, 1))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 107, 13))
+>a : Symbol(a, Decl(neverReturningFunctions1.ts, 107, 17))
+
+    if (typeof x.a === "string") {
+>x.a : Symbol(a, Decl(neverReturningFunctions1.ts, 107, 17))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 107, 13))
+>a : Symbol(a, Decl(neverReturningFunctions1.ts, 107, 17))
+
+        fail();
+>fail : Symbol(fail, Decl(neverReturningFunctions1.ts, 0, 0))
+
+        x;    // Unreachable
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 107, 13))
+
+        x.a;  // Unreachable
+>x.a : Symbol(a, Decl(neverReturningFunctions1.ts, 107, 17))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 107, 13))
+>a : Symbol(a, Decl(neverReturningFunctions1.ts, 107, 17))
+    }
+    x;    // { a: string | number }
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 107, 13))
+
+    x.a;  // number
+>x.a : Symbol(a, Decl(neverReturningFunctions1.ts, 107, 17))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 107, 13))
+>a : Symbol(a, Decl(neverReturningFunctions1.ts, 107, 17))
+}
+
+function f40(x: number) {
+>f40 : Symbol(f40, Decl(neverReturningFunctions1.ts, 115, 1))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 117, 13))
+
+    try {
+        x;
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 117, 13))
+
+        fail();
+>fail : Symbol(fail, Decl(neverReturningFunctions1.ts, 0, 0))
+
+        x;  // Unreachable
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 117, 13))
+    }
+    finally {
+        x;
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 117, 13))
+
+        fail();
+>fail : Symbol(fail, Decl(neverReturningFunctions1.ts, 0, 0))
+
+        x;  // Unreachable
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 117, 13))
+    }
+    x;  // Unreachable
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 117, 13))
+}
+
+function f41(x: number) {
+>f41 : Symbol(f41, Decl(neverReturningFunctions1.ts, 129, 1))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 131, 13))
+
+    try {
+        x;
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 131, 13))
+    }
+    finally {
+        x;
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 131, 13))
+
+        fail();
+>fail : Symbol(fail, Decl(neverReturningFunctions1.ts, 0, 0))
+
+        x;  // Unreachable
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 131, 13))
+    }
+    x;  // Unreachable
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 131, 13))
+}
+
+function f42(x: number) {
+>f42 : Symbol(f42, Decl(neverReturningFunctions1.ts, 141, 1))
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 143, 13))
+
+    try {
+        x;
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 143, 13))
+
+        fail();
+>fail : Symbol(fail, Decl(neverReturningFunctions1.ts, 0, 0))
+
+        x;  // Unreachable
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 143, 13))
+    }
+    finally {
+        x;
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 143, 13))
+    }
+    x;  // Unreachable
+>x : Symbol(x, Decl(neverReturningFunctions1.ts, 143, 13))
+}
+
diff --git a/tests/baselines/reference/neverReturningFunctions1.types b/tests/baselines/reference/neverReturningFunctions1.types
new file mode 100644
index 00000000000..e7d6afa36a5
--- /dev/null
+++ b/tests/baselines/reference/neverReturningFunctions1.types
@@ -0,0 +1,439 @@
+=== tests/cases/conformance/controlFlow/neverReturningFunctions1.ts ===
+function fail(message?: string): never {
+>fail : (message?: string | undefined) => never
+>message : string | undefined
+
+    throw new Error(message);
+>new Error(message) : Error
+>Error : ErrorConstructor
+>message : string | undefined
+}
+
+function f01(x: string | undefined) {
+>f01 : (x: string | undefined) => void
+>x : string | undefined
+
+    if (x === undefined) fail("undefined argument");
+>x === undefined : boolean
+>x : string | undefined
+>undefined : undefined
+>fail("undefined argument") : never
+>fail : (message?: string | undefined) => never
+>"undefined argument" : "undefined argument"
+
+    x.length;  // string
+>x.length : number
+>x : string
+>length : number
+}
+
+function f02(x: number): number {
+>f02 : (x: number) => number
+>x : number
+
+    if (x >= 0) return x;
+>x >= 0 : boolean
+>x : number
+>0 : 0
+>x : number
+
+    fail("negative number");
+>fail("negative number") : never
+>fail : (message?: string | undefined) => never
+>"negative number" : "negative number"
+
+    x;  // Unreachable
+>x : number
+}
+
+function f03(x: string) {
+>f03 : (x: string) => void
+>x : string
+
+    x;  // string
+>x : string
+
+    fail();
+>fail() : never
+>fail : (message?: string | undefined) => never
+
+    x;  // Unreachable
+>x : string
+}
+
+function f11(x: string | undefined, fail: (message?: string) => never) {
+>f11 : (x: string | undefined, fail: (message?: string | undefined) => never) => void
+>x : string | undefined
+>fail : (message?: string | undefined) => never
+>message : string | undefined
+
+    if (x === undefined) fail("undefined argument");
+>x === undefined : boolean
+>x : string | undefined
+>undefined : undefined
+>fail("undefined argument") : never
+>fail : (message?: string | undefined) => never
+>"undefined argument" : "undefined argument"
+
+    x.length;  // string
+>x.length : number
+>x : string
+>length : number
+}
+
+function f12(x: number, fail: (message?: string) => never): number {
+>f12 : (x: number, fail: (message?: string | undefined) => never) => number
+>x : number
+>fail : (message?: string | undefined) => never
+>message : string | undefined
+
+    if (x >= 0) return x;
+>x >= 0 : boolean
+>x : number
+>0 : 0
+>x : number
+
+    fail("negative number");
+>fail("negative number") : never
+>fail : (message?: string | undefined) => never
+>"negative number" : "negative number"
+
+    x;  // Unreachable
+>x : number
+}
+
+function f13(x: string, fail: (message?: string) => never) {
+>f13 : (x: string, fail: (message?: string | undefined) => never) => void
+>x : string
+>fail : (message?: string | undefined) => never
+>message : string | undefined
+
+    x;  // string
+>x : string
+
+    fail();
+>fail() : never
+>fail : (message?: string | undefined) => never
+
+    x;  // Unreachable
+>x : string
+}
+
+namespace Debug {
+>Debug : typeof Debug
+
+    export declare function fail(message?: string): never;
+>fail : (message?: string | undefined) => never
+>message : string | undefined
+}
+
+function f21(x: string | undefined) {
+>f21 : (x: string | undefined) => void
+>x : string | undefined
+
+    if (x === undefined) Debug.fail("undefined argument");
+>x === undefined : boolean
+>x : string | undefined
+>undefined : undefined
+>Debug.fail("undefined argument") : never
+>Debug.fail : (message?: string | undefined) => never
+>Debug : typeof Debug
+>fail : (message?: string | undefined) => never
+>"undefined argument" : "undefined argument"
+
+    x.length;  // string
+>x.length : number
+>x : string
+>length : number
+}
+
+function f22(x: number): number {
+>f22 : (x: number) => number
+>x : number
+
+    if (x >= 0) return x;
+>x >= 0 : boolean
+>x : number
+>0 : 0
+>x : number
+
+    Debug.fail("negative number");
+>Debug.fail("negative number") : never
+>Debug.fail : (message?: string | undefined) => never
+>Debug : typeof Debug
+>fail : (message?: string | undefined) => never
+>"negative number" : "negative number"
+
+    x;  // Unreachable
+>x : number
+}
+
+function f23(x: string) {
+>f23 : (x: string) => void
+>x : string
+
+    x;  // string
+>x : string
+
+    Debug.fail();
+>Debug.fail() : never
+>Debug.fail : (message?: string | undefined) => never
+>Debug : typeof Debug
+>fail : (message?: string | undefined) => never
+
+    x;  // Unreachable
+>x : string
+}
+
+function f24(x: string) {
+>f24 : (x: string) => void
+>x : string
+
+    x;  // string
+>x : string
+
+    ((Debug).fail)();
+>((Debug).fail)() : never
+>((Debug).fail) : (message?: string | undefined) => never
+>(Debug).fail : (message?: string | undefined) => never
+>(Debug) : typeof Debug
+>Debug : typeof Debug
+>fail : (message?: string | undefined) => never
+
+    x;  // Unreachable
+>x : string
+}
+
+class Test {
+>Test : Test
+
+    fail(message?: string): never {
+>fail : (message?: string | undefined) => never
+>message : string | undefined
+
+        throw new Error(message);
+>new Error(message) : Error
+>Error : ErrorConstructor
+>message : string | undefined
+    }
+    f1(x: string | undefined) {
+>f1 : (x: string | undefined) => void
+>x : string | undefined
+
+        if (x === undefined) this.fail("undefined argument");
+>x === undefined : boolean
+>x : string | undefined
+>undefined : undefined
+>this.fail("undefined argument") : never
+>this.fail : (message?: string | undefined) => never
+>this : this
+>fail : (message?: string | undefined) => never
+>"undefined argument" : "undefined argument"
+
+        x.length;  // string
+>x.length : number
+>x : string
+>length : number
+    }
+    f2(x: number): number {
+>f2 : (x: number) => number
+>x : number
+
+        if (x >= 0) return x;
+>x >= 0 : boolean
+>x : number
+>0 : 0
+>x : number
+
+        this.fail("negative number");
+>this.fail("negative number") : never
+>this.fail : (message?: string | undefined) => never
+>this : this
+>fail : (message?: string | undefined) => never
+>"negative number" : "negative number"
+
+        x;  // Unreachable
+>x : number
+    }
+    f3(x: string) {
+>f3 : (x: string) => void
+>x : string
+
+        x;  // string
+>x : string
+
+        this.fail();
+>this.fail() : never
+>this.fail : (message?: string | undefined) => never
+>this : this
+>fail : (message?: string | undefined) => never
+
+        x;  // Unreachable
+>x : string
+    }
+}
+
+function f30(x: string | number | undefined) {
+>f30 : (x: string | number | undefined) => void
+>x : string | number | undefined
+
+    if (typeof x === "string") {
+>typeof x === "string" : boolean
+>typeof x : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
+>x : string | number | undefined
+>"string" : "string"
+
+        fail();
+>fail() : never
+>fail : (message?: string | undefined) => never
+
+        x;  // Unreachable
+>x : string | number | undefined
+    }
+    else {
+        x;  // number | undefined
+>x : number | undefined
+
+        if (x !== undefined) {
+>x !== undefined : boolean
+>x : number | undefined
+>undefined : undefined
+
+            x;  // number
+>x : number
+
+            fail();
+>fail() : never
+>fail : (message?: string | undefined) => never
+
+            x;  // Unreachable
+>x : string | number | undefined
+        }
+        else {
+            x;  // undefined
+>x : undefined
+
+            fail();
+>fail() : never
+>fail : (message?: string | undefined) => never
+
+            x;  // Unreachable
+>x : string | number | undefined
+        }
+        x;  // Unreachable
+>x : string | number | undefined
+    }
+    x;  // Unreachable
+>x : string | number | undefined
+}
+
+function f31(x: { a: string | number }) {
+>f31 : (x: { a: string | number; }) => void
+>x : { a: string | number; }
+>a : string | number
+
+    if (typeof x.a === "string") {
+>typeof x.a === "string" : boolean
+>typeof x.a : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
+>x.a : string | number
+>x : { a: string | number; }
+>a : string | number
+>"string" : "string"
+
+        fail();
+>fail() : never
+>fail : (message?: string | undefined) => never
+
+        x;    // Unreachable
+>x : { a: string | number; }
+
+        x.a;  // Unreachable
+>x.a : string | number
+>x : { a: string | number; }
+>a : string | number
+    }
+    x;    // { a: string | number }
+>x : { a: string | number; }
+
+    x.a;  // number
+>x.a : number
+>x : { a: string | number; }
+>a : number
+}
+
+function f40(x: number) {
+>f40 : (x: number) => void
+>x : number
+
+    try {
+        x;
+>x : number
+
+        fail();
+>fail() : never
+>fail : (message?: string | undefined) => never
+
+        x;  // Unreachable
+>x : number
+    }
+    finally {
+        x;
+>x : number
+
+        fail();
+>fail() : never
+>fail : (message?: string | undefined) => never
+
+        x;  // Unreachable
+>x : number
+    }
+    x;  // Unreachable
+>x : number
+}
+
+function f41(x: number) {
+>f41 : (x: number) => void
+>x : number
+
+    try {
+        x;
+>x : number
+    }
+    finally {
+        x;
+>x : number
+
+        fail();
+>fail() : never
+>fail : (message?: string | undefined) => never
+
+        x;  // Unreachable
+>x : number
+    }
+    x;  // Unreachable
+>x : number
+}
+
+function f42(x: number) {
+>f42 : (x: number) => void
+>x : number
+
+    try {
+        x;
+>x : number
+
+        fail();
+>fail() : never
+>fail : (message?: string | undefined) => never
+
+        x;  // Unreachable
+>x : number
+    }
+    finally {
+        x;
+>x : number
+    }
+    x;  // Unreachable
+>x : number
+}
+
diff --git a/tests/baselines/reference/objectTypeHidingMembersOfObjectAssignmentCompat.errors.txt b/tests/baselines/reference/objectTypeHidingMembersOfObjectAssignmentCompat.errors.txt
index c4ee3ea17b2..d4afd97723e 100644
--- a/tests/baselines/reference/objectTypeHidingMembersOfObjectAssignmentCompat.errors.txt
+++ b/tests/baselines/reference/objectTypeHidingMembersOfObjectAssignmentCompat.errors.txt
@@ -1,15 +1,12 @@
 tests/cases/conformance/types/members/objectTypeHidingMembersOfObjectAssignmentCompat.ts(7,1): error TS2322: Type 'I' is not assignable to type 'Object'.
-  Types of property 'toString' are incompatible.
-    Type '() => void' is not assignable to type '() => string'.
-      Type 'void' is not assignable to type 'string'.
+  The types returned by 'toString()' are incompatible between these types.
+    Type 'void' is not assignable to type 'string'.
 tests/cases/conformance/types/members/objectTypeHidingMembersOfObjectAssignmentCompat.ts(14,1): error TS2322: Type 'C' is not assignable to type 'Object'.
-  Types of property 'toString' are incompatible.
-    Type '() => void' is not assignable to type '() => string'.
-      Type 'void' is not assignable to type 'string'.
+  The types returned by 'toString()' are incompatible between these types.
+    Type 'void' is not assignable to type 'string'.
 tests/cases/conformance/types/members/objectTypeHidingMembersOfObjectAssignmentCompat.ts(20,1): error TS2322: Type '{ toString: () => void; }' is not assignable to type 'Object'.
-  Types of property 'toString' are incompatible.
-    Type '() => void' is not assignable to type '() => string'.
-      Type 'void' is not assignable to type 'string'.
+  The types returned by 'toString()' are incompatible between these types.
+    Type 'void' is not assignable to type 'string'.
 
 
 ==== tests/cases/conformance/types/members/objectTypeHidingMembersOfObjectAssignmentCompat.ts (3 errors) ====
@@ -22,9 +19,8 @@ tests/cases/conformance/types/members/objectTypeHidingMembersOfObjectAssignmentC
     o = i; // error
     ~
 !!! error TS2322: Type 'I' is not assignable to type 'Object'.
-!!! error TS2322:   Types of property 'toString' are incompatible.
-!!! error TS2322:     Type '() => void' is not assignable to type '() => string'.
-!!! error TS2322:       Type 'void' is not assignable to type 'string'.
+!!! error TS2322:   The types returned by 'toString()' are incompatible between these types.
+!!! error TS2322:     Type 'void' is not assignable to type 'string'.
     i = o; // ok
     
     class C {
@@ -34,9 +30,8 @@ tests/cases/conformance/types/members/objectTypeHidingMembersOfObjectAssignmentC
     o = c; // error
     ~
 !!! error TS2322: Type 'C' is not assignable to type 'Object'.
-!!! error TS2322:   Types of property 'toString' are incompatible.
-!!! error TS2322:     Type '() => void' is not assignable to type '() => string'.
-!!! error TS2322:       Type 'void' is not assignable to type 'string'.
+!!! error TS2322:   The types returned by 'toString()' are incompatible between these types.
+!!! error TS2322:     Type 'void' is not assignable to type 'string'.
     c = o; // ok
     
     var a = {
@@ -45,7 +40,6 @@ tests/cases/conformance/types/members/objectTypeHidingMembersOfObjectAssignmentC
     o = a; // error
     ~
 !!! error TS2322: Type '{ toString: () => void; }' is not assignable to type 'Object'.
-!!! error TS2322:   Types of property 'toString' are incompatible.
-!!! error TS2322:     Type '() => void' is not assignable to type '() => string'.
-!!! error TS2322:       Type 'void' is not assignable to type 'string'.
+!!! error TS2322:   The types returned by 'toString()' are incompatible between these types.
+!!! error TS2322:     Type 'void' is not assignable to type 'string'.
     a = o; // ok
\ No newline at end of file
diff --git a/tests/baselines/reference/objectTypeHidingMembersOfObjectAssignmentCompat2.errors.txt b/tests/baselines/reference/objectTypeHidingMembersOfObjectAssignmentCompat2.errors.txt
index 3e27b22240e..28d466457d7 100644
--- a/tests/baselines/reference/objectTypeHidingMembersOfObjectAssignmentCompat2.errors.txt
+++ b/tests/baselines/reference/objectTypeHidingMembersOfObjectAssignmentCompat2.errors.txt
@@ -1,25 +1,18 @@
 tests/cases/conformance/types/members/objectTypeHidingMembersOfObjectAssignmentCompat2.ts(7,1): error TS2322: Type 'I' is not assignable to type 'Object'.
-  Types of property 'toString' are incompatible.
-    Type '() => number' is not assignable to type '() => string'.
-      Type 'number' is not assignable to type 'string'.
-tests/cases/conformance/types/members/objectTypeHidingMembersOfObjectAssignmentCompat2.ts(8,1): error TS2322: Type 'Object' is not assignable to type 'I'.
-  The 'Object' type is assignable to very few other types. Did you mean to use the 'any' type instead?
-    Types of property 'toString' are incompatible.
-      Type '() => string' is not assignable to type '() => number'.
-        Type 'string' is not assignable to type 'number'.
+  The types returned by 'toString()' are incompatible between these types.
+    Type 'number' is not assignable to type 'string'.
+tests/cases/conformance/types/members/objectTypeHidingMembersOfObjectAssignmentCompat2.ts(8,1): error TS2696: The 'Object' type is assignable to very few other types. Did you mean to use the 'any' type instead?
+  The types returned by 'toString()' are incompatible between these types.
+    Type 'string' is not assignable to type 'number'.
 tests/cases/conformance/types/members/objectTypeHidingMembersOfObjectAssignmentCompat2.ts(14,1): error TS2322: Type 'C' is not assignable to type 'Object'.
-  Types of property 'toString' are incompatible.
-    Type '() => number' is not assignable to type '() => string'.
-      Type 'number' is not assignable to type 'string'.
-tests/cases/conformance/types/members/objectTypeHidingMembersOfObjectAssignmentCompat2.ts(15,1): error TS2322: Type 'Object' is not assignable to type 'C'.
-  The 'Object' type is assignable to very few other types. Did you mean to use the 'any' type instead?
-    Types of property 'toString' are incompatible.
-      Type '() => string' is not assignable to type '() => number'.
-        Type 'string' is not assignable to type 'number'.
+  The types returned by 'toString()' are incompatible between these types.
+    Type 'number' is not assignable to type 'string'.
+tests/cases/conformance/types/members/objectTypeHidingMembersOfObjectAssignmentCompat2.ts(15,1): error TS2696: The 'Object' type is assignable to very few other types. Did you mean to use the 'any' type instead?
+  The types returned by 'toString()' are incompatible between these types.
+    Type 'string' is not assignable to type 'number'.
 tests/cases/conformance/types/members/objectTypeHidingMembersOfObjectAssignmentCompat2.ts(20,1): error TS2322: Type '{ toString: () => void; }' is not assignable to type 'Object'.
-  Types of property 'toString' are incompatible.
-    Type '() => void' is not assignable to type '() => string'.
-      Type 'void' is not assignable to type 'string'.
+  The types returned by 'toString()' are incompatible between these types.
+    Type 'void' is not assignable to type 'string'.
 
 
 ==== tests/cases/conformance/types/members/objectTypeHidingMembersOfObjectAssignmentCompat2.ts (5 errors) ====
@@ -32,16 +25,13 @@ tests/cases/conformance/types/members/objectTypeHidingMembersOfObjectAssignmentC
     o = i; // error
     ~
 !!! error TS2322: Type 'I' is not assignable to type 'Object'.
-!!! error TS2322:   Types of property 'toString' are incompatible.
-!!! error TS2322:     Type '() => number' is not assignable to type '() => string'.
-!!! error TS2322:       Type 'number' is not assignable to type 'string'.
+!!! error TS2322:   The types returned by 'toString()' are incompatible between these types.
+!!! error TS2322:     Type 'number' is not assignable to type 'string'.
     i = o; // error
     ~
-!!! error TS2322: Type 'Object' is not assignable to type 'I'.
-!!! error TS2322:   The 'Object' type is assignable to very few other types. Did you mean to use the 'any' type instead?
-!!! error TS2322:     Types of property 'toString' are incompatible.
-!!! error TS2322:       Type '() => string' is not assignable to type '() => number'.
-!!! error TS2322:         Type 'string' is not assignable to type 'number'.
+!!! error TS2696: The 'Object' type is assignable to very few other types. Did you mean to use the 'any' type instead?
+!!! error TS2696:   The types returned by 'toString()' are incompatible between these types.
+!!! error TS2696:     Type 'string' is not assignable to type 'number'.
     
     class C {
         toString(): number { return 1; }
@@ -50,16 +40,13 @@ tests/cases/conformance/types/members/objectTypeHidingMembersOfObjectAssignmentC
     o = c; // error
     ~
 !!! error TS2322: Type 'C' is not assignable to type 'Object'.
-!!! error TS2322:   Types of property 'toString' are incompatible.
-!!! error TS2322:     Type '() => number' is not assignable to type '() => string'.
-!!! error TS2322:       Type 'number' is not assignable to type 'string'.
+!!! error TS2322:   The types returned by 'toString()' are incompatible between these types.
+!!! error TS2322:     Type 'number' is not assignable to type 'string'.
     c = o; // error
     ~
-!!! error TS2322: Type 'Object' is not assignable to type 'C'.
-!!! error TS2322:   The 'Object' type is assignable to very few other types. Did you mean to use the 'any' type instead?
-!!! error TS2322:     Types of property 'toString' are incompatible.
-!!! error TS2322:       Type '() => string' is not assignable to type '() => number'.
-!!! error TS2322:         Type 'string' is not assignable to type 'number'.
+!!! error TS2696: The 'Object' type is assignable to very few other types. Did you mean to use the 'any' type instead?
+!!! error TS2696:   The types returned by 'toString()' are incompatible between these types.
+!!! error TS2696:     Type 'string' is not assignable to type 'number'.
     
     var a = {
         toString: () => { }
@@ -67,7 +54,6 @@ tests/cases/conformance/types/members/objectTypeHidingMembersOfObjectAssignmentC
     o = a; // error
     ~
 !!! error TS2322: Type '{ toString: () => void; }' is not assignable to type 'Object'.
-!!! error TS2322:   Types of property 'toString' are incompatible.
-!!! error TS2322:     Type '() => void' is not assignable to type '() => string'.
-!!! error TS2322:       Type 'void' is not assignable to type 'string'.
+!!! error TS2322:   The types returned by 'toString()' are incompatible between these types.
+!!! error TS2322:     Type 'void' is not assignable to type 'string'.
     a = o; // ok
\ No newline at end of file
diff --git a/tests/baselines/reference/promisePermutations.errors.txt b/tests/baselines/reference/promisePermutations.errors.txt
index 1cb61562fe3..87743ab77a3 100644
--- a/tests/baselines/reference/promisePermutations.errors.txt
+++ b/tests/baselines/reference/promisePermutations.errors.txt
@@ -122,8 +122,8 @@ tests/cases/compiler/promisePermutations.ts(159,21): error TS2769: No overload m
 tests/cases/compiler/promisePermutations.ts(160,21): error TS2769: No overload matches this call.
   The last overload gave the following error.
     Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
-      Type 'Promise<number>' is not assignable to type 'IPromise<string>'.
-        Types of property 'then' are incompatible.
+      Call signature return types 'Promise<number>' and 'IPromise<string>' are incompatible.
+        The types of 'then' are incompatible between these types.
           Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }'.
             Types of parameters 'onfulfilled' and 'success' are incompatible.
               Types of parameters 'value' and 'value' are incompatible.
@@ -481,8 +481,8 @@ tests/cases/compiler/promisePermutations.ts(160,21): error TS2769: No overload m
 !!! error TS2769: No overload matches this call.
 !!! error TS2769:   The last overload gave the following error.
 !!! error TS2769:     Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
-!!! error TS2769:       Type 'Promise<number>' is not assignable to type 'IPromise<string>'.
-!!! error TS2769:         Types of property 'then' are incompatible.
+!!! error TS2769:       Call signature return types 'Promise<number>' and 'IPromise<string>' are incompatible.
+!!! error TS2769:         The types of 'then' are incompatible between these types.
 !!! error TS2769:           Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }'.
 !!! error TS2769:             Types of parameters 'onfulfilled' and 'success' are incompatible.
 !!! error TS2769:               Types of parameters 'value' and 'value' are incompatible.
diff --git a/tests/baselines/reference/promisePermutations2.errors.txt b/tests/baselines/reference/promisePermutations2.errors.txt
index d601a5049bf..b69eaab3157 100644
--- a/tests/baselines/reference/promisePermutations2.errors.txt
+++ b/tests/baselines/reference/promisePermutations2.errors.txt
@@ -80,8 +80,8 @@ tests/cases/compiler/promisePermutations2.ts(158,21): error TS2345: Argument of
   Type 'Promise<number>' is not assignable to type 'Promise<string>'.
     Type 'number' is not assignable to type 'string'.
 tests/cases/compiler/promisePermutations2.ts(159,21): error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
-  Type 'Promise<number>' is not assignable to type 'IPromise<string>'.
-    Types of property 'then' are incompatible.
+  Call signature return types 'Promise<number>' and 'IPromise<string>' are incompatible.
+    The types of 'then' are incompatible between these types.
       Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }'.
         Types of parameters 'onfulfilled' and 'success' are incompatible.
           Types of parameters 'value' and 'value' are incompatible.
@@ -376,8 +376,8 @@ tests/cases/compiler/promisePermutations2.ts(159,21): error TS2345: Argument of
     var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // ok
                         ~~~~~~~~~~~~~~~
 !!! error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
-!!! error TS2345:   Type 'Promise<number>' is not assignable to type 'IPromise<string>'.
-!!! error TS2345:     Types of property 'then' are incompatible.
+!!! error TS2345:   Call signature return types 'Promise<number>' and 'IPromise<string>' are incompatible.
+!!! error TS2345:     The types of 'then' are incompatible between these types.
 !!! error TS2345:       Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }'.
 !!! error TS2345:         Types of parameters 'onfulfilled' and 'success' are incompatible.
 !!! error TS2345:           Types of parameters 'value' and 'value' are incompatible.
diff --git a/tests/baselines/reference/promisePermutations3.errors.txt b/tests/baselines/reference/promisePermutations3.errors.txt
index d3574d2a4c3..929b0d5459c 100644
--- a/tests/baselines/reference/promisePermutations3.errors.txt
+++ b/tests/baselines/reference/promisePermutations3.errors.txt
@@ -101,8 +101,8 @@ tests/cases/compiler/promisePermutations3.ts(158,21): error TS2769: No overload
 tests/cases/compiler/promisePermutations3.ts(159,21): error TS2769: No overload matches this call.
   The last overload gave the following error.
     Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
-      Type 'Promise<number>' is not assignable to type 'IPromise<string>'.
-        Types of property 'then' are incompatible.
+      Call signature return types 'Promise<number>' and 'IPromise<string>' are incompatible.
+        The types of 'then' are incompatible between these types.
           Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '<U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>'.
             Types of parameters 'onfulfilled' and 'success' are incompatible.
               Types of parameters 'value' and 'value' are incompatible.
@@ -429,8 +429,8 @@ tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of
 !!! error TS2769: No overload matches this call.
 !!! error TS2769:   The last overload gave the following error.
 !!! error TS2769:     Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
-!!! error TS2769:       Type 'Promise<number>' is not assignable to type 'IPromise<string>'.
-!!! error TS2769:         Types of property 'then' are incompatible.
+!!! error TS2769:       Call signature return types 'Promise<number>' and 'IPromise<string>' are incompatible.
+!!! error TS2769:         The types of 'then' are incompatible between these types.
 !!! error TS2769:           Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '<U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>'.
 !!! error TS2769:             Types of parameters 'onfulfilled' and 'success' are incompatible.
 !!! error TS2769:               Types of parameters 'value' and 'value' are incompatible.
diff --git a/tests/baselines/reference/promiseTypeInference.errors.txt b/tests/baselines/reference/promiseTypeInference.errors.txt
index 04ba3a0d878..7056e35432f 100644
--- a/tests/baselines/reference/promiseTypeInference.errors.txt
+++ b/tests/baselines/reference/promiseTypeInference.errors.txt
@@ -5,10 +5,9 @@ tests/cases/compiler/promiseTypeInference.ts(10,39): error TS2769: No overload m
     Type 'IPromise<number>' is not assignable to type 'number | PromiseLike<number>'.
       Type 'IPromise<number>' is not assignable to type 'PromiseLike<number>'.
         Types of property 'then' are incompatible.
-          Type '<U>(success?: (value: number) => IPromise<U>) => IPromise<U>' is not assignable to type '<TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => PromiseLike<TResult1 | TResult2>'.
-            Types of parameters 'success' and 'onfulfilled' are incompatible.
-              Type 'TResult1 | PromiseLike<TResult1>' is not assignable to type 'IPromise<TResult1 | TResult2>'.
-                Type 'TResult1' is not assignable to type 'IPromise<TResult1 | TResult2>'.
+          Types of parameters 'success' and 'onfulfilled' are incompatible.
+            Type 'TResult1 | PromiseLike<TResult1>' is not assignable to type 'IPromise<TResult1 | TResult2>'.
+              Type 'TResult1' is not assignable to type 'IPromise<TResult1 | TResult2>'.
 
 
 ==== tests/cases/compiler/promiseTypeInference.ts (1 errors) ====
@@ -30,10 +29,9 @@ tests/cases/compiler/promiseTypeInference.ts(10,39): error TS2769: No overload m
 !!! error TS2769:     Type 'IPromise<number>' is not assignable to type 'number | PromiseLike<number>'.
 !!! error TS2769:       Type 'IPromise<number>' is not assignable to type 'PromiseLike<number>'.
 !!! error TS2769:         Types of property 'then' are incompatible.
-!!! error TS2769:           Type '<U>(success?: (value: number) => IPromise<U>) => IPromise<U>' is not assignable to type '<TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => PromiseLike<TResult1 | TResult2>'.
-!!! error TS2769:             Types of parameters 'success' and 'onfulfilled' are incompatible.
-!!! error TS2769:               Type 'TResult1 | PromiseLike<TResult1>' is not assignable to type 'IPromise<TResult1 | TResult2>'.
-!!! error TS2769:                 Type 'TResult1' is not assignable to type 'IPromise<TResult1 | TResult2>'.
+!!! error TS2769:           Types of parameters 'success' and 'onfulfilled' are incompatible.
+!!! error TS2769:             Type 'TResult1 | PromiseLike<TResult1>' is not assignable to type 'IPromise<TResult1 | TResult2>'.
+!!! error TS2769:               Type 'TResult1' is not assignable to type 'IPromise<TResult1 | TResult2>'.
 !!! related TS2728 /.ts/lib.es5.d.ts:1413:5: 'catch' is declared here.
 !!! related TS6502 tests/cases/compiler/promiseTypeInference.ts:2:23: The expected type comes from the return type of this signature.
 !!! related TS6502 /.ts/lib.es5.d.ts:1406:57: The expected type comes from the return type of this signature.
diff --git a/tests/baselines/reference/showConfig/Shows tsconfig for single option/disableSourceOfProjectReferenceRedirect/tsconfig.json b/tests/baselines/reference/showConfig/Shows tsconfig for single option/disableSourceOfProjectReferenceRedirect/tsconfig.json
new file mode 100644
index 00000000000..c8b95e0909d
--- /dev/null
+++ b/tests/baselines/reference/showConfig/Shows tsconfig for single option/disableSourceOfProjectReferenceRedirect/tsconfig.json	
@@ -0,0 +1,5 @@
+{
+    "compilerOptions": {
+        "disableSourceOfProjectReferenceRedirect": true
+    }
+}
diff --git a/tests/baselines/reference/strictFunctionTypesErrors.errors.txt b/tests/baselines/reference/strictFunctionTypesErrors.errors.txt
index 3ff04c44fb7..6f474663dcb 100644
--- a/tests/baselines/reference/strictFunctionTypesErrors.errors.txt
+++ b/tests/baselines/reference/strictFunctionTypesErrors.errors.txt
@@ -69,9 +69,8 @@ tests/cases/compiler/strictFunctionTypesErrors.ts(126,1): error TS2322: Type 'Cr
 tests/cases/compiler/strictFunctionTypesErrors.ts(127,1): error TS2322: Type 'Crate<Animal>' is not assignable to type 'Crate<Dog>'.
   Types of property 'item' are incompatible.
     Type 'Animal' is not assignable to type 'Dog'.
-tests/cases/compiler/strictFunctionTypesErrors.ts(133,1): error TS2322: Type '(f: (x: Dog) => Dog) => void' is not assignable to type '(f: (x: Animal) => Animal) => void'.
-  Types of parameters 'f' and 'f' are incompatible.
-    Type 'Animal' is not assignable to type 'Dog'.
+tests/cases/compiler/strictFunctionTypesErrors.ts(133,1): error TS2328: Types of parameters 'f' and 'f' are incompatible.
+  Type 'Animal' is not assignable to type 'Dog'.
 tests/cases/compiler/strictFunctionTypesErrors.ts(134,1): error TS2322: Type '(f: (x: Animal) => Animal) => void' is not assignable to type '(f: (x: Dog) => Dog) => void'.
   Types of parameters 'f' and 'f' are incompatible.
     Types of parameters 'x' and 'x' are incompatible.
@@ -324,9 +323,8 @@ tests/cases/compiler/strictFunctionTypesErrors.ts(155,5): error TS2322: Type '(c
     declare let fc2: (f: (x: Dog) => Dog) => void;
     fc1 = fc2;  // Error
     ~~~
-!!! error TS2322: Type '(f: (x: Dog) => Dog) => void' is not assignable to type '(f: (x: Animal) => Animal) => void'.
-!!! error TS2322:   Types of parameters 'f' and 'f' are incompatible.
-!!! error TS2322:     Type 'Animal' is not assignable to type 'Dog'.
+!!! error TS2328: Types of parameters 'f' and 'f' are incompatible.
+!!! error TS2328:   Type 'Animal' is not assignable to type 'Dog'.
     fc2 = fc1;  // Error
     ~~~
 !!! error TS2322: Type '(f: (x: Animal) => Animal) => void' is not assignable to type '(f: (x: Dog) => Dog) => void'.
diff --git a/tests/baselines/reference/subtypingWithCallSignaturesWithSpecializedSignatures.errors.txt b/tests/baselines/reference/subtypingWithCallSignaturesWithSpecializedSignatures.errors.txt
index 7dfb078170a..b8bc5100402 100644
--- a/tests/baselines/reference/subtypingWithCallSignaturesWithSpecializedSignatures.errors.txt
+++ b/tests/baselines/reference/subtypingWithCallSignaturesWithSpecializedSignatures.errors.txt
@@ -1,12 +1,10 @@
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithCallSignaturesWithSpecializedSignatures.ts(70,15): error TS2430: Interface 'I2' incorrectly extends interface 'Base2'.
-  Types of property 'a' are incompatible.
-    Type '(x: string) => string' is not assignable to type '{ (x: "a"): number; (x: string): number; }'.
-      Type 'string' is not assignable to type 'number'.
+  The types returned by 'a(...)' are incompatible between these types.
+    Type 'string' is not assignable to type 'number'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithCallSignaturesWithSpecializedSignatures.ts(76,15): error TS2430: Interface 'I3' incorrectly extends interface 'Base2'.
-  Types of property 'a2' are incompatible.
-    Type '<T>(x: T) => string' is not assignable to type '<T>(x: T) => T'.
-      Type 'string' is not assignable to type 'T'.
-        'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+  The types returned by 'a2(...)' are incompatible between these types.
+    Type 'string' is not assignable to type 'T'.
+      'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
 
 
 ==== tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithCallSignaturesWithSpecializedSignatures.ts (2 errors) ====
@@ -82,9 +80,8 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingW
         interface I2 extends Base2 {
                   ~~
 !!! error TS2430: Interface 'I2' incorrectly extends interface 'Base2'.
-!!! error TS2430:   Types of property 'a' are incompatible.
-!!! error TS2430:     Type '(x: string) => string' is not assignable to type '{ (x: "a"): number; (x: string): number; }'.
-!!! error TS2430:       Type 'string' is not assignable to type 'number'.
+!!! error TS2430:   The types returned by 'a(...)' are incompatible between these types.
+!!! error TS2430:     Type 'string' is not assignable to type 'number'.
             // N's
             a: (x: string) => string; // error because base returns non-void;
         }
@@ -93,10 +90,9 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingW
         interface I3 extends Base2 {
                   ~~
 !!! error TS2430: Interface 'I3' incorrectly extends interface 'Base2'.
-!!! error TS2430:   Types of property 'a2' are incompatible.
-!!! error TS2430:     Type '<T>(x: T) => string' is not assignable to type '<T>(x: T) => T'.
-!!! error TS2430:       Type 'string' is not assignable to type 'T'.
-!!! error TS2430:         'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+!!! error TS2430:   The types returned by 'a2(...)' are incompatible between these types.
+!!! error TS2430:     Type 'string' is not assignable to type 'T'.
+!!! error TS2430:       'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
             // N's
             a2: <T>(x: T) => string; // error because base returns non-void;
         }
diff --git a/tests/baselines/reference/subtypingWithConstructSignaturesWithSpecializedSignatures.errors.txt b/tests/baselines/reference/subtypingWithConstructSignaturesWithSpecializedSignatures.errors.txt
index 8f4a219407a..db493045f09 100644
--- a/tests/baselines/reference/subtypingWithConstructSignaturesWithSpecializedSignatures.errors.txt
+++ b/tests/baselines/reference/subtypingWithConstructSignaturesWithSpecializedSignatures.errors.txt
@@ -1,12 +1,10 @@
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithConstructSignaturesWithSpecializedSignatures.ts(70,15): error TS2430: Interface 'I2' incorrectly extends interface 'Base2'.
-  Types of property 'a' are incompatible.
-    Type 'new (x: string) => string' is not assignable to type '{ new (x: "a"): number; new (x: string): number; }'.
-      Type 'string' is not assignable to type 'number'.
+  The types returned by 'new a(...)' are incompatible between these types.
+    Type 'string' is not assignable to type 'number'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithConstructSignaturesWithSpecializedSignatures.ts(76,15): error TS2430: Interface 'I3' incorrectly extends interface 'Base2'.
-  Types of property 'a2' are incompatible.
-    Type 'new <T>(x: T) => string' is not assignable to type 'new <T>(x: T) => T'.
-      Type 'string' is not assignable to type 'T'.
-        'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+  The types returned by 'new a2(...)' are incompatible between these types.
+    Type 'string' is not assignable to type 'T'.
+      'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
 
 
 ==== tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithConstructSignaturesWithSpecializedSignatures.ts (2 errors) ====
@@ -82,9 +80,8 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingW
         interface I2 extends Base2 {
                   ~~
 !!! error TS2430: Interface 'I2' incorrectly extends interface 'Base2'.
-!!! error TS2430:   Types of property 'a' are incompatible.
-!!! error TS2430:     Type 'new (x: string) => string' is not assignable to type '{ new (x: "a"): number; new (x: string): number; }'.
-!!! error TS2430:       Type 'string' is not assignable to type 'number'.
+!!! error TS2430:   The types returned by 'new a(...)' are incompatible between these types.
+!!! error TS2430:     Type 'string' is not assignable to type 'number'.
             // N's
             a: new (x: string) => string; // error because base returns non-void;
         }
@@ -93,10 +90,9 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingW
         interface I3 extends Base2 {
                   ~~
 !!! error TS2430: Interface 'I3' incorrectly extends interface 'Base2'.
-!!! error TS2430:   Types of property 'a2' are incompatible.
-!!! error TS2430:     Type 'new <T>(x: T) => string' is not assignable to type 'new <T>(x: T) => T'.
-!!! error TS2430:       Type 'string' is not assignable to type 'T'.
-!!! error TS2430:         'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+!!! error TS2430:   The types returned by 'new a2(...)' are incompatible between these types.
+!!! error TS2430:     Type 'string' is not assignable to type 'T'.
+!!! error TS2430:       'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
             // N's
             a2: new <T>(x: T) => string; // error because base returns non-void;
         }
diff --git a/tests/baselines/reference/subtypingWithGenericCallSignaturesWithOptionalParameters.errors.txt b/tests/baselines/reference/subtypingWithGenericCallSignaturesWithOptionalParameters.errors.txt
index 36380fc97f4..4e0ef2113ec 100644
--- a/tests/baselines/reference/subtypingWithGenericCallSignaturesWithOptionalParameters.errors.txt
+++ b/tests/baselines/reference/subtypingWithGenericCallSignaturesWithOptionalParameters.errors.txt
@@ -5,23 +5,20 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingW
   Types of property 'a3' are incompatible.
     Type '(x: T, y: T) => T' is not assignable to type '(x: T) => T'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithGenericCallSignaturesWithOptionalParameters.ts(100,15): error TS2430: Interface 'I1<T>' incorrectly extends interface 'Base2'.
-  Types of property 'a' are incompatible.
-    Type '() => T' is not assignable to type '<T>() => T'.
-      Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
-        'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+  The types returned by 'a()' are incompatible between these types.
+    Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
+      'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithGenericCallSignaturesWithOptionalParameters.ts(104,15): error TS2430: Interface 'I2<T>' incorrectly extends interface 'Base2'.
-  Types of property 'a' are incompatible.
-    Type '(x?: T) => T' is not assignable to type '<T>() => T'.
-      Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
-        'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+  The types returned by 'a(...)' are incompatible between these types.
+    Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
+      'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithGenericCallSignaturesWithOptionalParameters.ts(108,15): error TS2430: Interface 'I3<T>' incorrectly extends interface 'Base2'.
   Types of property 'a' are incompatible.
     Type '(x: T) => T' is not assignable to type '<T>() => T'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithGenericCallSignaturesWithOptionalParameters.ts(113,15): error TS2430: Interface 'I4<T>' incorrectly extends interface 'Base2'.
-  Types of property 'a2' are incompatible.
-    Type '() => T' is not assignable to type '<T>(x?: T) => T'.
-      Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
-        'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+  The types returned by 'a2(...)' are incompatible between these types.
+    Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
+      'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithGenericCallSignaturesWithOptionalParameters.ts(117,15): error TS2430: Interface 'I5<T>' incorrectly extends interface 'Base2'.
   Types of property 'a2' are incompatible.
     Type '(x?: T) => T' is not assignable to type '<T>(x?: T) => T'.
@@ -35,10 +32,9 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingW
         Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
           'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithGenericCallSignaturesWithOptionalParameters.ts(126,15): error TS2430: Interface 'I7<T>' incorrectly extends interface 'Base2'.
-  Types of property 'a3' are incompatible.
-    Type '() => T' is not assignable to type '<T>(x: T) => T'.
-      Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
-        'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+  The types returned by 'a3(...)' are incompatible between these types.
+    Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
+      'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithGenericCallSignaturesWithOptionalParameters.ts(130,15): error TS2430: Interface 'I8<T>' incorrectly extends interface 'Base2'.
   Types of property 'a3' are incompatible.
     Type '(x?: T) => T' is not assignable to type '<T>(x: T) => T'.
@@ -55,10 +51,9 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingW
   Types of property 'a3' are incompatible.
     Type '(x: T, y: T) => T' is not assignable to type '<T>(x: T) => T'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithGenericCallSignaturesWithOptionalParameters.ts(143,15): error TS2430: Interface 'I11<T>' incorrectly extends interface 'Base2'.
-  Types of property 'a4' are incompatible.
-    Type '() => T' is not assignable to type '<T>(x: T, y?: T) => T'.
-      Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
-        'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+  The types returned by 'a4(...)' are incompatible between these types.
+    Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
+      'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithGenericCallSignaturesWithOptionalParameters.ts(147,15): error TS2430: Interface 'I12<T>' incorrectly extends interface 'Base2'.
   Types of property 'a4' are incompatible.
     Type '(x?: T, y?: T) => T' is not assignable to type '<T>(x: T, y?: T) => T'.
@@ -78,10 +73,9 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingW
         Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
           'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithGenericCallSignaturesWithOptionalParameters.ts(160,15): error TS2430: Interface 'I15<T>' incorrectly extends interface 'Base2'.
-  Types of property 'a5' are incompatible.
-    Type '() => T' is not assignable to type '<T>(x?: T, y?: T) => T'.
-      Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
-        'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+  The types returned by 'a5(...)' are incompatible between these types.
+    Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
+      'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithGenericCallSignaturesWithOptionalParameters.ts(164,15): error TS2430: Interface 'I16<T>' incorrectly extends interface 'Base2'.
   Types of property 'a5' are incompatible.
     Type '(x?: T, y?: T) => T' is not assignable to type '<T>(x?: T, y?: T) => T'.
@@ -219,20 +213,18 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingW
         interface I1<T> extends Base2 {
                   ~~
 !!! error TS2430: Interface 'I1<T>' incorrectly extends interface 'Base2'.
-!!! error TS2430:   Types of property 'a' are incompatible.
-!!! error TS2430:     Type '() => T' is not assignable to type '<T>() => T'.
-!!! error TS2430:       Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
-!!! error TS2430:         'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+!!! error TS2430:   The types returned by 'a()' are incompatible between these types.
+!!! error TS2430:     Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
+!!! error TS2430:       'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
             a: () => T; 
         }
     
         interface I2<T> extends Base2 {
                   ~~
 !!! error TS2430: Interface 'I2<T>' incorrectly extends interface 'Base2'.
-!!! error TS2430:   Types of property 'a' are incompatible.
-!!! error TS2430:     Type '(x?: T) => T' is not assignable to type '<T>() => T'.
-!!! error TS2430:       Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
-!!! error TS2430:         'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+!!! error TS2430:   The types returned by 'a(...)' are incompatible between these types.
+!!! error TS2430:     Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
+!!! error TS2430:       'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
             a: (x?: T) => T;
         }
     
@@ -248,10 +240,9 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingW
         interface I4<T> extends Base2 {
                   ~~
 !!! error TS2430: Interface 'I4<T>' incorrectly extends interface 'Base2'.
-!!! error TS2430:   Types of property 'a2' are incompatible.
-!!! error TS2430:     Type '() => T' is not assignable to type '<T>(x?: T) => T'.
-!!! error TS2430:       Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
-!!! error TS2430:         'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+!!! error TS2430:   The types returned by 'a2(...)' are incompatible between these types.
+!!! error TS2430:     Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
+!!! error TS2430:       'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
             a2: () => T; 
         }
     
@@ -281,10 +272,9 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingW
         interface I7<T> extends Base2 {
                   ~~
 !!! error TS2430: Interface 'I7<T>' incorrectly extends interface 'Base2'.
-!!! error TS2430:   Types of property 'a3' are incompatible.
-!!! error TS2430:     Type '() => T' is not assignable to type '<T>(x: T) => T'.
-!!! error TS2430:       Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
-!!! error TS2430:         'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+!!! error TS2430:   The types returned by 'a3(...)' are incompatible between these types.
+!!! error TS2430:     Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
+!!! error TS2430:       'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
             a3: () => T;
         }
     
@@ -322,10 +312,9 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingW
         interface I11<T> extends Base2 {
                   ~~~
 !!! error TS2430: Interface 'I11<T>' incorrectly extends interface 'Base2'.
-!!! error TS2430:   Types of property 'a4' are incompatible.
-!!! error TS2430:     Type '() => T' is not assignable to type '<T>(x: T, y?: T) => T'.
-!!! error TS2430:       Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
-!!! error TS2430:         'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+!!! error TS2430:   The types returned by 'a4(...)' are incompatible between these types.
+!!! error TS2430:     Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
+!!! error TS2430:       'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
             a4: () => T; 
         }
     
@@ -366,10 +355,9 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingW
         interface I15<T> extends Base2 {
                   ~~~
 !!! error TS2430: Interface 'I15<T>' incorrectly extends interface 'Base2'.
-!!! error TS2430:   Types of property 'a5' are incompatible.
-!!! error TS2430:     Type '() => T' is not assignable to type '<T>(x?: T, y?: T) => T'.
-!!! error TS2430:       Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
-!!! error TS2430:         'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+!!! error TS2430:   The types returned by 'a5(...)' are incompatible between these types.
+!!! error TS2430:     Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
+!!! error TS2430:       'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
             a5: () => T; 
         }
     
diff --git a/tests/baselines/reference/subtypingWithGenericConstructSignaturesWithOptionalParameters.errors.txt b/tests/baselines/reference/subtypingWithGenericConstructSignaturesWithOptionalParameters.errors.txt
index 427c7c1f19e..7481ba54f1e 100644
--- a/tests/baselines/reference/subtypingWithGenericConstructSignaturesWithOptionalParameters.errors.txt
+++ b/tests/baselines/reference/subtypingWithGenericConstructSignaturesWithOptionalParameters.errors.txt
@@ -5,23 +5,20 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingW
   Types of property 'a3' are incompatible.
     Type 'new (x: T, y: T) => T' is not assignable to type 'new (x: T) => T'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithGenericConstructSignaturesWithOptionalParameters.ts(100,15): error TS2430: Interface 'I1<T>' incorrectly extends interface 'Base2'.
-  Types of property 'a' are incompatible.
-    Type 'new () => T' is not assignable to type 'new <T>() => T'.
-      Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
-        'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+  The types returned by 'new a()' are incompatible between these types.
+    Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
+      'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithGenericConstructSignaturesWithOptionalParameters.ts(104,15): error TS2430: Interface 'I2<T>' incorrectly extends interface 'Base2'.
-  Types of property 'a' are incompatible.
-    Type 'new (x?: T) => T' is not assignable to type 'new <T>() => T'.
-      Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
-        'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+  The types returned by 'new a(...)' are incompatible between these types.
+    Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
+      'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithGenericConstructSignaturesWithOptionalParameters.ts(108,15): error TS2430: Interface 'I3<T>' incorrectly extends interface 'Base2'.
   Types of property 'a' are incompatible.
     Type 'new (x: T) => T' is not assignable to type 'new <T>() => T'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithGenericConstructSignaturesWithOptionalParameters.ts(113,15): error TS2430: Interface 'I4<T>' incorrectly extends interface 'Base2'.
-  Types of property 'a2' are incompatible.
-    Type 'new () => T' is not assignable to type 'new <T>(x?: T) => T'.
-      Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
-        'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+  The types returned by 'new a2(...)' are incompatible between these types.
+    Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
+      'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithGenericConstructSignaturesWithOptionalParameters.ts(117,15): error TS2430: Interface 'I5<T>' incorrectly extends interface 'Base2'.
   Types of property 'a2' are incompatible.
     Type 'new (x?: T) => T' is not assignable to type 'new <T>(x?: T) => T'.
@@ -35,10 +32,9 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingW
         Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
           'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithGenericConstructSignaturesWithOptionalParameters.ts(126,15): error TS2430: Interface 'I7<T>' incorrectly extends interface 'Base2'.
-  Types of property 'a3' are incompatible.
-    Type 'new () => T' is not assignable to type 'new <T>(x: T) => T'.
-      Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
-        'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+  The types returned by 'new a3(...)' are incompatible between these types.
+    Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
+      'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithGenericConstructSignaturesWithOptionalParameters.ts(130,15): error TS2430: Interface 'I8<T>' incorrectly extends interface 'Base2'.
   Types of property 'a3' are incompatible.
     Type 'new (x?: T) => T' is not assignable to type 'new <T>(x: T) => T'.
@@ -55,10 +51,9 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingW
   Types of property 'a3' are incompatible.
     Type 'new (x: T, y: T) => T' is not assignable to type 'new <T>(x: T) => T'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithGenericConstructSignaturesWithOptionalParameters.ts(143,15): error TS2430: Interface 'I11<T>' incorrectly extends interface 'Base2'.
-  Types of property 'a4' are incompatible.
-    Type 'new () => T' is not assignable to type 'new <T>(x: T, y?: T) => T'.
-      Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
-        'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+  The types returned by 'new a4(...)' are incompatible between these types.
+    Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
+      'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithGenericConstructSignaturesWithOptionalParameters.ts(147,15): error TS2430: Interface 'I12<T>' incorrectly extends interface 'Base2'.
   Types of property 'a4' are incompatible.
     Type 'new (x?: T, y?: T) => T' is not assignable to type 'new <T>(x: T, y?: T) => T'.
@@ -78,10 +73,9 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingW
         Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
           'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithGenericConstructSignaturesWithOptionalParameters.ts(160,15): error TS2430: Interface 'I15<T>' incorrectly extends interface 'Base2'.
-  Types of property 'a5' are incompatible.
-    Type 'new () => T' is not assignable to type 'new <T>(x?: T, y?: T) => T'.
-      Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
-        'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+  The types returned by 'new a5(...)' are incompatible between these types.
+    Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
+      'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithGenericConstructSignaturesWithOptionalParameters.ts(164,15): error TS2430: Interface 'I16<T>' incorrectly extends interface 'Base2'.
   Types of property 'a5' are incompatible.
     Type 'new (x?: T, y?: T) => T' is not assignable to type 'new <T>(x?: T, y?: T) => T'.
@@ -219,20 +213,18 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingW
         interface I1<T> extends Base2 {
                   ~~
 !!! error TS2430: Interface 'I1<T>' incorrectly extends interface 'Base2'.
-!!! error TS2430:   Types of property 'a' are incompatible.
-!!! error TS2430:     Type 'new () => T' is not assignable to type 'new <T>() => T'.
-!!! error TS2430:       Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
-!!! error TS2430:         'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+!!! error TS2430:   The types returned by 'new a()' are incompatible between these types.
+!!! error TS2430:     Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
+!!! error TS2430:       'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
             a: new () => T; 
         }
     
         interface I2<T> extends Base2 {
                   ~~
 !!! error TS2430: Interface 'I2<T>' incorrectly extends interface 'Base2'.
-!!! error TS2430:   Types of property 'a' are incompatible.
-!!! error TS2430:     Type 'new (x?: T) => T' is not assignable to type 'new <T>() => T'.
-!!! error TS2430:       Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
-!!! error TS2430:         'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+!!! error TS2430:   The types returned by 'new a(...)' are incompatible between these types.
+!!! error TS2430:     Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
+!!! error TS2430:       'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
             a: new (x?: T) => T;
         }
     
@@ -248,10 +240,9 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingW
         interface I4<T> extends Base2 {
                   ~~
 !!! error TS2430: Interface 'I4<T>' incorrectly extends interface 'Base2'.
-!!! error TS2430:   Types of property 'a2' are incompatible.
-!!! error TS2430:     Type 'new () => T' is not assignable to type 'new <T>(x?: T) => T'.
-!!! error TS2430:       Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
-!!! error TS2430:         'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+!!! error TS2430:   The types returned by 'new a2(...)' are incompatible between these types.
+!!! error TS2430:     Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
+!!! error TS2430:       'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
             a2: new () => T; 
         }
     
@@ -281,10 +272,9 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingW
         interface I7<T> extends Base2 {
                   ~~
 !!! error TS2430: Interface 'I7<T>' incorrectly extends interface 'Base2'.
-!!! error TS2430:   Types of property 'a3' are incompatible.
-!!! error TS2430:     Type 'new () => T' is not assignable to type 'new <T>(x: T) => T'.
-!!! error TS2430:       Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
-!!! error TS2430:         'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+!!! error TS2430:   The types returned by 'new a3(...)' are incompatible between these types.
+!!! error TS2430:     Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
+!!! error TS2430:       'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
             a3: new () => T;
         }
     
@@ -322,10 +312,9 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingW
         interface I11<T> extends Base2 {
                   ~~~
 !!! error TS2430: Interface 'I11<T>' incorrectly extends interface 'Base2'.
-!!! error TS2430:   Types of property 'a4' are incompatible.
-!!! error TS2430:     Type 'new () => T' is not assignable to type 'new <T>(x: T, y?: T) => T'.
-!!! error TS2430:       Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
-!!! error TS2430:         'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+!!! error TS2430:   The types returned by 'new a4(...)' are incompatible between these types.
+!!! error TS2430:     Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
+!!! error TS2430:       'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
             a4: new () => T; 
         }
     
@@ -366,10 +355,9 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingW
         interface I15<T> extends Base2 {
                   ~~~
 !!! error TS2430: Interface 'I15<T>' incorrectly extends interface 'Base2'.
-!!! error TS2430:   Types of property 'a5' are incompatible.
-!!! error TS2430:     Type 'new () => T' is not assignable to type 'new <T>(x?: T, y?: T) => T'.
-!!! error TS2430:       Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
-!!! error TS2430:         'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
+!!! error TS2430:   The types returned by 'new a5(...)' are incompatible between these types.
+!!! error TS2430:     Type 'T' is not assignable to type 'T'. Two different types with this name exist, but they are unrelated.
+!!! error TS2430:       'T' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
             a5: new () => T; 
         }
     
diff --git a/tests/baselines/reference/tsxAttributeResolution1.errors.txt b/tests/baselines/reference/tsxAttributeResolution1.errors.txt
index 9fc3e8f94da..46ccb39e704 100644
--- a/tests/baselines/reference/tsxAttributeResolution1.errors.txt
+++ b/tests/baselines/reference/tsxAttributeResolution1.errors.txt
@@ -1,10 +1,10 @@
 tests/cases/conformance/jsx/file.tsx(23,8): error TS2322: Type 'string' is not assignable to type 'number'.
-tests/cases/conformance/jsx/file.tsx(24,2): error TS2322: Type '{ y: number; }' is not assignable to type 'Attribs1'.
+tests/cases/conformance/jsx/file.tsx(24,8): error TS2322: Type '{ y: number; }' is not assignable to type 'Attribs1'.
   Property 'y' does not exist on type 'Attribs1'.
-tests/cases/conformance/jsx/file.tsx(25,2): error TS2322: Type '{ y: string; }' is not assignable to type 'Attribs1'.
+tests/cases/conformance/jsx/file.tsx(25,8): error TS2322: Type '{ y: string; }' is not assignable to type 'Attribs1'.
   Property 'y' does not exist on type 'Attribs1'.
 tests/cases/conformance/jsx/file.tsx(26,8): error TS2322: Type 'string' is not assignable to type 'number'.
-tests/cases/conformance/jsx/file.tsx(27,2): error TS2322: Type '{ var: string; }' is not assignable to type 'Attribs1'.
+tests/cases/conformance/jsx/file.tsx(27,8): error TS2322: Type '{ var: string; }' is not assignable to type 'Attribs1'.
   Property 'var' does not exist on type 'Attribs1'.
 tests/cases/conformance/jsx/file.tsx(29,2): error TS2741: Property 'reqd' is missing in type '{}' but required in type '{ reqd: string; }'.
 tests/cases/conformance/jsx/file.tsx(30,8): error TS2322: Type 'number' is not assignable to type 'string'.
@@ -38,11 +38,11 @@ tests/cases/conformance/jsx/file.tsx(30,8): error TS2322: Type 'number' is not a
 !!! error TS2322: Type 'string' is not assignable to type 'number'.
 !!! related TS6500 tests/cases/conformance/jsx/file.tsx:10:2: The expected type comes from property 'x' which is declared here on type 'Attribs1'
     <test1 y={0} />; // Error, no property "y"
-     ~~~~~
+           ~
 !!! error TS2322: Type '{ y: number; }' is not assignable to type 'Attribs1'.
 !!! error TS2322:   Property 'y' does not exist on type 'Attribs1'.
     <test1 y="foo" />; // Error, no property "y"
-     ~~~~~
+           ~
 !!! error TS2322: Type '{ y: string; }' is not assignable to type 'Attribs1'.
 !!! error TS2322:   Property 'y' does not exist on type 'Attribs1'.
     <test1 x="32" />; // Error, "32" is not number
@@ -50,7 +50,7 @@ tests/cases/conformance/jsx/file.tsx(30,8): error TS2322: Type 'number' is not a
 !!! error TS2322: Type 'string' is not assignable to type 'number'.
 !!! related TS6500 tests/cases/conformance/jsx/file.tsx:10:2: The expected type comes from property 'x' which is declared here on type 'Attribs1'
     <test1 var="10" />; // Error, no 'var' property
-     ~~~~~
+           ~~~
 !!! error TS2322: Type '{ var: string; }' is not assignable to type 'Attribs1'.
 !!! error TS2322:   Property 'var' does not exist on type 'Attribs1'.
     
diff --git a/tests/baselines/reference/tsxAttributeResolution11.errors.txt b/tests/baselines/reference/tsxAttributeResolution11.errors.txt
index 6c6a23a9b70..d490faad314 100644
--- a/tests/baselines/reference/tsxAttributeResolution11.errors.txt
+++ b/tests/baselines/reference/tsxAttributeResolution11.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/jsx/file.tsx(11,10): error TS2322: Type '{ bar: string; }' is not assignable to type 'IntrinsicAttributes & { ref?: string; }'.
+tests/cases/conformance/jsx/file.tsx(11,22): error TS2322: Type '{ bar: string; }' is not assignable to type 'IntrinsicAttributes & { ref?: string; }'.
   Property 'bar' does not exist on type 'IntrinsicAttributes & { ref?: string; }'.
 
 
@@ -27,7 +27,7 @@ tests/cases/conformance/jsx/file.tsx(11,10): error TS2322: Type '{ bar: string;
     
     // Should be an OK
     var x = <MyComponent bar='world' />;
-             ~~~~~~~~~~~
+                         ~~~
 !!! error TS2322: Type '{ bar: string; }' is not assignable to type 'IntrinsicAttributes & { ref?: string; }'.
 !!! error TS2322:   Property 'bar' does not exist on type 'IntrinsicAttributes & { ref?: string; }'.
     
diff --git a/tests/baselines/reference/tsxAttributeResolution15.errors.txt b/tests/baselines/reference/tsxAttributeResolution15.errors.txt
index ca86178b578..7ec97ba4675 100644
--- a/tests/baselines/reference/tsxAttributeResolution15.errors.txt
+++ b/tests/baselines/reference/tsxAttributeResolution15.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/jsx/file.tsx(11,10): error TS2322: Type '{ prop1: string; }' is not assignable to type 'IntrinsicAttributes & IntrinsicClassAttributes<BigGreeter> & { children?: ReactNode; }'.
+tests/cases/conformance/jsx/file.tsx(11,21): error TS2322: Type '{ prop1: string; }' is not assignable to type 'IntrinsicAttributes & IntrinsicClassAttributes<BigGreeter> & { children?: ReactNode; }'.
   Property 'prop1' does not exist on type 'IntrinsicAttributes & IntrinsicClassAttributes<BigGreeter> & { children?: ReactNode; }'.
 tests/cases/conformance/jsx/file.tsx(14,44): error TS7017: Element implicitly has an 'any' type because type 'typeof globalThis' has no index signature.
 
@@ -15,7 +15,7 @@ tests/cases/conformance/jsx/file.tsx(14,44): error TS7017: Element implicitly ha
     
     // Error
     let a = <BigGreeter prop1="hello" />
-             ~~~~~~~~~~
+                        ~~~~~
 !!! error TS2322: Type '{ prop1: string; }' is not assignable to type 'IntrinsicAttributes & IntrinsicClassAttributes<BigGreeter> & { children?: ReactNode; }'.
 !!! error TS2322:   Property 'prop1' does not exist on type 'IntrinsicAttributes & IntrinsicClassAttributes<BigGreeter> & { children?: ReactNode; }'.
     
diff --git a/tests/baselines/reference/tsxElementResolution11.errors.txt b/tests/baselines/reference/tsxElementResolution11.errors.txt
index d08a6ed2721..cc032610e2b 100644
--- a/tests/baselines/reference/tsxElementResolution11.errors.txt
+++ b/tests/baselines/reference/tsxElementResolution11.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/jsx/file.tsx(17,2): error TS2322: Type '{ x: number; }' is not assignable to type '{ q?: number; }'.
+tests/cases/conformance/jsx/file.tsx(17,7): error TS2322: Type '{ x: number; }' is not assignable to type '{ q?: number; }'.
   Property 'x' does not exist on type '{ q?: number; }'.
 
 
@@ -20,7 +20,7 @@ tests/cases/conformance/jsx/file.tsx(17,2): error TS2322: Type '{ x: number; }'
     }
     var Obj2: Obj2type;
     <Obj2 x={10} />; // Error
-     ~~~~
+          ~
 !!! error TS2322: Type '{ x: number; }' is not assignable to type '{ q?: number; }'.
 !!! error TS2322:   Property 'x' does not exist on type '{ q?: number; }'.
     
diff --git a/tests/baselines/reference/tsxElementResolution3.errors.txt b/tests/baselines/reference/tsxElementResolution3.errors.txt
index f220dbd8a5b..8f8679b3857 100644
--- a/tests/baselines/reference/tsxElementResolution3.errors.txt
+++ b/tests/baselines/reference/tsxElementResolution3.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/jsx/file.tsx(12,2): error TS2322: Type '{ w: string; }' is not assignable to type '{ n: string; }'.
+tests/cases/conformance/jsx/file.tsx(12,7): error TS2322: Type '{ w: string; }' is not assignable to type '{ n: string; }'.
   Property 'w' does not exist on type '{ n: string; }'.
 
 
@@ -15,6 +15,6 @@ tests/cases/conformance/jsx/file.tsx(12,2): error TS2322: Type '{ w: string; }'
     
     // Error
     <span w='err' />;
-     ~~~~
+          ~
 !!! error TS2322: Type '{ w: string; }' is not assignable to type '{ n: string; }'.
 !!! error TS2322:   Property 'w' does not exist on type '{ n: string; }'.
\ No newline at end of file
diff --git a/tests/baselines/reference/tsxElementResolution4.errors.txt b/tests/baselines/reference/tsxElementResolution4.errors.txt
index f76925030f2..235adbb199a 100644
--- a/tests/baselines/reference/tsxElementResolution4.errors.txt
+++ b/tests/baselines/reference/tsxElementResolution4.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/jsx/file.tsx(16,2): error TS2322: Type '{ q: string; }' is not assignable to type '{ m: string; }'.
+tests/cases/conformance/jsx/file.tsx(16,7): error TS2322: Type '{ q: string; }' is not assignable to type '{ m: string; }'.
   Property 'q' does not exist on type '{ m: string; }'.
 
 
@@ -19,7 +19,7 @@ tests/cases/conformance/jsx/file.tsx(16,2): error TS2322: Type '{ q: string; }'
     
     // Error
     <span q='' />;
-     ~~~~
+          ~
 !!! error TS2322: Type '{ q: string; }' is not assignable to type '{ m: string; }'.
 !!! error TS2322:   Property 'q' does not exist on type '{ m: string; }'.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/tsxLibraryManagedAttributes.errors.txt b/tests/baselines/reference/tsxLibraryManagedAttributes.errors.txt
index b34ee77d1fb..4b4448e42f6 100644
--- a/tests/baselines/reference/tsxLibraryManagedAttributes.errors.txt
+++ b/tests/baselines/reference/tsxLibraryManagedAttributes.errors.txt
@@ -1,22 +1,22 @@
 tests/cases/conformance/jsx/tsxLibraryManagedAttributes.tsx(55,12): error TS2322: Type '{ foo: number; }' is not assignable to type 'Defaultize<InferredPropTypes<{ foo: PropTypeChecker<number, false>; bar: PropTypeChecker<ReactNode, false>; baz: PropTypeChecker<string, true>; }>, { foo: number; }>'.
   Type '{ foo: number; }' is missing the following properties from type '{ bar: string | number | ReactComponent<{}, {}> | null | undefined; baz: string; }': bar, baz
-tests/cases/conformance/jsx/tsxLibraryManagedAttributes.tsx(57,12): error TS2322: Type '{ bar: string; baz: string; bat: string; }' is not assignable to type 'Defaultize<InferredPropTypes<{ foo: PropTypeChecker<number, false>; bar: PropTypeChecker<ReactNode, false>; baz: PropTypeChecker<string, true>; }>, { foo: number; }>'.
+tests/cases/conformance/jsx/tsxLibraryManagedAttributes.tsx(57,41): error TS2322: Type '{ bar: string; baz: string; bat: string; }' is not assignable to type 'Defaultize<InferredPropTypes<{ foo: PropTypeChecker<number, false>; bar: PropTypeChecker<ReactNode, false>; baz: PropTypeChecker<string, true>; }>, { foo: number; }>'.
   Property 'bat' does not exist on type 'Defaultize<InferredPropTypes<{ foo: PropTypeChecker<number, false>; bar: PropTypeChecker<ReactNode, false>; baz: PropTypeChecker<string, true>; }>, { foo: number; }>'.
 tests/cases/conformance/jsx/tsxLibraryManagedAttributes.tsx(59,42): error TS2322: Type 'null' is not assignable to type 'string'.
 tests/cases/conformance/jsx/tsxLibraryManagedAttributes.tsx(69,26): error TS2322: Type 'string' is not assignable to type 'number | null | undefined'.
 tests/cases/conformance/jsx/tsxLibraryManagedAttributes.tsx(71,35): error TS2322: Type 'null' is not assignable to type 'ReactNode'.
-tests/cases/conformance/jsx/tsxLibraryManagedAttributes.tsx(80,12): error TS2322: Type '{ foo: number; bar: string; }' is not assignable to type 'Defaultize<{}, { foo: number; }>'.
+tests/cases/conformance/jsx/tsxLibraryManagedAttributes.tsx(80,38): error TS2322: Type '{ foo: number; bar: string; }' is not assignable to type 'Defaultize<{}, { foo: number; }>'.
   Property 'bar' does not exist on type 'Defaultize<{}, { foo: number; }>'.
 tests/cases/conformance/jsx/tsxLibraryManagedAttributes.tsx(81,29): error TS2322: Type 'string' is not assignable to type 'number | undefined'.
 tests/cases/conformance/jsx/tsxLibraryManagedAttributes.tsx(98,12): error TS2322: Type '{ foo: string; }' is not assignable to type 'Defaultize<FooProps & InferredPropTypes<{ foo: PropTypeChecker<string, false>; bar: PropTypeChecker<ReactNode, false>; baz: PropTypeChecker<number, true>; }>, { foo: string; }>'.
   Type '{ foo: string; }' is missing the following properties from type '{ bar: string | number | ReactComponent<{}, {}> | null | undefined; baz: number; }': bar, baz
-tests/cases/conformance/jsx/tsxLibraryManagedAttributes.tsx(100,12): error TS2322: Type '{ bar: string; baz: number; bat: string; }' is not assignable to type 'Defaultize<FooProps & InferredPropTypes<{ foo: PropTypeChecker<string, false>; bar: PropTypeChecker<ReactNode, false>; baz: PropTypeChecker<number, true>; }>, { foo: string; }>'.
+tests/cases/conformance/jsx/tsxLibraryManagedAttributes.tsx(100,56): error TS2322: Type '{ bar: string; baz: number; bat: string; }' is not assignable to type 'Defaultize<FooProps & InferredPropTypes<{ foo: PropTypeChecker<string, false>; bar: PropTypeChecker<ReactNode, false>; baz: PropTypeChecker<number, true>; }>, { foo: string; }>'.
   Property 'bat' does not exist on type 'Defaultize<FooProps & InferredPropTypes<{ foo: PropTypeChecker<string, false>; bar: PropTypeChecker<ReactNode, false>; baz: PropTypeChecker<number, true>; }>, { foo: string; }>'.
 tests/cases/conformance/jsx/tsxLibraryManagedAttributes.tsx(102,57): error TS2322: Type 'null' is not assignable to type 'number'.
 tests/cases/conformance/jsx/tsxLibraryManagedAttributes.tsx(111,46): error TS2322: Type 'number' is not assignable to type 'string'.
 tests/cases/conformance/jsx/tsxLibraryManagedAttributes.tsx(112,46): error TS2322: Type 'null' is not assignable to type 'string'.
 tests/cases/conformance/jsx/tsxLibraryManagedAttributes.tsx(113,57): error TS2322: Type 'null' is not assignable to type 'ReactNode'.
-tests/cases/conformance/jsx/tsxLibraryManagedAttributes.tsx(122,12): error TS2322: Type '{ foo: string; bar: string; }' is not assignable to type 'Defaultize<FooProps, { foo: string; }>'.
+tests/cases/conformance/jsx/tsxLibraryManagedAttributes.tsx(122,58): error TS2322: Type '{ foo: string; bar: string; }' is not assignable to type 'Defaultize<FooProps, { foo: string; }>'.
   Property 'bar' does not exist on type 'Defaultize<FooProps, { foo: string; }>'.
 tests/cases/conformance/jsx/tsxLibraryManagedAttributes.tsx(123,49): error TS2322: Type 'number' is not assignable to type 'string | undefined'.
 
@@ -82,7 +82,7 @@ tests/cases/conformance/jsx/tsxLibraryManagedAttributes.tsx(123,49): error TS232
 !!! error TS2322:   Type '{ foo: number; }' is missing the following properties from type '{ bar: string | number | ReactComponent<{}, {}> | null | undefined; baz: string; }': bar, baz
     const c = <Component bar="yes" baz="yeah" />;
     const d = <Component bar="yes" baz="yo" bat="ohno" />; // Error, baz not a valid prop
-               ~~~~~~~~~
+                                            ~~~
 !!! error TS2322: Type '{ bar: string; baz: string; bat: string; }' is not assignable to type 'Defaultize<InferredPropTypes<{ foo: PropTypeChecker<number, false>; bar: PropTypeChecker<ReactNode, false>; baz: PropTypeChecker<string, true>; }>, { foo: number; }>'.
 !!! error TS2322:   Property 'bat' does not exist on type 'Defaultize<InferredPropTypes<{ foo: PropTypeChecker<number, false>; bar: PropTypeChecker<ReactNode, false>; baz: PropTypeChecker<string, true>; }>, { foo: number; }>'.
     const e = <Component foo={12} bar={null} baz="cool" />; // bar is nullable/undefinable since it's not marked `isRequired`
@@ -116,7 +116,7 @@ tests/cases/conformance/jsx/tsxLibraryManagedAttributes.tsx(123,49): error TS232
     
     const k = <JustDefaultProps foo={12} />;
     const l = <JustDefaultProps foo={12} bar="ok" />; // error, no prop named bar
-               ~~~~~~~~~~~~~~~~
+                                         ~~~
 !!! error TS2322: Type '{ foo: number; bar: string; }' is not assignable to type 'Defaultize<{}, { foo: number; }>'.
 !!! error TS2322:   Property 'bar' does not exist on type 'Defaultize<{}, { foo: number; }>'.
     const m = <JustDefaultProps foo="no" />; // error, wrong type
@@ -145,7 +145,7 @@ tests/cases/conformance/jsx/tsxLibraryManagedAttributes.tsx(123,49): error TS232
 !!! error TS2322:   Type '{ foo: string; }' is missing the following properties from type '{ bar: string | number | ReactComponent<{}, {}> | null | undefined; baz: number; }': bar, baz
     const p = <BothWithSpecifiedGeneric bar="yes" baz={12} />;
     const q = <BothWithSpecifiedGeneric bar="yes" baz={12} bat="ohno" />; // Error, baz not a valid prop
-               ~~~~~~~~~~~~~~~~~~~~~~~~
+                                                           ~~~
 !!! error TS2322: Type '{ bar: string; baz: number; bat: string; }' is not assignable to type 'Defaultize<FooProps & InferredPropTypes<{ foo: PropTypeChecker<string, false>; bar: PropTypeChecker<ReactNode, false>; baz: PropTypeChecker<number, true>; }>, { foo: string; }>'.
 !!! error TS2322:   Property 'bat' does not exist on type 'Defaultize<FooProps & InferredPropTypes<{ foo: PropTypeChecker<string, false>; bar: PropTypeChecker<ReactNode, false>; baz: PropTypeChecker<number, true>; }>, { foo: string; }>'.
     const r = <BothWithSpecifiedGeneric foo="no" bar={null} baz={0} />; // bar is nullable/undefinable since it's not marked `isRequired`
@@ -181,7 +181,7 @@ tests/cases/conformance/jsx/tsxLibraryManagedAttributes.tsx(123,49): error TS232
     
     const x = <JustDefaultPropsWithSpecifiedGeneric foo="eh" />;
     const y = <JustDefaultPropsWithSpecifiedGeneric foo="no" bar="ok" />; // error, no prop named bar
-               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+                                                             ~~~
 !!! error TS2322: Type '{ foo: string; bar: string; }' is not assignable to type 'Defaultize<FooProps, { foo: string; }>'.
 !!! error TS2322:   Property 'bar' does not exist on type 'Defaultize<FooProps, { foo: string; }>'.
     const z = <JustDefaultPropsWithSpecifiedGeneric foo={12} />; // error, wrong type
diff --git a/tests/baselines/reference/tsxSpreadAttributesResolution14.errors.txt b/tests/baselines/reference/tsxSpreadAttributesResolution14.errors.txt
index 67beb30ccb0..f000257b9d5 100644
--- a/tests/baselines/reference/tsxSpreadAttributesResolution14.errors.txt
+++ b/tests/baselines/reference/tsxSpreadAttributesResolution14.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/jsx/file.tsx(11,10): error TS2322: Type '{ Property1: true; property1: string; property2: number; }' is not assignable to type 'IntrinsicAttributes & AnotherComponentProps'.
+tests/cases/conformance/jsx/file.tsx(11,38): error TS2322: Type '{ Property1: true; property1: string; property2: number; }' is not assignable to type 'IntrinsicAttributes & AnotherComponentProps'.
   Property 'Property1' does not exist on type 'IntrinsicAttributes & AnotherComponentProps'.
 
 
@@ -14,7 +14,7 @@ tests/cases/conformance/jsx/file.tsx(11,10): error TS2322: Type '{ Property1: tr
         return (
             // Error extra property
             <AnotherComponent {...props} Property1/>
-             ~~~~~~~~~~~~~~~~
+                                         ~~~~~~~~~
 !!! error TS2322: Type '{ Property1: true; property1: string; property2: number; }' is not assignable to type 'IntrinsicAttributes & AnotherComponentProps'.
 !!! error TS2322:   Property 'Property1' does not exist on type 'IntrinsicAttributes & AnotherComponentProps'.
         );
diff --git a/tests/baselines/reference/tsxSpreadAttributesResolution2.errors.txt b/tests/baselines/reference/tsxSpreadAttributesResolution2.errors.txt
index d9748382f25..a5f36e5ed08 100644
--- a/tests/baselines/reference/tsxSpreadAttributesResolution2.errors.txt
+++ b/tests/baselines/reference/tsxSpreadAttributesResolution2.errors.txt
@@ -5,7 +5,7 @@ tests/cases/conformance/jsx/file.tsx(22,21): error TS2322: Type 'true' is not as
 tests/cases/conformance/jsx/file.tsx(23,10): error TS2322: Type '{ x: number; y: "2"; }' is not assignable to type 'PoisonedProp'.
   Types of property 'x' are incompatible.
     Type 'number' is not assignable to type 'string'.
-tests/cases/conformance/jsx/file.tsx(24,11): error TS2322: Type '{ X: string; x: number; y: "2"; }' is not assignable to type 'IntrinsicAttributes & IntrinsicClassAttributes<Poisoned> & PoisonedProp & { children?: ReactNode; }'.
+tests/cases/conformance/jsx/file.tsx(24,40): error TS2322: Type '{ X: string; x: number; y: "2"; }' is not assignable to type 'IntrinsicAttributes & IntrinsicClassAttributes<Poisoned> & PoisonedProp & { children?: ReactNode; }'.
   Property 'X' does not exist on type 'IntrinsicAttributes & IntrinsicClassAttributes<Poisoned> & PoisonedProp & { children?: ReactNode; }'.
 
 
@@ -48,6 +48,6 @@ tests/cases/conformance/jsx/file.tsx(24,11): error TS2322: Type '{ X: string; x:
 !!! error TS2322:   Types of property 'x' are incompatible.
 !!! error TS2322:     Type 'number' is not assignable to type 'string'.
     let w1 = <Poisoned {...{x: 5, y: "2"}} X="hi" />;
-              ~~~~~~~~
+                                           ~
 !!! error TS2322: Type '{ X: string; x: number; y: "2"; }' is not assignable to type 'IntrinsicAttributes & IntrinsicClassAttributes<Poisoned> & PoisonedProp & { children?: ReactNode; }'.
 !!! error TS2322:   Property 'X' does not exist on type 'IntrinsicAttributes & IntrinsicClassAttributes<Poisoned> & PoisonedProp & { children?: ReactNode; }'.
\ No newline at end of file
diff --git a/tests/baselines/reference/tsxStatelessFunctionComponentOverload4.errors.txt b/tests/baselines/reference/tsxStatelessFunctionComponentOverload4.errors.txt
index 5318c77efae..3a47e329162 100644
--- a/tests/baselines/reference/tsxStatelessFunctionComponentOverload4.errors.txt
+++ b/tests/baselines/reference/tsxStatelessFunctionComponentOverload4.errors.txt
@@ -1,23 +1,23 @@
-tests/cases/conformance/jsx/file.tsx(12,13): error TS2769: No overload matches this call.
+tests/cases/conformance/jsx/file.tsx(12,22): error TS2769: No overload matches this call.
   Overload 1 of 2, '(): Element', gave the following error.
     Type '{ extraProp: true; }' is not assignable to type 'IntrinsicAttributes'.
       Property 'extraProp' does not exist on type 'IntrinsicAttributes'.
   Overload 2 of 2, '(l: { yy: number; yy1: string; }): Element', gave the following error.
     Type '{ extraProp: true; }' is not assignable to type 'IntrinsicAttributes & { yy: number; yy1: string; }'.
       Property 'extraProp' does not exist on type 'IntrinsicAttributes & { yy: number; yy1: string; }'.
-tests/cases/conformance/jsx/file.tsx(13,13): error TS2769: No overload matches this call.
+tests/cases/conformance/jsx/file.tsx(13,12): error TS2769: No overload matches this call.
   Overload 1 of 2, '(): Element', gave the following error.
     Type '{ yy: number; }' is not assignable to type 'IntrinsicAttributes'.
       Property 'yy' does not exist on type 'IntrinsicAttributes'.
   Overload 2 of 2, '(l: { yy: number; yy1: string; }): Element', gave the following error.
     Property 'yy1' is missing in type '{ yy: number; }' but required in type '{ yy: number; yy1: string; }'.
-tests/cases/conformance/jsx/file.tsx(14,12): error TS2769: No overload matches this call.
+tests/cases/conformance/jsx/file.tsx(14,31): error TS2769: No overload matches this call.
   Overload 1 of 2, '(): Element', gave the following error.
     Type '{ yy1: true; yy: number; }' is not assignable to type 'IntrinsicAttributes'.
       Property 'yy1' does not exist on type 'IntrinsicAttributes'.
   Overload 2 of 2, '(l: { yy: number; yy1: string; }): Element', gave the following error.
     Type 'true' is not assignable to type 'string'.
-tests/cases/conformance/jsx/file.tsx(16,13): error TS2769: No overload matches this call.
+tests/cases/conformance/jsx/file.tsx(16,31): error TS2769: No overload matches this call.
   Overload 1 of 2, '(): Element', gave the following error.
     Type '{ y1: number; yy: number; yy1: string; }' is not assignable to type 'IntrinsicAttributes'.
       Property 'y1' does not exist on type 'IntrinsicAttributes'.
@@ -89,7 +89,7 @@ tests/cases/conformance/jsx/file.tsx(36,12): error TS2769: No overload matches t
     
     // Error
     const c0 = <OneThing extraProp />;  // extra property;
-                ~~~~~~~~
+                         ~~~~~~~~~
 !!! error TS2769: No overload matches this call.
 !!! error TS2769:   Overload 1 of 2, '(): Element', gave the following error.
 !!! error TS2769:     Type '{ extraProp: true; }' is not assignable to type 'IntrinsicAttributes'.
@@ -98,7 +98,7 @@ tests/cases/conformance/jsx/file.tsx(36,12): error TS2769: No overload matches t
 !!! error TS2769:     Type '{ extraProp: true; }' is not assignable to type 'IntrinsicAttributes & { yy: number; yy1: string; }'.
 !!! error TS2769:       Property 'extraProp' does not exist on type 'IntrinsicAttributes & { yy: number; yy1: string; }'.
     const c1 = <OneThing yy={10}/>;  // missing property;
-                ~~~~~~~~
+               ~~~~~~~~~~~~~~~~~~~
 !!! error TS2769: No overload matches this call.
 !!! error TS2769:   Overload 1 of 2, '(): Element', gave the following error.
 !!! error TS2769:     Type '{ yy: number; }' is not assignable to type 'IntrinsicAttributes'.
@@ -107,7 +107,7 @@ tests/cases/conformance/jsx/file.tsx(36,12): error TS2769: No overload matches t
 !!! error TS2769:     Property 'yy1' is missing in type '{ yy: number; }' but required in type '{ yy: number; yy1: string; }'.
 !!! related TS2728 tests/cases/conformance/jsx/file.tsx:3:43: 'yy1' is declared here.
     const c2 = <OneThing {...obj} yy1 />; // type incompatible;
-               ~~~~~~~~~~~~~~~~~~~~~~~~~
+                                  ~~~
 !!! error TS2769: No overload matches this call.
 !!! error TS2769:   Overload 1 of 2, '(): Element', gave the following error.
 !!! error TS2769:     Type '{ yy1: true; yy: number; }' is not assignable to type 'IntrinsicAttributes'.
@@ -117,7 +117,7 @@ tests/cases/conformance/jsx/file.tsx(36,12): error TS2769: No overload matches t
 !!! related TS6500 tests/cases/conformance/jsx/file.tsx:3:43: The expected type comes from property 'yy1' which is declared here on type 'IntrinsicAttributes & { yy: number; yy1: string; }'
     const c3 = <OneThing {...obj} {...{extra: "extra attr"}} />;  //  This is OK becuase all attribute are spread
     const c4 = <OneThing {...obj} y1={10000} />;  // extra property;
-                ~~~~~~~~
+                                  ~~
 !!! error TS2769: No overload matches this call.
 !!! error TS2769:   Overload 1 of 2, '(): Element', gave the following error.
 !!! error TS2769:     Type '{ y1: number; yy: number; yy1: string; }' is not assignable to type 'IntrinsicAttributes'.
diff --git a/tests/baselines/reference/tsxStatelessFunctionComponentOverload5.errors.txt b/tests/baselines/reference/tsxStatelessFunctionComponentOverload5.errors.txt
index faf129dda4b..aa2e4fe19c6 100644
--- a/tests/baselines/reference/tsxStatelessFunctionComponentOverload5.errors.txt
+++ b/tests/baselines/reference/tsxStatelessFunctionComponentOverload5.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/jsx/file.tsx(48,13): error TS2769: No overload matches this call.
+tests/cases/conformance/jsx/file.tsx(48,12): error TS2769: No overload matches this call.
   Overload 1 of 3, '(buttonProps: ButtonProps): Element', gave the following error.
     Type '{ children: string; to: string; onClick: (e: MouseEvent<any>) => void; }' is not assignable to type 'IntrinsicAttributes & ButtonProps'.
       Property 'to' does not exist on type 'IntrinsicAttributes & ButtonProps'.
@@ -80,7 +80,7 @@ tests/cases/conformance/jsx/file.tsx(56,12): error TS2769: No overload matches t
     
     // Error
     const b0 = <MainButton to='/some/path' onClick={(e)=>{}}>GO</MainButton>;  // extra property;
-                ~~~~~~~~~~
+               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2769: No overload matches this call.
 !!! error TS2769:   Overload 1 of 3, '(buttonProps: ButtonProps): Element', gave the following error.
 !!! error TS2769:     Type '{ children: string; to: string; onClick: (e: MouseEvent<any>) => void; }' is not assignable to type 'IntrinsicAttributes & ButtonProps'.
diff --git a/tests/baselines/reference/tsxStatelessFunctionComponents1.errors.txt b/tests/baselines/reference/tsxStatelessFunctionComponents1.errors.txt
index 2ca7adfbc3e..7827c0625a4 100644
--- a/tests/baselines/reference/tsxStatelessFunctionComponents1.errors.txt
+++ b/tests/baselines/reference/tsxStatelessFunctionComponents1.errors.txt
@@ -1,12 +1,12 @@
-tests/cases/conformance/jsx/file.tsx(19,10): error TS2322: Type '{ naaame: string; }' is not assignable to type 'IntrinsicAttributes & { name: string; }'.
+tests/cases/conformance/jsx/file.tsx(19,16): error TS2322: Type '{ naaame: string; }' is not assignable to type 'IntrinsicAttributes & { name: string; }'.
   Property 'naaame' does not exist on type 'IntrinsicAttributes & { name: string; }'.
 tests/cases/conformance/jsx/file.tsx(27,15): error TS2322: Type 'number' is not assignable to type 'string'.
-tests/cases/conformance/jsx/file.tsx(29,10): error TS2322: Type '{ naaaaaaame: string; }' is not assignable to type 'IntrinsicAttributes & { name?: string; }'.
+tests/cases/conformance/jsx/file.tsx(29,15): error TS2322: Type '{ naaaaaaame: string; }' is not assignable to type 'IntrinsicAttributes & { name?: string; }'.
   Property 'naaaaaaame' does not exist on type 'IntrinsicAttributes & { name?: string; }'.
 tests/cases/conformance/jsx/file.tsx(34,10): error TS2741: Property '"prop-name"' is missing in type '{ extra-prop-name: string; }' but required in type '{ "prop-name": string; }'.
-tests/cases/conformance/jsx/file.tsx(37,10): error TS2322: Type '{ prop1: true; }' is not assignable to type 'IntrinsicAttributes'.
+tests/cases/conformance/jsx/file.tsx(37,23): error TS2322: Type '{ prop1: true; }' is not assignable to type 'IntrinsicAttributes'.
   Property 'prop1' does not exist on type 'IntrinsicAttributes'.
-tests/cases/conformance/jsx/file.tsx(38,11): error TS2322: Type '{ ref: (x: any) => any; }' is not assignable to type 'IntrinsicAttributes'.
+tests/cases/conformance/jsx/file.tsx(38,24): error TS2322: Type '{ ref: (x: any) => any; }' is not assignable to type 'IntrinsicAttributes'.
   Property 'ref' does not exist on type 'IntrinsicAttributes'.
 tests/cases/conformance/jsx/file.tsx(41,16): error TS1005: ',' expected.
 tests/cases/conformance/jsx/file.tsx(45,11): error TS2559: Type '{ prop1: boolean; }' has no properties in common with type 'IntrinsicAttributes'.
@@ -32,7 +32,7 @@ tests/cases/conformance/jsx/file.tsx(45,11): error TS2559: Type '{ prop1: boolea
     let a1 = <Greet name='world' extra-prop />;
     // Error
     let b = <Greet naaame='world' />;
-             ~~~~~
+                   ~~~~~~
 !!! error TS2322: Type '{ naaame: string; }' is not assignable to type 'IntrinsicAttributes & { name: string; }'.
 !!! error TS2322:   Property 'naaame' does not exist on type 'IntrinsicAttributes & { name: string; }'.
     
@@ -47,7 +47,7 @@ tests/cases/conformance/jsx/file.tsx(45,11): error TS2559: Type '{ prop1: boolea
 !!! error TS2322: Type 'number' is not assignable to type 'string'.
     // Error
     let f = <Meet naaaaaaame='no' />;
-             ~~~~
+                  ~~~~~~~~~~
 !!! error TS2322: Type '{ naaaaaaame: string; }' is not assignable to type 'IntrinsicAttributes & { name?: string; }'.
 !!! error TS2322:   Property 'naaaaaaame' does not exist on type 'IntrinsicAttributes & { name?: string; }'.
     
@@ -61,11 +61,11 @@ tests/cases/conformance/jsx/file.tsx(45,11): error TS2559: Type '{ prop1: boolea
     
     // Error
     let i = <EmptyPropSFC prop1 />
-             ~~~~~~~~~~~~
+                          ~~~~~
 !!! error TS2322: Type '{ prop1: true; }' is not assignable to type 'IntrinsicAttributes'.
 !!! error TS2322:   Property 'prop1' does not exist on type 'IntrinsicAttributes'.
     let i1 = <EmptyPropSFC ref={x => x.greeting.substr(10)} />
-              ~~~~~~~~~~~~
+                           ~~~
 !!! error TS2322: Type '{ ref: (x: any) => any; }' is not assignable to type 'IntrinsicAttributes'.
 !!! error TS2322:   Property 'ref' does not exist on type 'IntrinsicAttributes'.
     
diff --git a/tests/baselines/reference/tsxStatelessFunctionComponents2.errors.txt b/tests/baselines/reference/tsxStatelessFunctionComponents2.errors.txt
index 551d0e72523..b6727eb5ca8 100644
--- a/tests/baselines/reference/tsxStatelessFunctionComponents2.errors.txt
+++ b/tests/baselines/reference/tsxStatelessFunctionComponents2.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/jsx/file.tsx(19,10): error TS2322: Type '{ ref: string; }' is not assignable to type 'IntrinsicAttributes & { name?: string; }'.
+tests/cases/conformance/jsx/file.tsx(19,16): error TS2322: Type '{ ref: string; }' is not assignable to type 'IntrinsicAttributes & { name?: string; }'.
   Property 'ref' does not exist on type 'IntrinsicAttributes & { name?: string; }'.
 tests/cases/conformance/jsx/file.tsx(25,42): error TS2551: Property 'subtr' does not exist on type 'string'. Did you mean 'substr'?
 tests/cases/conformance/jsx/file.tsx(27,33): error TS2339: Property 'notARealProperty' does not exist on type 'BigGreeter'.
@@ -25,7 +25,7 @@ tests/cases/conformance/jsx/file.tsx(35,26): error TS2339: Property 'propertyNot
     let b = <Greet key="k" />;
     // Error - not allowed to specify 'ref' on SFCs
     let c = <Greet ref="myRef" />;
-             ~~~~~
+                   ~~~
 !!! error TS2322: Type '{ ref: string; }' is not assignable to type 'IntrinsicAttributes & { name?: string; }'.
 !!! error TS2322:   Property 'ref' does not exist on type 'IntrinsicAttributes & { name?: string; }'.
     
diff --git a/tests/baselines/reference/tsxUnionElementType4.errors.txt b/tests/baselines/reference/tsxUnionElementType4.errors.txt
index bca0229de54..40463bcbb79 100644
--- a/tests/baselines/reference/tsxUnionElementType4.errors.txt
+++ b/tests/baselines/reference/tsxUnionElementType4.errors.txt
@@ -1,7 +1,7 @@
 tests/cases/conformance/jsx/file.tsx(32,17): error TS2322: Type 'true' is not assignable to type 'never'.
-tests/cases/conformance/jsx/file.tsx(33,10): error TS2322: Type '{ x: number; }' is not assignable to type 'IntrinsicAttributes & IntrinsicClassAttributes<RC4> & { children?: ReactNode; }'.
+tests/cases/conformance/jsx/file.tsx(33,21): error TS2322: Type '{ x: number; }' is not assignable to type 'IntrinsicAttributes & IntrinsicClassAttributes<RC4> & { children?: ReactNode; }'.
   Property 'x' does not exist on type 'IntrinsicAttributes & IntrinsicClassAttributes<RC4> & { children?: ReactNode; }'.
-tests/cases/conformance/jsx/file.tsx(34,10): error TS2322: Type '{ prop: true; }' is not assignable to type 'IntrinsicAttributes & IntrinsicClassAttributes<RC3> & { children?: ReactNode; }'.
+tests/cases/conformance/jsx/file.tsx(34,22): error TS2322: Type '{ prop: true; }' is not assignable to type 'IntrinsicAttributes & IntrinsicClassAttributes<RC3> & { children?: ReactNode; }'.
   Property 'prop' does not exist on type 'IntrinsicAttributes & IntrinsicClassAttributes<RC3> & { children?: ReactNode; }'.
 
 
@@ -42,11 +42,11 @@ tests/cases/conformance/jsx/file.tsx(34,10): error TS2322: Type '{ prop: true; }
 !!! error TS2322: Type 'true' is not assignable to type 'never'.
 !!! related TS6500 tests/cases/conformance/jsx/file.tsx:3:36: The expected type comes from property 'x' which is declared here on type 'IntrinsicAttributes & IntrinsicClassAttributes<RC1 | RC2> & { x: number; } & { children?: ReactNode; } & { x: string; } & { children?: ReactNode; }'
     let b = <PartRCComp x={10} />
-             ~~~~~~~~~~
+                        ~
 !!! error TS2322: Type '{ x: number; }' is not assignable to type 'IntrinsicAttributes & IntrinsicClassAttributes<RC4> & { children?: ReactNode; }'.
 !!! error TS2322:   Property 'x' does not exist on type 'IntrinsicAttributes & IntrinsicClassAttributes<RC4> & { children?: ReactNode; }'.
     let c = <EmptyRCComp prop />;
-             ~~~~~~~~~~~
+                         ~~~~
 !!! error TS2322: Type '{ prop: true; }' is not assignable to type 'IntrinsicAttributes & IntrinsicClassAttributes<RC3> & { children?: ReactNode; }'.
 !!! error TS2322:   Property 'prop' does not exist on type 'IntrinsicAttributes & IntrinsicClassAttributes<RC3> & { children?: ReactNode; }'.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/tsxUnionElementType6.errors.txt b/tests/baselines/reference/tsxUnionElementType6.errors.txt
index 790285f2978..cad93a38ae9 100644
--- a/tests/baselines/reference/tsxUnionElementType6.errors.txt
+++ b/tests/baselines/reference/tsxUnionElementType6.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/jsx/file.tsx(18,10): error TS2322: Type '{ x: true; }' is not assignable to type 'IntrinsicAttributes'.
+tests/cases/conformance/jsx/file.tsx(18,23): error TS2322: Type '{ x: true; }' is not assignable to type 'IntrinsicAttributes'.
   Property 'x' does not exist on type 'IntrinsicAttributes'.
 tests/cases/conformance/jsx/file.tsx(19,27): error TS2322: Type 'string' is not assignable to type 'boolean'.
 tests/cases/conformance/jsx/file.tsx(20,10): error TS2741: Property 'x' is missing in type '{}' but required in type '{ x: boolean; }'.
@@ -24,7 +24,7 @@ tests/cases/conformance/jsx/file.tsx(21,10): error TS2741: Property 'x' is missi
     var SFC2AndEmptyComp = SFC2 || EmptySFC1;
     // Error
     let a = <EmptySFCComp x />;
-             ~~~~~~~~~~~~
+                          ~
 !!! error TS2322: Type '{ x: true; }' is not assignable to type 'IntrinsicAttributes'.
 !!! error TS2322:   Property 'x' does not exist on type 'IntrinsicAttributes'.
     let b = <SFC2AndEmptyComp x="hi" />;
diff --git a/tests/baselines/reference/typeParameterArgumentEquivalence5.errors.txt b/tests/baselines/reference/typeParameterArgumentEquivalence5.errors.txt
index e5196d3d4a5..b832ce6cb7c 100644
--- a/tests/baselines/reference/typeParameterArgumentEquivalence5.errors.txt
+++ b/tests/baselines/reference/typeParameterArgumentEquivalence5.errors.txt
@@ -1,9 +1,9 @@
 tests/cases/compiler/typeParameterArgumentEquivalence5.ts(4,5): error TS2322: Type '() => (item: any) => T' is not assignable to type '() => (item: any) => U'.
-  Type '(item: any) => T' is not assignable to type '(item: any) => U'.
+  Call signature return types '(item: any) => T' and '(item: any) => U' are incompatible.
     Type 'T' is not assignable to type 'U'.
       'T' is assignable to the constraint of type 'U', but 'U' could be instantiated with a different subtype of constraint '{}'.
 tests/cases/compiler/typeParameterArgumentEquivalence5.ts(5,5): error TS2322: Type '() => (item: any) => U' is not assignable to type '() => (item: any) => T'.
-  Type '(item: any) => U' is not assignable to type '(item: any) => T'.
+  Call signature return types '(item: any) => U' and '(item: any) => T' are incompatible.
     Type 'U' is not assignable to type 'T'.
       'U' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
 
@@ -15,13 +15,13 @@ tests/cases/compiler/typeParameterArgumentEquivalence5.ts(5,5): error TS2322: Ty
         x = y;  // Should be an error
         ~
 !!! error TS2322: Type '() => (item: any) => T' is not assignable to type '() => (item: any) => U'.
-!!! error TS2322:   Type '(item: any) => T' is not assignable to type '(item: any) => U'.
+!!! error TS2322:   Call signature return types '(item: any) => T' and '(item: any) => U' are incompatible.
 !!! error TS2322:     Type 'T' is not assignable to type 'U'.
 !!! error TS2322:       'T' is assignable to the constraint of type 'U', but 'U' could be instantiated with a different subtype of constraint '{}'.
         y = x;  // Shound be an error
         ~
 !!! error TS2322: Type '() => (item: any) => U' is not assignable to type '() => (item: any) => T'.
-!!! error TS2322:   Type '(item: any) => U' is not assignable to type '(item: any) => T'.
+!!! error TS2322:   Call signature return types '(item: any) => U' and '(item: any) => T' are incompatible.
 !!! error TS2322:     Type 'U' is not assignable to type 'T'.
 !!! error TS2322:       'U' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.
     }
diff --git a/tests/baselines/reference/typeParameterExtendsUnionConstraintDistributed.js b/tests/baselines/reference/typeParameterExtendsUnionConstraintDistributed.js
new file mode 100644
index 00000000000..ea8ac927061
--- /dev/null
+++ b/tests/baselines/reference/typeParameterExtendsUnionConstraintDistributed.js
@@ -0,0 +1,11 @@
+//// [typeParameterExtendsUnionConstraintDistributed.ts]
+type A = 1 | 2;
+function f<T extends A>(a: T): A & T { return a; } // Shouldn't error
+
+type B = 2 | 3;
+function f2<T extends A, U extends B>(ab: T & U): (A | B) & T & U { return ab; } // Also shouldn't error
+
+
+//// [typeParameterExtendsUnionConstraintDistributed.js]
+function f(a) { return a; } // Shouldn't error
+function f2(ab) { return ab; } // Also shouldn't error
diff --git a/tests/baselines/reference/typeParameterExtendsUnionConstraintDistributed.symbols b/tests/baselines/reference/typeParameterExtendsUnionConstraintDistributed.symbols
new file mode 100644
index 00000000000..2d47ed96e14
--- /dev/null
+++ b/tests/baselines/reference/typeParameterExtendsUnionConstraintDistributed.symbols
@@ -0,0 +1,32 @@
+=== tests/cases/conformance/jsdoc/typeParameterExtendsUnionConstraintDistributed.ts ===
+type A = 1 | 2;
+>A : Symbol(A, Decl(typeParameterExtendsUnionConstraintDistributed.ts, 0, 0))
+
+function f<T extends A>(a: T): A & T { return a; } // Shouldn't error
+>f : Symbol(f, Decl(typeParameterExtendsUnionConstraintDistributed.ts, 0, 15))
+>T : Symbol(T, Decl(typeParameterExtendsUnionConstraintDistributed.ts, 1, 11))
+>A : Symbol(A, Decl(typeParameterExtendsUnionConstraintDistributed.ts, 0, 0))
+>a : Symbol(a, Decl(typeParameterExtendsUnionConstraintDistributed.ts, 1, 24))
+>T : Symbol(T, Decl(typeParameterExtendsUnionConstraintDistributed.ts, 1, 11))
+>A : Symbol(A, Decl(typeParameterExtendsUnionConstraintDistributed.ts, 0, 0))
+>T : Symbol(T, Decl(typeParameterExtendsUnionConstraintDistributed.ts, 1, 11))
+>a : Symbol(a, Decl(typeParameterExtendsUnionConstraintDistributed.ts, 1, 24))
+
+type B = 2 | 3;
+>B : Symbol(B, Decl(typeParameterExtendsUnionConstraintDistributed.ts, 1, 50))
+
+function f2<T extends A, U extends B>(ab: T & U): (A | B) & T & U { return ab; } // Also shouldn't error
+>f2 : Symbol(f2, Decl(typeParameterExtendsUnionConstraintDistributed.ts, 3, 15))
+>T : Symbol(T, Decl(typeParameterExtendsUnionConstraintDistributed.ts, 4, 12))
+>A : Symbol(A, Decl(typeParameterExtendsUnionConstraintDistributed.ts, 0, 0))
+>U : Symbol(U, Decl(typeParameterExtendsUnionConstraintDistributed.ts, 4, 24))
+>B : Symbol(B, Decl(typeParameterExtendsUnionConstraintDistributed.ts, 1, 50))
+>ab : Symbol(ab, Decl(typeParameterExtendsUnionConstraintDistributed.ts, 4, 38))
+>T : Symbol(T, Decl(typeParameterExtendsUnionConstraintDistributed.ts, 4, 12))
+>U : Symbol(U, Decl(typeParameterExtendsUnionConstraintDistributed.ts, 4, 24))
+>A : Symbol(A, Decl(typeParameterExtendsUnionConstraintDistributed.ts, 0, 0))
+>B : Symbol(B, Decl(typeParameterExtendsUnionConstraintDistributed.ts, 1, 50))
+>T : Symbol(T, Decl(typeParameterExtendsUnionConstraintDistributed.ts, 4, 12))
+>U : Symbol(U, Decl(typeParameterExtendsUnionConstraintDistributed.ts, 4, 24))
+>ab : Symbol(ab, Decl(typeParameterExtendsUnionConstraintDistributed.ts, 4, 38))
+
diff --git a/tests/baselines/reference/typeParameterExtendsUnionConstraintDistributed.types b/tests/baselines/reference/typeParameterExtendsUnionConstraintDistributed.types
new file mode 100644
index 00000000000..4e81c9728c4
--- /dev/null
+++ b/tests/baselines/reference/typeParameterExtendsUnionConstraintDistributed.types
@@ -0,0 +1,17 @@
+=== tests/cases/conformance/jsdoc/typeParameterExtendsUnionConstraintDistributed.ts ===
+type A = 1 | 2;
+>A : A
+
+function f<T extends A>(a: T): A & T { return a; } // Shouldn't error
+>f : <T extends A>(a: T) => (1 & T) | (2 & T)
+>a : T
+>a : T
+
+type B = 2 | 3;
+>B : B
+
+function f2<T extends A, U extends B>(ab: T & U): (A | B) & T & U { return ab; } // Also shouldn't error
+>f2 : <T extends A, U extends B>(ab: T & U) => (1 & T & U) | (2 & T & U) | (3 & T & U)
+>ab : T & U
+>ab : T & U
+
diff --git a/tests/baselines/reference/types.asyncGenerators.es2018.2.errors.txt b/tests/baselines/reference/types.asyncGenerators.es2018.2.errors.txt
index 9f22060b9e9..3d588abf1ee 100644
--- a/tests/baselines/reference/types.asyncGenerators.es2018.2.errors.txt
+++ b/tests/baselines/reference/types.asyncGenerators.es2018.2.errors.txt
@@ -1,39 +1,29 @@
 tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(2,12): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator.
 tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(8,12): error TS2504: Type 'Promise<number[]>' must have a '[Symbol.asyncIterator]()' method that returns an async iterator.
 tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(10,7): error TS2322: Type '() => AsyncGenerator<string, void, undefined>' is not assignable to type '() => AsyncIterableIterator<number>'.
-  Type 'AsyncGenerator<string, void, undefined>' is not assignable to type 'AsyncIterableIterator<number>'.
-    Types of property 'next' are incompatible.
-      Type '(...args: [] | [undefined]) => Promise<IteratorResult<string, void>>' is not assignable to type '(...args: [] | [undefined]) => Promise<IteratorResult<number, any>>'.
-        Type 'Promise<IteratorResult<string, void>>' is not assignable to type 'Promise<IteratorResult<number, any>>'.
-          Type 'IteratorResult<string, void>' is not assignable to type 'IteratorResult<number, any>'.
-            Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorResult<number, any>'.
-              Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorYieldResult<number>'.
-                Type 'string' is not assignable to type 'number'.
+  Call signature return types 'AsyncGenerator<string, void, undefined>' and 'AsyncIterableIterator<number>' are incompatible.
+    The types returned by 'next(...)' are incompatible between these types.
+      Type 'Promise<IteratorResult<string, void>>' is not assignable to type 'Promise<IteratorResult<number, any>>'.
+        Type 'IteratorResult<string, void>' is not assignable to type 'IteratorResult<number, any>'.
+          Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorResult<number, any>'.
+            Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorYieldResult<number>'.
+              Type 'string' is not assignable to type 'number'.
 tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(13,7): error TS2322: Type '() => AsyncGenerator<string, void, undefined>' is not assignable to type '() => AsyncIterableIterator<number>'.
   Type 'AsyncGenerator<string, void, undefined>' is not assignable to type 'AsyncIterableIterator<number>'.
 tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(16,7): error TS2322: Type '() => AsyncGenerator<string, void, unknown>' is not assignable to type '() => AsyncIterableIterator<number>'.
-  Type 'AsyncGenerator<string, void, unknown>' is not assignable to type 'AsyncIterableIterator<number>'.
-    Types of property 'next' are incompatible.
-      Type '(...args: [] | [unknown]) => Promise<IteratorResult<string, void>>' is not assignable to type '(...args: [] | [undefined]) => Promise<IteratorResult<number, any>>'.
-        Type 'Promise<IteratorResult<string, void>>' is not assignable to type 'Promise<IteratorResult<number, any>>'.
+  Call signature return types 'AsyncGenerator<string, void, unknown>' and 'AsyncIterableIterator<number>' are incompatible.
+    The types returned by 'next(...)' are incompatible between these types.
+      Type 'Promise<IteratorResult<string, void>>' is not assignable to type 'Promise<IteratorResult<number, any>>'.
 tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(19,7): error TS2322: Type '() => AsyncGenerator<string, void, undefined>' is not assignable to type '() => AsyncIterable<number>'.
-  Type 'AsyncGenerator<string, void, undefined>' is not assignable to type 'AsyncIterable<number>'.
-    Types of property '[Symbol.asyncIterator]' are incompatible.
-      Type '() => AsyncGenerator<string, void, undefined>' is not assignable to type '() => AsyncIterator<number, any, undefined>'.
-        Type 'AsyncGenerator<string, void, undefined>' is not assignable to type 'AsyncIterator<number, any, undefined>'.
-          Types of property 'next' are incompatible.
-            Type '(...args: [] | [undefined]) => Promise<IteratorResult<string, void>>' is not assignable to type '(...args: [] | [undefined]) => Promise<IteratorResult<number, any>>'.
-              Type 'Promise<IteratorResult<string, void>>' is not assignable to type 'Promise<IteratorResult<number, any>>'.
+  Call signature return types 'AsyncGenerator<string, void, undefined>' and 'AsyncIterable<number>' are incompatible.
+    The types returned by '[Symbol.asyncIterator]().next(...)' are incompatible between these types.
+      Type 'Promise<IteratorResult<string, void>>' is not assignable to type 'Promise<IteratorResult<number, any>>'.
 tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(22,7): error TS2322: Type '() => AsyncGenerator<string, void, undefined>' is not assignable to type '() => AsyncIterable<number>'.
   Type 'AsyncGenerator<string, void, undefined>' is not assignable to type 'AsyncIterable<number>'.
 tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(25,7): error TS2322: Type '() => AsyncGenerator<string, void, unknown>' is not assignable to type '() => AsyncIterable<number>'.
-  Type 'AsyncGenerator<string, void, unknown>' is not assignable to type 'AsyncIterable<number>'.
-    Types of property '[Symbol.asyncIterator]' are incompatible.
-      Type '() => AsyncGenerator<string, void, unknown>' is not assignable to type '() => AsyncIterator<number, any, undefined>'.
-        Type 'AsyncGenerator<string, void, unknown>' is not assignable to type 'AsyncIterator<number, any, undefined>'.
-          Types of property 'next' are incompatible.
-            Type '(...args: [] | [unknown]) => Promise<IteratorResult<string, void>>' is not assignable to type '(...args: [] | [undefined]) => Promise<IteratorResult<number, any>>'.
-              Type 'Promise<IteratorResult<string, void>>' is not assignable to type 'Promise<IteratorResult<number, any>>'.
+  Call signature return types 'AsyncGenerator<string, void, unknown>' and 'AsyncIterable<number>' are incompatible.
+    The types returned by '[Symbol.asyncIterator]().next(...)' are incompatible between these types.
+      Type 'Promise<IteratorResult<string, void>>' is not assignable to type 'Promise<IteratorResult<number, any>>'.
 tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(28,7): error TS2322: Type '() => AsyncGenerator<string, void, undefined>' is not assignable to type '() => AsyncIterator<number, any, undefined>'.
   Type 'AsyncGenerator<string, void, undefined>' is not assignable to type 'AsyncIterator<number, any, undefined>'.
 tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(31,7): error TS2322: Type '() => AsyncGenerator<string, void, undefined>' is not assignable to type '() => AsyncIterator<number, any, undefined>'.
@@ -52,10 +42,9 @@ tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(
 tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(64,42): error TS2741: Property '[Symbol.iterator]' is missing in type 'AsyncGenerator<number, any, undefined>' but required in type 'IterableIterator<number>'.
 tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(67,42): error TS2741: Property '[Symbol.iterator]' is missing in type 'AsyncGenerator<any, any, any>' but required in type 'Iterable<number>'.
 tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(70,42): error TS2322: Type 'AsyncGenerator<number, any, undefined>' is not assignable to type 'Iterator<number, any, undefined>'.
-  Types of property 'next' are incompatible.
-    Type '(...args: [] | [undefined]) => Promise<IteratorResult<number, any>>' is not assignable to type '(...args: [] | [undefined]) => IteratorResult<number, any>'.
-      Type 'Promise<IteratorResult<number, any>>' is not assignable to type 'IteratorResult<number, any>'.
-        Property 'value' is missing in type 'Promise<IteratorResult<number, any>>' but required in type 'IteratorYieldResult<number>'.
+  The types returned by 'next(...)' are incompatible between these types.
+    Type 'Promise<IteratorResult<number, any>>' is not assignable to type 'IteratorResult<number, any>'.
+      Property 'value' is missing in type 'Promise<IteratorResult<number, any>>' but required in type 'IteratorYieldResult<number>'.
 tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(74,12): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator.
 
 
@@ -77,14 +66,13 @@ tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(
     const assignability1: () => AsyncIterableIterator<number> = async function * () {
           ~~~~~~~~~~~~~~
 !!! error TS2322: Type '() => AsyncGenerator<string, void, undefined>' is not assignable to type '() => AsyncIterableIterator<number>'.
-!!! error TS2322:   Type 'AsyncGenerator<string, void, undefined>' is not assignable to type 'AsyncIterableIterator<number>'.
-!!! error TS2322:     Types of property 'next' are incompatible.
-!!! error TS2322:       Type '(...args: [] | [undefined]) => Promise<IteratorResult<string, void>>' is not assignable to type '(...args: [] | [undefined]) => Promise<IteratorResult<number, any>>'.
-!!! error TS2322:         Type 'Promise<IteratorResult<string, void>>' is not assignable to type 'Promise<IteratorResult<number, any>>'.
-!!! error TS2322:           Type 'IteratorResult<string, void>' is not assignable to type 'IteratorResult<number, any>'.
-!!! error TS2322:             Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorResult<number, any>'.
-!!! error TS2322:               Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorYieldResult<number>'.
-!!! error TS2322:                 Type 'string' is not assignable to type 'number'.
+!!! error TS2322:   Call signature return types 'AsyncGenerator<string, void, undefined>' and 'AsyncIterableIterator<number>' are incompatible.
+!!! error TS2322:     The types returned by 'next(...)' are incompatible between these types.
+!!! error TS2322:       Type 'Promise<IteratorResult<string, void>>' is not assignable to type 'Promise<IteratorResult<number, any>>'.
+!!! error TS2322:         Type 'IteratorResult<string, void>' is not assignable to type 'IteratorResult<number, any>'.
+!!! error TS2322:           Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorResult<number, any>'.
+!!! error TS2322:             Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorYieldResult<number>'.
+!!! error TS2322:               Type 'string' is not assignable to type 'number'.
         yield "a";
     };
     const assignability2: () => AsyncIterableIterator<number> = async function * () {
@@ -96,22 +84,17 @@ tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(
     const assignability3: () => AsyncIterableIterator<number> = async function * () {
           ~~~~~~~~~~~~~~
 !!! error TS2322: Type '() => AsyncGenerator<string, void, unknown>' is not assignable to type '() => AsyncIterableIterator<number>'.
-!!! error TS2322:   Type 'AsyncGenerator<string, void, unknown>' is not assignable to type 'AsyncIterableIterator<number>'.
-!!! error TS2322:     Types of property 'next' are incompatible.
-!!! error TS2322:       Type '(...args: [] | [unknown]) => Promise<IteratorResult<string, void>>' is not assignable to type '(...args: [] | [undefined]) => Promise<IteratorResult<number, any>>'.
-!!! error TS2322:         Type 'Promise<IteratorResult<string, void>>' is not assignable to type 'Promise<IteratorResult<number, any>>'.
+!!! error TS2322:   Call signature return types 'AsyncGenerator<string, void, unknown>' and 'AsyncIterableIterator<number>' are incompatible.
+!!! error TS2322:     The types returned by 'next(...)' are incompatible between these types.
+!!! error TS2322:       Type 'Promise<IteratorResult<string, void>>' is not assignable to type 'Promise<IteratorResult<number, any>>'.
         yield* (async function * () { yield "a"; })();
     };
     const assignability4: () => AsyncIterable<number> = async function * () {
           ~~~~~~~~~~~~~~
 !!! error TS2322: Type '() => AsyncGenerator<string, void, undefined>' is not assignable to type '() => AsyncIterable<number>'.
-!!! error TS2322:   Type 'AsyncGenerator<string, void, undefined>' is not assignable to type 'AsyncIterable<number>'.
-!!! error TS2322:     Types of property '[Symbol.asyncIterator]' are incompatible.
-!!! error TS2322:       Type '() => AsyncGenerator<string, void, undefined>' is not assignable to type '() => AsyncIterator<number, any, undefined>'.
-!!! error TS2322:         Type 'AsyncGenerator<string, void, undefined>' is not assignable to type 'AsyncIterator<number, any, undefined>'.
-!!! error TS2322:           Types of property 'next' are incompatible.
-!!! error TS2322:             Type '(...args: [] | [undefined]) => Promise<IteratorResult<string, void>>' is not assignable to type '(...args: [] | [undefined]) => Promise<IteratorResult<number, any>>'.
-!!! error TS2322:               Type 'Promise<IteratorResult<string, void>>' is not assignable to type 'Promise<IteratorResult<number, any>>'.
+!!! error TS2322:   Call signature return types 'AsyncGenerator<string, void, undefined>' and 'AsyncIterable<number>' are incompatible.
+!!! error TS2322:     The types returned by '[Symbol.asyncIterator]().next(...)' are incompatible between these types.
+!!! error TS2322:       Type 'Promise<IteratorResult<string, void>>' is not assignable to type 'Promise<IteratorResult<number, any>>'.
         yield "a";
     };
     const assignability5: () => AsyncIterable<number> = async function * () {
@@ -123,13 +106,9 @@ tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(
     const assignability6: () => AsyncIterable<number> = async function * () {
           ~~~~~~~~~~~~~~
 !!! error TS2322: Type '() => AsyncGenerator<string, void, unknown>' is not assignable to type '() => AsyncIterable<number>'.
-!!! error TS2322:   Type 'AsyncGenerator<string, void, unknown>' is not assignable to type 'AsyncIterable<number>'.
-!!! error TS2322:     Types of property '[Symbol.asyncIterator]' are incompatible.
-!!! error TS2322:       Type '() => AsyncGenerator<string, void, unknown>' is not assignable to type '() => AsyncIterator<number, any, undefined>'.
-!!! error TS2322:         Type 'AsyncGenerator<string, void, unknown>' is not assignable to type 'AsyncIterator<number, any, undefined>'.
-!!! error TS2322:           Types of property 'next' are incompatible.
-!!! error TS2322:             Type '(...args: [] | [unknown]) => Promise<IteratorResult<string, void>>' is not assignable to type '(...args: [] | [undefined]) => Promise<IteratorResult<number, any>>'.
-!!! error TS2322:               Type 'Promise<IteratorResult<string, void>>' is not assignable to type 'Promise<IteratorResult<number, any>>'.
+!!! error TS2322:   Call signature return types 'AsyncGenerator<string, void, unknown>' and 'AsyncIterable<number>' are incompatible.
+!!! error TS2322:     The types returned by '[Symbol.asyncIterator]().next(...)' are incompatible between these types.
+!!! error TS2322:       Type 'Promise<IteratorResult<string, void>>' is not assignable to type 'Promise<IteratorResult<number, any>>'.
         yield* (async function * () { yield "a"; })();
     };
     const assignability7: () => AsyncIterator<number> = async function * () {
@@ -210,10 +189,9 @@ tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(
     async function * explicitReturnType12(): Iterator<number> {
                                              ~~~~~~~~~~~~~~~~
 !!! error TS2322: Type 'AsyncGenerator<number, any, undefined>' is not assignable to type 'Iterator<number, any, undefined>'.
-!!! error TS2322:   Types of property 'next' are incompatible.
-!!! error TS2322:     Type '(...args: [] | [undefined]) => Promise<IteratorResult<number, any>>' is not assignable to type '(...args: [] | [undefined]) => IteratorResult<number, any>'.
-!!! error TS2322:       Type 'Promise<IteratorResult<number, any>>' is not assignable to type 'IteratorResult<number, any>'.
-!!! error TS2322:         Property 'value' is missing in type 'Promise<IteratorResult<number, any>>' but required in type 'IteratorYieldResult<number>'.
+!!! error TS2322:   The types returned by 'next(...)' are incompatible between these types.
+!!! error TS2322:     Type 'Promise<IteratorResult<number, any>>' is not assignable to type 'IteratorResult<number, any>'.
+!!! error TS2322:       Property 'value' is missing in type 'Promise<IteratorResult<number, any>>' but required in type 'IteratorYieldResult<number>'.
 !!! related TS2728 /.ts/lib.es2015.iterable.d.ts:33:5: 'value' is declared here.
         yield 1;
     }
diff --git a/tests/baselines/reference/user/assert.log b/tests/baselines/reference/user/assert.log
index 4b00cccc6ab..ce8e6cc19d0 100644
--- a/tests/baselines/reference/user/assert.log
+++ b/tests/baselines/reference/user/assert.log
@@ -1,34 +1,34 @@
 Exit Code: 1
 Standard output:
 node_modules/assert/test.js(25,5): error TS2367: This condition will always return 'false' since the types 'string | undefined' and 'boolean' have no overlap.
-node_modules/assert/test.js(39,5): error TS2552: Cannot find name 'test'. Did you mean 'tests'?
-node_modules/assert/test.js(55,5): error TS2552: Cannot find name 'test'. Did you mean 'tests'?
-node_modules/assert/test.js(74,5): error TS2552: Cannot find name 'test'. Did you mean 'tests'?
-node_modules/assert/test.js(84,5): error TS2552: Cannot find name 'test'. Did you mean 'tests'?
-node_modules/assert/test.js(94,5): error TS2552: Cannot find name 'test'. Did you mean 'tests'?
-node_modules/assert/test.js(103,5): error TS2552: Cannot find name 'test'. Did you mean 'tests'?
-node_modules/assert/test.js(120,5): error TS2552: Cannot find name 'test'. Did you mean 'tests'?
-node_modules/assert/test.js(128,5): error TS2552: Cannot find name 'test'. Did you mean 'tests'?
+node_modules/assert/test.js(39,5): error TS2593: Cannot find name 'test'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha` and then add `jest` or `mocha` to the types field in your tsconfig.
+node_modules/assert/test.js(55,5): error TS2593: Cannot find name 'test'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha` and then add `jest` or `mocha` to the types field in your tsconfig.
+node_modules/assert/test.js(74,5): error TS2593: Cannot find name 'test'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha` and then add `jest` or `mocha` to the types field in your tsconfig.
+node_modules/assert/test.js(84,5): error TS2593: Cannot find name 'test'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha` and then add `jest` or `mocha` to the types field in your tsconfig.
+node_modules/assert/test.js(94,5): error TS2593: Cannot find name 'test'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha` and then add `jest` or `mocha` to the types field in your tsconfig.
+node_modules/assert/test.js(103,5): error TS2593: Cannot find name 'test'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha` and then add `jest` or `mocha` to the types field in your tsconfig.
+node_modules/assert/test.js(120,5): error TS2593: Cannot find name 'test'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha` and then add `jest` or `mocha` to the types field in your tsconfig.
+node_modules/assert/test.js(128,5): error TS2593: Cannot find name 'test'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha` and then add `jest` or `mocha` to the types field in your tsconfig.
 node_modules/assert/test.js(140,10): error TS2339: Property 'a' does not exist on type 'number[]'.
 node_modules/assert/test.js(141,10): error TS2339: Property 'b' does not exist on type 'number[]'.
 node_modules/assert/test.js(142,10): error TS2339: Property 'b' does not exist on type 'number[]'.
 node_modules/assert/test.js(143,10): error TS2339: Property 'a' does not exist on type 'number[]'.
-node_modules/assert/test.js(149,5): error TS2552: Cannot find name 'test'. Did you mean 'tests'?
+node_modules/assert/test.js(149,5): error TS2593: Cannot find name 'test'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha` and then add `jest` or `mocha` to the types field in your tsconfig.
 node_modules/assert/test.js(157,51): error TS2349: This expression is not callable.
   Type 'never' has no call signatures.
-node_modules/assert/test.js(161,5): error TS2552: Cannot find name 'test'. Did you mean 'tests'?
+node_modules/assert/test.js(161,5): error TS2593: Cannot find name 'test'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha` and then add `jest` or `mocha` to the types field in your tsconfig.
 node_modules/assert/test.js(168,5): error TS2593: Cannot find name 'test'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha` and then add `jest` or `mocha` to the types field in your tsconfig.
-node_modules/assert/test.js(182,5): error TS2593: Cannot find name 'test'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha` and then add `jest` or `mocha` to the types field in your tsconfig.
-node_modules/assert/test.js(229,5): error TS2593: Cannot find name 'test'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha` and then add `jest` or `mocha` to the types field in your tsconfig.
-node_modules/assert/test.js(235,5): error TS2593: Cannot find name 'test'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha` and then add `jest` or `mocha` to the types field in your tsconfig.
-node_modules/assert/test.js(250,5): error TS2593: Cannot find name 'test'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha` and then add `jest` or `mocha` to the types field in your tsconfig.
-node_modules/assert/test.js(254,5): error TS2593: Cannot find name 'test'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha` and then add `jest` or `mocha` to the types field in your tsconfig.
+node_modules/assert/test.js(182,5): error TS2552: Cannot find name 'test'. Did you mean 'tests'?
+node_modules/assert/test.js(229,5): error TS2552: Cannot find name 'test'. Did you mean 'tests'?
+node_modules/assert/test.js(235,5): error TS2552: Cannot find name 'test'. Did you mean 'tests'?
+node_modules/assert/test.js(250,5): error TS2552: Cannot find name 'test'. Did you mean 'tests'?
+node_modules/assert/test.js(254,5): error TS2552: Cannot find name 'test'. Did you mean 'tests'?
 node_modules/assert/test.js(256,55): error TS2345: Argument of type 'TypeError' is not assignable to parameter of type 'string'.
-node_modules/assert/test.js(262,5): error TS2593: Cannot find name 'test'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha` and then add `jest` or `mocha` to the types field in your tsconfig.
-node_modules/assert/test.js(279,5): error TS2593: Cannot find name 'test'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha` and then add `jest` or `mocha` to the types field in your tsconfig.
-node_modules/assert/test.js(285,5): error TS2593: Cannot find name 'test'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha` and then add `jest` or `mocha` to the types field in your tsconfig.
-node_modules/assert/test.js(320,5): error TS2593: Cannot find name 'test'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha` and then add `jest` or `mocha` to the types field in your tsconfig.
-node_modules/assert/test.js(346,5): error TS2593: Cannot find name 'test'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha` and then add `jest` or `mocha` to the types field in your tsconfig.
+node_modules/assert/test.js(262,5): error TS2552: Cannot find name 'test'. Did you mean 'tests'?
+node_modules/assert/test.js(279,5): error TS2552: Cannot find name 'test'. Did you mean 'tests'?
+node_modules/assert/test.js(285,5): error TS2552: Cannot find name 'test'. Did you mean 'tests'?
+node_modules/assert/test.js(320,5): error TS2552: Cannot find name 'test'. Did you mean 'tests'?
+node_modules/assert/test.js(346,5): error TS2552: Cannot find name 'test'. Did you mean 'tests'?
 
 
 
diff --git a/tests/baselines/reference/user/chrome-devtools-frontend.log b/tests/baselines/reference/user/chrome-devtools-frontend.log
index bad901d3d57..c9ce3bc730b 100644
--- a/tests/baselines/reference/user/chrome-devtools-frontend.log
+++ b/tests/baselines/reference/user/chrome-devtools-frontend.log
@@ -3990,10 +3990,9 @@ node_modules/chrome-devtools-frontend/front_end/console/ConsoleView.js(1277,60):
 node_modules/chrome-devtools-frontend/front_end/console/ConsoleView.js(1278,42): error TS2769: No overload matches this call.
   Overload 1 of 2, '(...items: ConcatArray<{ key: string; text: string; regex: RegExp; negative: boolean; }>[]): { key: string; text: string; regex: RegExp; negative: boolean; }[]', gave the following error.
     Argument of type '{ key: any; text: string; negative: boolean; }[]' is not assignable to parameter of type 'ConcatArray<{ key: string; text: string; regex: RegExp; negative: boolean; }>'.
-      Types of property 'slice' are incompatible.
-        Type '(start?: number, end?: number) => { key: any; text: string; negative: boolean; }[]' is not assignable to type '(start?: number, end?: number) => { key: string; text: string; regex: RegExp; negative: boolean; }[]'.
-          Type '{ key: any; text: string; negative: boolean; }[]' is not assignable to type '{ key: string; text: string; regex: RegExp; negative: boolean; }[]'.
-            Property 'regex' is missing in type '{ key: any; text: string; negative: boolean; }' but required in type '{ key: string; text: string; regex: RegExp; negative: boolean; }'.
+      The types returned by 'slice(...)' are incompatible between these types.
+        Type '{ key: any; text: string; negative: boolean; }[]' is not assignable to type '{ key: string; text: string; regex: RegExp; negative: boolean; }[]'.
+          Property 'regex' is missing in type '{ key: any; text: string; negative: boolean; }' but required in type '{ key: string; text: string; regex: RegExp; negative: boolean; }'.
   Overload 2 of 2, '(...items: ({ key: string; text: string; regex: RegExp; negative: boolean; } | ConcatArray<{ key: string; text: string; regex: RegExp; negative: boolean; }>)[]): { key: string; text: string; regex: RegExp; negative: boolean; }[]', gave the following error.
     Argument of type '{ key: any; text: string; negative: boolean; }[]' is not assignable to parameter of type '{ key: string; text: string; regex: RegExp; negative: boolean; } | ConcatArray<{ key: string; text: string; regex: RegExp; negative: boolean; }>'.
       Type '{ key: any; text: string; negative: boolean; }[]' is not assignable to type 'ConcatArray<{ key: string; text: string; regex: RegExp; negative: boolean; }>'.
@@ -5038,22 +5037,18 @@ node_modules/chrome-devtools-frontend/front_end/elements/ComputedStyleWidget.js(
 node_modules/chrome-devtools-frontend/front_end/elements/ComputedStyleWidget.js(91,24): error TS2769: No overload matches this call.
   The last overload gave the following error.
     Argument of type '(Promise<CSSMatchedStyles> | Promise<ComputedStyle>)[]' is not assignable to parameter of type 'Iterable<CSSMatchedStyles | PromiseLike<CSSMatchedStyles>>'.
-      Types of property '[Symbol.iterator]' are incompatible.
-        Type '() => IterableIterator<Promise<CSSMatchedStyles> | Promise<ComputedStyle>>' is not assignable to type '() => Iterator<CSSMatchedStyles | PromiseLike<CSSMatchedStyles>, any, undefined>'.
-          Type 'IterableIterator<Promise<CSSMatchedStyles> | Promise<ComputedStyle>>' is not assignable to type 'Iterator<CSSMatchedStyles | PromiseLike<CSSMatchedStyles>, any, undefined>'.
-            Types of property 'next' are incompatible.
-              Type '(...args: [] | [undefined]) => IteratorResult<Promise<CSSMatchedStyles> | Promise<ComputedStyle>, any>' is not assignable to type '(...args: [] | [undefined]) => IteratorResult<CSSMatchedStyles | PromiseLike<CSSMatchedStyles>, any>'.
-                Type 'IteratorResult<Promise<CSSMatchedStyles> | Promise<ComputedStyle>, any>' is not assignable to type 'IteratorResult<CSSMatchedStyles | PromiseLike<CSSMatchedStyles>, any>'.
-                  Type 'IteratorYieldResult<Promise<CSSMatchedStyles> | Promise<ComputedStyle>>' is not assignable to type 'IteratorResult<CSSMatchedStyles | PromiseLike<CSSMatchedStyles>, any>'.
-                    Type 'IteratorYieldResult<Promise<CSSMatchedStyles> | Promise<ComputedStyle>>' is not assignable to type 'IteratorYieldResult<CSSMatchedStyles | PromiseLike<CSSMatchedStyles>>'.
-                      Type 'Promise<CSSMatchedStyles> | Promise<ComputedStyle>' is not assignable to type 'CSSMatchedStyles | PromiseLike<CSSMatchedStyles>'.
-                        Type 'Promise<ComputedStyle>' is not assignable to type 'CSSMatchedStyles | PromiseLike<CSSMatchedStyles>'.
-                          Type 'Promise<ComputedStyle>' is not assignable to type 'PromiseLike<CSSMatchedStyles>'.
-                            Types of property 'then' are incompatible.
-                              Type '<TResult1 = ComputedStyle, TResult2 = never>(onfulfilled?: (value: ComputedStyle) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>' is not assignable to type '<TResult1 = CSSMatchedStyles, TResult2 = never>(onfulfilled?: (value: CSSMatchedStyles) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => PromiseLike<...>'.
-                                Types of parameters 'onfulfilled' and 'onfulfilled' are incompatible.
-                                  Types of parameters 'value' and 'value' are incompatible.
-                                    Type 'ComputedStyle' is missing the following properties from type 'CSSMatchedStyles': _cssModel, _node, _nodeStyles, _nodeForStyle, and 22 more.
+      The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types.
+        Type 'IteratorResult<Promise<CSSMatchedStyles> | Promise<ComputedStyle>, any>' is not assignable to type 'IteratorResult<CSSMatchedStyles | PromiseLike<CSSMatchedStyles>, any>'.
+          Type 'IteratorYieldResult<Promise<CSSMatchedStyles> | Promise<ComputedStyle>>' is not assignable to type 'IteratorResult<CSSMatchedStyles | PromiseLike<CSSMatchedStyles>, any>'.
+            Type 'IteratorYieldResult<Promise<CSSMatchedStyles> | Promise<ComputedStyle>>' is not assignable to type 'IteratorYieldResult<CSSMatchedStyles | PromiseLike<CSSMatchedStyles>>'.
+              Type 'Promise<CSSMatchedStyles> | Promise<ComputedStyle>' is not assignable to type 'CSSMatchedStyles | PromiseLike<CSSMatchedStyles>'.
+                Type 'Promise<ComputedStyle>' is not assignable to type 'CSSMatchedStyles | PromiseLike<CSSMatchedStyles>'.
+                  Type 'Promise<ComputedStyle>' is not assignable to type 'PromiseLike<CSSMatchedStyles>'.
+                    Types of property 'then' are incompatible.
+                      Type '<TResult1 = ComputedStyle, TResult2 = never>(onfulfilled?: (value: ComputedStyle) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>' is not assignable to type '<TResult1 = CSSMatchedStyles, TResult2 = never>(onfulfilled?: (value: CSSMatchedStyles) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => PromiseLike<...>'.
+                        Types of parameters 'onfulfilled' and 'onfulfilled' are incompatible.
+                          Types of parameters 'value' and 'value' are incompatible.
+                            Type 'ComputedStyle' is missing the following properties from type 'CSSMatchedStyles': _cssModel, _node, _nodeStyles, _nodeForStyle, and 22 more.
 node_modules/chrome-devtools-frontend/front_end/elements/ComputedStyleWidget.js(147,52): error TS2339: Property 'keysArray' does not exist on type 'Map<string, string>'.
 node_modules/chrome-devtools-frontend/front_end/elements/ComputedStyleWidget.js(179,50): error TS2339: Property 'createChild' does not exist on type 'Element'.
 node_modules/chrome-devtools-frontend/front_end/elements/ComputedStyleWidget.js(200,74): error TS2339: Property 'consume' does not exist on type 'Event'.
@@ -5339,22 +5334,18 @@ node_modules/chrome-devtools-frontend/front_end/elements/MetricsSidebarPane.js(5
 node_modules/chrome-devtools-frontend/front_end/elements/MetricsSidebarPane.js(82,24): error TS2769: No overload matches this call.
   The last overload gave the following error.
     Argument of type '(Promise<Map<string, string>> | Promise<InlineStyleResult>)[]' is not assignable to parameter of type 'Iterable<Map<string, string> | PromiseLike<Map<string, string>>>'.
-      Types of property '[Symbol.iterator]' are incompatible.
-        Type '() => IterableIterator<Promise<Map<string, string>> | Promise<InlineStyleResult>>' is not assignable to type '() => Iterator<Map<string, string> | PromiseLike<Map<string, string>>, any, undefined>'.
-          Type 'IterableIterator<Promise<Map<string, string>> | Promise<InlineStyleResult>>' is not assignable to type 'Iterator<Map<string, string> | PromiseLike<Map<string, string>>, any, undefined>'.
-            Types of property 'next' are incompatible.
-              Type '(...args: [] | [undefined]) => IteratorResult<Promise<Map<string, string>> | Promise<InlineStyleResult>, any>' is not assignable to type '(...args: [] | [undefined]) => IteratorResult<Map<string, string> | PromiseLike<Map<string, string>>, any>'.
-                Type 'IteratorResult<Promise<Map<string, string>> | Promise<InlineStyleResult>, any>' is not assignable to type 'IteratorResult<Map<string, string> | PromiseLike<Map<string, string>>, any>'.
-                  Type 'IteratorYieldResult<Promise<Map<string, string>> | Promise<InlineStyleResult>>' is not assignable to type 'IteratorResult<Map<string, string> | PromiseLike<Map<string, string>>, any>'.
-                    Type 'IteratorYieldResult<Promise<Map<string, string>> | Promise<InlineStyleResult>>' is not assignable to type 'IteratorYieldResult<Map<string, string> | PromiseLike<Map<string, string>>>'.
-                      Type 'Promise<Map<string, string>> | Promise<InlineStyleResult>' is not assignable to type 'Map<string, string> | PromiseLike<Map<string, string>>'.
-                        Type 'Promise<InlineStyleResult>' is not assignable to type 'Map<string, string> | PromiseLike<Map<string, string>>'.
-                          Type 'Promise<InlineStyleResult>' is not assignable to type 'PromiseLike<Map<string, string>>'.
-                            Types of property 'then' are incompatible.
-                              Type '<TResult1 = InlineStyleResult, TResult2 = never>(onfulfilled?: (value: InlineStyleResult) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<...>' is not assignable to type '<TResult1 = Map<string, string>, TResult2 = never>(onfulfilled?: (value: Map<string, string>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => PromiseLike<...>'.
-                                Types of parameters 'onfulfilled' and 'onfulfilled' are incompatible.
-                                  Types of parameters 'value' and 'value' are incompatible.
-                                    Type 'InlineStyleResult' is missing the following properties from type 'Map<string, string>': clear, delete, forEach, get, and 8 more.
+      The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types.
+        Type 'IteratorResult<Promise<Map<string, string>> | Promise<InlineStyleResult>, any>' is not assignable to type 'IteratorResult<Map<string, string> | PromiseLike<Map<string, string>>, any>'.
+          Type 'IteratorYieldResult<Promise<Map<string, string>> | Promise<InlineStyleResult>>' is not assignable to type 'IteratorResult<Map<string, string> | PromiseLike<Map<string, string>>, any>'.
+            Type 'IteratorYieldResult<Promise<Map<string, string>> | Promise<InlineStyleResult>>' is not assignable to type 'IteratorYieldResult<Map<string, string> | PromiseLike<Map<string, string>>>'.
+              Type 'Promise<Map<string, string>> | Promise<InlineStyleResult>' is not assignable to type 'Map<string, string> | PromiseLike<Map<string, string>>'.
+                Type 'Promise<InlineStyleResult>' is not assignable to type 'Map<string, string> | PromiseLike<Map<string, string>>'.
+                  Type 'Promise<InlineStyleResult>' is not assignable to type 'PromiseLike<Map<string, string>>'.
+                    Types of property 'then' are incompatible.
+                      Type '<TResult1 = InlineStyleResult, TResult2 = never>(onfulfilled?: (value: InlineStyleResult) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<...>' is not assignable to type '<TResult1 = Map<string, string>, TResult2 = never>(onfulfilled?: (value: Map<string, string>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => PromiseLike<...>'.
+                        Types of parameters 'onfulfilled' and 'onfulfilled' are incompatible.
+                          Types of parameters 'value' and 'value' are incompatible.
+                            Type 'InlineStyleResult' is missing the following properties from type 'Map<string, string>': clear, delete, forEach, get, and 8 more.
 node_modules/chrome-devtools-frontend/front_end/elements/MetricsSidebarPane.js(120,11): error TS2339: Property 'consume' does not exist on type 'Event'.
 node_modules/chrome-devtools-frontend/front_end/elements/MetricsSidebarPane.js(164,22): error TS2339: Property 'toFixedIfFloating' does not exist on type 'NumberConstructor'.
 node_modules/chrome-devtools-frontend/front_end/elements/MetricsSidebarPane.js(179,18): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'.
@@ -12648,22 +12639,18 @@ node_modules/chrome-devtools-frontend/front_end/ui/View.js(454,38): error TS2339
 node_modules/chrome-devtools-frontend/front_end/ui/View.js(461,44): error TS2769: No overload matches this call.
   The last overload gave the following error.
     Argument of type '(Promise<void> | Promise<ToolbarItem[]>)[]' is not assignable to parameter of type 'Iterable<void | PromiseLike<void>>'.
-      Types of property '[Symbol.iterator]' are incompatible.
-        Type '() => IterableIterator<Promise<void> | Promise<ToolbarItem[]>>' is not assignable to type '() => Iterator<void | PromiseLike<void>, any, undefined>'.
-          Type 'IterableIterator<Promise<void> | Promise<ToolbarItem[]>>' is not assignable to type 'Iterator<void | PromiseLike<void>, any, undefined>'.
-            Types of property 'next' are incompatible.
-              Type '(...args: [] | [undefined]) => IteratorResult<Promise<void> | Promise<ToolbarItem[]>, any>' is not assignable to type '(...args: [] | [undefined]) => IteratorResult<void | PromiseLike<void>, any>'.
-                Type 'IteratorResult<Promise<void> | Promise<ToolbarItem[]>, any>' is not assignable to type 'IteratorResult<void | PromiseLike<void>, any>'.
-                  Type 'IteratorYieldResult<Promise<void> | Promise<ToolbarItem[]>>' is not assignable to type 'IteratorResult<void | PromiseLike<void>, any>'.
-                    Type 'IteratorYieldResult<Promise<void> | Promise<ToolbarItem[]>>' is not assignable to type 'IteratorYieldResult<void | PromiseLike<void>>'.
-                      Type 'Promise<void> | Promise<ToolbarItem[]>' is not assignable to type 'void | PromiseLike<void>'.
-                        Type 'Promise<ToolbarItem[]>' is not assignable to type 'void | PromiseLike<void>'.
-                          Type 'Promise<ToolbarItem[]>' is not assignable to type 'PromiseLike<void>'.
-                            Types of property 'then' are incompatible.
-                              Type '<TResult1 = ToolbarItem[], TResult2 = never>(onfulfilled?: (value: ToolbarItem[]) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>' is not assignable to type '<TResult1 = void, TResult2 = never>(onfulfilled?: (value: void) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => PromiseLike<TResult1 | TResult2>'.
-                                Types of parameters 'onfulfilled' and 'onfulfilled' are incompatible.
-                                  Types of parameters 'value' and 'value' are incompatible.
-                                    Type 'ToolbarItem[]' is not assignable to type 'void'.
+      The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types.
+        Type 'IteratorResult<Promise<void> | Promise<ToolbarItem[]>, any>' is not assignable to type 'IteratorResult<void | PromiseLike<void>, any>'.
+          Type 'IteratorYieldResult<Promise<void> | Promise<ToolbarItem[]>>' is not assignable to type 'IteratorResult<void | PromiseLike<void>, any>'.
+            Type 'IteratorYieldResult<Promise<void> | Promise<ToolbarItem[]>>' is not assignable to type 'IteratorYieldResult<void | PromiseLike<void>>'.
+              Type 'Promise<void> | Promise<ToolbarItem[]>' is not assignable to type 'void | PromiseLike<void>'.
+                Type 'Promise<ToolbarItem[]>' is not assignable to type 'void | PromiseLike<void>'.
+                  Type 'Promise<ToolbarItem[]>' is not assignable to type 'PromiseLike<void>'.
+                    Types of property 'then' are incompatible.
+                      Type '<TResult1 = ToolbarItem[], TResult2 = never>(onfulfilled?: (value: ToolbarItem[]) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>' is not assignable to type '<TResult1 = void, TResult2 = never>(onfulfilled?: (value: void) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => PromiseLike<TResult1 | TResult2>'.
+                        Types of parameters 'onfulfilled' and 'onfulfilled' are incompatible.
+                          Types of parameters 'value' and 'value' are incompatible.
+                            Type 'ToolbarItem[]' is not assignable to type 'void'.
 node_modules/chrome-devtools-frontend/front_end/ui/View.js(495,24): error TS2339: Property 'createTextChild' does not exist on type 'Element'.
 node_modules/chrome-devtools-frontend/front_end/ui/View.js(496,24): error TS2339: Property 'tabIndex' does not exist on type 'Element'.
 node_modules/chrome-devtools-frontend/front_end/ui/View.js(501,25): error TS2339: Property 'createChild' does not exist on type 'Element'.
diff --git a/tests/baselines/reference/user/prettier.log b/tests/baselines/reference/user/prettier.log
index 93ccd99a0d6..71fb532b794 100644
--- a/tests/baselines/reference/user/prettier.log
+++ b/tests/baselines/reference/user/prettier.log
@@ -142,10 +142,9 @@ src/language-html/printer-html.js(314,13): error TS2769: No overload matches thi
 src/language-html/printer-html.js(471,11): error TS2769: No overload matches this call.
   Overload 1 of 2, '(...items: ConcatArray<never>[]): never[]', gave the following error.
     Argument of type '{ type: string; parts: any; }[]' is not assignable to parameter of type 'ConcatArray<never>'.
-      Types of property 'slice' are incompatible.
-        Type '(start?: number | undefined, end?: number | undefined) => { type: string; parts: any; }[]' is not assignable to type '(start?: number | undefined, end?: number | undefined) => never[]'.
-          Type '{ type: string; parts: any; }[]' is not assignable to type 'never[]'.
-            Type '{ type: string; parts: any; }' is not assignable to type 'never'.
+      The types returned by 'slice(...)' are incompatible between these types.
+        Type '{ type: string; parts: any; }[]' is not assignable to type 'never[]'.
+          Type '{ type: string; parts: any; }' is not assignable to type 'never'.
   Overload 2 of 2, '(...items: ConcatArray<never>[]): never[]', gave the following error.
     Argument of type '{ type: string; parts: any; }[]' is not assignable to parameter of type 'ConcatArray<never>'.
 src/language-html/printer-html.js(492,11): error TS2769: No overload matches this call.
@@ -169,7 +168,7 @@ src/language-html/syntax-vue.js(14,27): error TS2339: Property 'right' does not
 src/language-html/utils.js(10,30): error TS2307: Cannot find module 'html-tag-names'.
 src/language-html/utils.js(11,39): error TS2307: Cannot find module 'html-element-attributes'.
 src/language-html/utils.js(444,17): error TS2554: Expected 0 arguments, but got 1.
-src/language-js/comments.js(864,64): error TS2554: Expected 0 arguments, but got 1.
+src/language-js/comments.js(865,64): error TS2554: Expected 0 arguments, but got 1.
 src/language-js/index.js(9,26): error TS2307: Cannot find module 'linguist-languages/data/JavaScript'.
 src/language-js/index.js(9,65): error TS2345: Argument of type '{ override: { since: string; parsers: string[]; vscodeLanguageIds: string[]; }; extend: { interpreters: string[]; }; }' is not assignable to parameter of type '{ extend: any; override: any; exclude: any; }'.
   Property 'exclude' is missing in type '{ override: { since: string; parsers: string[]; vscodeLanguageIds: string[]; }; extend: { interpreters: string[]; }; }' but required in type '{ extend: any; override: any; exclude: any; }'.
@@ -200,11 +199,10 @@ src/language-js/index.js(81,60): error TS2345: Argument of type '{ override: { s
 src/language-js/needs-parens.js(871,14): error TS2769: No overload matches this call.
   Overload 1 of 2, '(...items: ConcatArray<(childPath: any) => any>[]): ((childPath: any) => any)[]', gave the following error.
     Argument of type '(string | number)[]' is not assignable to parameter of type 'ConcatArray<(childPath: any) => any>'.
-      Types of property 'slice' are incompatible.
-        Type '(start?: number | undefined, end?: number | undefined) => (string | number)[]' is not assignable to type '(start?: number | undefined, end?: number | undefined) => ((childPath: any) => any)[]'.
-          Type '(string | number)[]' is not assignable to type '((childPath: any) => any)[]'.
-            Type 'string | number' is not assignable to type '(childPath: any) => any'.
-              Type 'string' is not assignable to type '(childPath: any) => any'.
+      The types returned by 'slice(...)' are incompatible between these types.
+        Type '(string | number)[]' is not assignable to type '((childPath: any) => any)[]'.
+          Type 'string | number' is not assignable to type '(childPath: any) => any'.
+            Type 'string' is not assignable to type '(childPath: any) => any'.
   Overload 2 of 2, '(...items: (((childPath: any) => any) | ConcatArray<(childPath: any) => any>)[]): ((childPath: any) => any)[]', gave the following error.
     Argument of type '(string | number)[]' is not assignable to parameter of type '((childPath: any) => any) | ConcatArray<(childPath: any) => any>'.
       Type '(string | number)[]' is not assignable to type 'ConcatArray<(childPath: any) => any>'.
@@ -219,56 +217,55 @@ src/language-js/printer-estree.js(400,9): error TS2769: No overload matches this
   Overload 2 of 2, '(...items: ConcatArray<never>[]): never[]', gave the following error.
     Argument of type '{ type: string; parts: any; } | { type: string; contents: any; n: any; }' is not assignable to parameter of type 'ConcatArray<never>'.
       Type '{ type: string; parts: any; }' is not assignable to type 'ConcatArray<never>'.
-src/language-js/printer-estree.js(1480,28): error TS2769: No overload matches this call.
+src/language-js/printer-estree.js(1481,28): error TS2769: No overload matches this call.
   Overload 1 of 2, '(...items: ConcatArray<string | { type: string; id: any; contents: any; break: boolean; expandedStates: any; }>[]): (string | { type: string; id: any; contents: any; break: boolean; expandedStates: any; })[]', gave the following error.
     Argument of type '{ type: string; parts: any; }' is not assignable to parameter of type 'ConcatArray<string | { type: string; id: any; contents: any; break: boolean; expandedStates: any; }>'.
       Type '{ type: string; parts: any; }' is missing the following properties from type 'ConcatArray<string | { type: string; id: any; contents: any; break: boolean; expandedStates: any; }>': length, join, slice
   Overload 2 of 2, '(...items: (string | { type: string; id: any; contents: any; break: boolean; expandedStates: any; } | ConcatArray<string | { type: string; id: any; contents: any; break: boolean; expandedStates: any; }>)[]): (string | { ...; })[]', gave the following error.
     Argument of type '{ type: string; parts: any; }' is not assignable to parameter of type 'string | { type: string; id: any; contents: any; break: boolean; expandedStates: any; } | ConcatArray<string | { type: string; id: any; contents: any; break: boolean; expandedStates: any; }>'.
       Type '{ type: string; parts: any; }' is missing the following properties from type '{ type: string; id: any; contents: any; break: boolean; expandedStates: any; }': id, contents, break, expandedStates
-src/language-js/printer-estree.js(1913,20): error TS2345: Argument of type '" "' is not assignable to parameter of type '{ type: string; id: any; contents: any; break: boolean; expandedStates: any; }'.
-src/language-js/printer-estree.js(1915,20): error TS2345: Argument of type '{ type: string; parts: any; }' is not assignable to parameter of type '{ type: string; id: any; contents: any; break: boolean; expandedStates: any; }'.
-src/language-js/printer-estree.js(1917,18): error TS2345: Argument of type '"while ("' is not assignable to parameter of type '{ type: string; id: any; contents: any; break: boolean; expandedStates: any; }'.
-src/language-js/printer-estree.js(1926,9): error TS2345: Argument of type '")"' is not assignable to parameter of type '{ type: string; id: any; contents: any; break: boolean; expandedStates: any; }'.
-src/language-js/printer-estree.js(3472,11): error TS2769: No overload matches this call.
+src/language-js/printer-estree.js(1914,20): error TS2345: Argument of type '" "' is not assignable to parameter of type '{ type: string; id: any; contents: any; break: boolean; expandedStates: any; }'.
+src/language-js/printer-estree.js(1916,20): error TS2345: Argument of type '{ type: string; parts: any; }' is not assignable to parameter of type '{ type: string; id: any; contents: any; break: boolean; expandedStates: any; }'.
+src/language-js/printer-estree.js(1918,18): error TS2345: Argument of type '"while ("' is not assignable to parameter of type '{ type: string; id: any; contents: any; break: boolean; expandedStates: any; }'.
+src/language-js/printer-estree.js(1927,9): error TS2345: Argument of type '")"' is not assignable to parameter of type '{ type: string; id: any; contents: any; break: boolean; expandedStates: any; }'.
+src/language-js/printer-estree.js(3473,11): error TS2769: No overload matches this call.
   Overload 1 of 2, '(...items: ConcatArray<never>[]): never[]', gave the following error.
     Argument of type 'never[] | { type: string; parts: any; }' is not assignable to parameter of type 'ConcatArray<never>'.
       Type '{ type: string; parts: any; }' is not assignable to type 'ConcatArray<never>'.
   Overload 2 of 2, '(...items: ConcatArray<never>[]): never[]', gave the following error.
     Argument of type 'never[] | { type: string; parts: any; }' is not assignable to parameter of type 'ConcatArray<never>'.
       Type '{ type: string; parts: any; }' is not assignable to type 'ConcatArray<never>'.
-src/language-js/printer-estree.js(3901,22): error TS2345: Argument of type 'any' is not assignable to parameter of type 'never'.
-src/language-js/printer-estree.js(3968,14): error TS2339: Property 'comments' does not exist on type 'Expression'.
+src/language-js/printer-estree.js(3902,22): error TS2345: Argument of type 'any' is not assignable to parameter of type 'never'.
+src/language-js/printer-estree.js(3969,14): error TS2339: Property 'comments' does not exist on type 'Expression'.
   Property 'comments' does not exist on type 'Identifier'.
-src/language-js/printer-estree.js(3980,9): error TS2367: This condition will always return 'false' since the types '"FunctionExpression" | "ClassExpression" | "ObjectExpression" | "TaggedTemplateExpression" | "CallExpression" | "ConditionalExpression" | "UpdateExpression" | "SequenceExpression" | ... 11 more ... | "MetaProperty"' and '"OptionalMemberExpression"' have no overlap.
-src/language-js/printer-estree.js(3981,13): error TS2339: Property 'property' does not exist on type 'SimpleLiteral | RegExpLiteral | FunctionExpression | ArrowFunctionExpression | ArrayExpression | ObjectExpression | YieldExpression | UnaryExpression | UpdateExpression | ... 12 more ... | AwaitExpression'.
+src/language-js/printer-estree.js(3981,9): error TS2367: This condition will always return 'false' since the types '"FunctionExpression" | "ClassExpression" | "ObjectExpression" | "TaggedTemplateExpression" | "CallExpression" | "ConditionalExpression" | "UpdateExpression" | "SequenceExpression" | ... 11 more ... | "MetaProperty"' and '"OptionalMemberExpression"' have no overlap.
+src/language-js/printer-estree.js(3982,13): error TS2339: Property 'property' does not exist on type 'SimpleLiteral | RegExpLiteral | FunctionExpression | ArrowFunctionExpression | ArrayExpression | ObjectExpression | YieldExpression | UnaryExpression | UpdateExpression | ... 12 more ... | AwaitExpression'.
   Property 'property' does not exist on type 'SimpleLiteral'.
-src/language-js/printer-estree.js(3981,52): error TS2339: Property 'property' does not exist on type 'SimpleLiteral | RegExpLiteral | FunctionExpression | ArrowFunctionExpression | ArrayExpression | ObjectExpression | YieldExpression | UnaryExpression | UpdateExpression | ... 12 more ... | AwaitExpression'.
+src/language-js/printer-estree.js(3982,52): error TS2339: Property 'property' does not exist on type 'SimpleLiteral | RegExpLiteral | FunctionExpression | ArrowFunctionExpression | ArrayExpression | ObjectExpression | YieldExpression | UnaryExpression | UpdateExpression | ... 12 more ... | AwaitExpression'.
   Property 'property' does not exist on type 'SimpleLiteral'.
-src/language-js/printer-estree.js(3986,9): error TS2367: This condition will always return 'false' since the types '"FunctionExpression" | "ClassExpression" | "ObjectExpression" | "TaggedTemplateExpression" | "CallExpression" | "ConditionalExpression" | "UpdateExpression" | "SequenceExpression" | ... 11 more ... | "MetaProperty"' and '"OptionalMemberExpression"' have no overlap.
-src/language-js/printer-estree.js(3988,29): error TS2339: Property 'object' does not exist on type 'SimpleLiteral | RegExpLiteral | FunctionExpression | ArrowFunctionExpression | ArrayExpression | ObjectExpression | YieldExpression | UnaryExpression | UpdateExpression | ... 12 more ... | AwaitExpression'.
+src/language-js/printer-estree.js(3987,9): error TS2367: This condition will always return 'false' since the types '"FunctionExpression" | "ClassExpression" | "ObjectExpression" | "TaggedTemplateExpression" | "CallExpression" | "ConditionalExpression" | "UpdateExpression" | "SequenceExpression" | ... 11 more ... | "MetaProperty"' and '"OptionalMemberExpression"' have no overlap.
+src/language-js/printer-estree.js(3989,29): error TS2339: Property 'object' does not exist on type 'SimpleLiteral | RegExpLiteral | FunctionExpression | ArrowFunctionExpression | ArrayExpression | ObjectExpression | YieldExpression | UnaryExpression | UpdateExpression | ... 12 more ... | AwaitExpression'.
   Property 'object' does not exist on type 'SimpleLiteral'.
-src/language-js/printer-estree.js(3989,22): error TS2339: Property 'comments' does not exist on type 'SimpleLiteral | RegExpLiteral | FunctionExpression | ArrowFunctionExpression | ArrayExpression | ObjectExpression | YieldExpression | UnaryExpression | UpdateExpression | ... 12 more ... | AwaitExpression'.
+src/language-js/printer-estree.js(3990,22): error TS2339: Property 'comments' does not exist on type 'SimpleLiteral | RegExpLiteral | FunctionExpression | ArrowFunctionExpression | ArrayExpression | ObjectExpression | YieldExpression | UnaryExpression | UpdateExpression | ... 12 more ... | AwaitExpression'.
   Property 'comments' does not exist on type 'SimpleLiteral'.
-src/language-js/printer-estree.js(3995,9): error TS2367: This condition will always return 'false' since the types '"FunctionExpression" | "ClassExpression" | "ObjectExpression" | "TaggedTemplateExpression" | "CallExpression" | "ConditionalExpression" | "UpdateExpression" | "SequenceExpression" | ... 11 more ... | "MetaProperty"' and '"Identifier"' have no overlap.
-src/language-js/printer-estree.js(3996,9): error TS2367: This condition will always return 'false' since the types '"FunctionExpression" | "ClassExpression" | "ObjectExpression" | "TaggedTemplateExpression" | "CallExpression" | "ConditionalExpression" | "UpdateExpression" | "SequenceExpression" | ... 11 more ... | "MetaProperty"' and '"ThisExpression"' have no overlap.
-src/language-js/printer-estree.js(4200,23): error TS2532: Object is possibly 'undefined'.
-src/language-js/printer-estree.js(4201,24): error TS2532: Object is possibly 'undefined'.
-src/language-js/printer-estree.js(4557,5): error TS2345: Argument of type '"" | { type: string; parts: any; } | { type: string; contents: any; }' is not assignable to parameter of type 'string'.
+src/language-js/printer-estree.js(3996,9): error TS2367: This condition will always return 'false' since the types '"FunctionExpression" | "ClassExpression" | "ObjectExpression" | "TaggedTemplateExpression" | "CallExpression" | "ConditionalExpression" | "UpdateExpression" | "SequenceExpression" | ... 11 more ... | "MetaProperty"' and '"Identifier"' have no overlap.
+src/language-js/printer-estree.js(3997,9): error TS2367: This condition will always return 'false' since the types '"FunctionExpression" | "ClassExpression" | "ObjectExpression" | "TaggedTemplateExpression" | "CallExpression" | "ConditionalExpression" | "UpdateExpression" | "SequenceExpression" | ... 11 more ... | "MetaProperty"' and '"ThisExpression"' have no overlap.
+src/language-js/printer-estree.js(4201,23): error TS2532: Object is possibly 'undefined'.
+src/language-js/printer-estree.js(4202,24): error TS2532: Object is possibly 'undefined'.
+src/language-js/printer-estree.js(4558,5): error TS2345: Argument of type '"" | { type: string; parts: any; } | { type: string; contents: any; }' is not assignable to parameter of type 'string'.
   Type '{ type: string; parts: any; }' is not assignable to type 'string'.
-src/language-js/printer-estree.js(4561,16): error TS2345: Argument of type '{ type: string; parts: any; }' is not assignable to parameter of type 'string'.
-src/language-js/printer-estree.js(4609,11): error TS2322: Type '{ type: string; id: any; contents: any; break: boolean; expandedStates: any; }' is not assignable to type 'string'.
-src/language-js/printer-estree.js(4624,11): error TS2322: Type '{ type: string; parts: any; }' is not assignable to type 'string'.
-src/language-js/printer-estree.js(4636,9): error TS2345: Argument of type '{ type: string; parts: any; }' is not assignable to parameter of type 'string'.
-src/language-js/printer-estree.js(4923,9): error TS2554: Expected 0-2 arguments, but got 3.
-src/language-js/printer-estree.js(6130,7): error TS2769: No overload matches this call.
+src/language-js/printer-estree.js(4562,16): error TS2345: Argument of type '{ type: string; parts: any; }' is not assignable to parameter of type 'string'.
+src/language-js/printer-estree.js(4610,11): error TS2322: Type '{ type: string; id: any; contents: any; break: boolean; expandedStates: any; }' is not assignable to type 'string'.
+src/language-js/printer-estree.js(4625,11): error TS2322: Type '{ type: string; parts: any; }' is not assignable to type 'string'.
+src/language-js/printer-estree.js(4637,9): error TS2345: Argument of type '{ type: string; parts: any; }' is not assignable to parameter of type 'string'.
+src/language-js/printer-estree.js(4924,9): error TS2554: Expected 0-2 arguments, but got 3.
+src/language-js/printer-estree.js(6131,7): error TS2769: No overload matches this call.
   Overload 1 of 2, '(...items: ConcatArray<(childPath: any) => any>[]): ((childPath: any) => any)[]', gave the following error.
     Argument of type '(string | number)[]' is not assignable to parameter of type 'ConcatArray<(childPath: any) => any>'.
-      Types of property 'slice' are incompatible.
-        Type '(start?: number | undefined, end?: number | undefined) => (string | number)[]' is not assignable to type '(start?: number | undefined, end?: number | undefined) => ((childPath: any) => any)[]'.
-          Type '(string | number)[]' is not assignable to type '((childPath: any) => any)[]'.
-            Type 'string | number' is not assignable to type '(childPath: any) => any'.
-              Type 'string' is not assignable to type '(childPath: any) => any'.
+      The types returned by 'slice(...)' are incompatible between these types.
+        Type '(string | number)[]' is not assignable to type '((childPath: any) => any)[]'.
+          Type 'string | number' is not assignable to type '(childPath: any) => any'.
+            Type 'string' is not assignable to type '(childPath: any) => any'.
   Overload 2 of 2, '(...items: (((childPath: any) => any) | ConcatArray<(childPath: any) => any>)[]): ((childPath: any) => any)[]', gave the following error.
     Argument of type '(string | number)[]' is not assignable to parameter of type '((childPath: any) => any) | ConcatArray<(childPath: any) => any>'.
       Type '(string | number)[]' is not assignable to type 'ConcatArray<(childPath: any) => any>'.
@@ -335,8 +332,6 @@ src/main/options-normalizer.js(36,35): error TS2339: Property 'blue' does not ex
 src/main/options-normalizer.js(54,5): error TS2525: Initializer provides no value for this binding element and the binding element has no default value.
 src/main/options-normalizer.js(74,16): error TS2341: Property '_hasDeprecationWarned' is private and only accessible within class 'Normalizer'.
 src/main/options-normalizer.js(80,39): error TS2341: Property '_hasDeprecationWarned' is private and only accessible within class 'Normalizer'.
-src/main/options-normalizer.js(90,44): error TS2345: Argument of type '{ name: string; }' is not assignable to parameter of type 'SchemaHandlers<any>'.
-  Object literal may only specify known properties, and 'name' does not exist in type 'SchemaHandlers<any>'.
 src/main/options-normalizer.js(99,11): error TS2345: Argument of type '{ name: any; sourceName: any; }' is not assignable to parameter of type 'SchemaHandlers<any>'.
   Object literal may only specify known properties, and 'name' does not exist in type 'SchemaHandlers<any>'.
 src/main/options-normalizer.js(143,13): error TS2769: No overload matches this call.
diff --git a/tests/baselines/reference/user/webpack.log b/tests/baselines/reference/user/webpack.log
deleted file mode 100644
index d1fbc9df903..00000000000
--- a/tests/baselines/reference/user/webpack.log
+++ /dev/null
@@ -1,10 +0,0 @@
-Exit Code: 1
-Standard output:
-lib/Compilation.js(575,5): error TS2322: Type 'number | "toString" | "valueOf" | "charAt" | "charCodeAt" | "concat" | "indexOf" | "lastIndexOf" | "localeCompare" | "match" | "replace" | "search" | "slice" | "split" | "substring" | ... 29 more ... | "trimRight"' is not assignable to type 'string'.
-  Type 'number' is not assignable to type 'string'.
-lib/Compiler.js(228,48): error TS2345: Argument of type 'number | "toString" | "valueOf" | "charAt" | "charCodeAt" | "concat" | "indexOf" | "lastIndexOf" | "localeCompare" | "match" | "replace" | "search" | "slice" | "split" | "substring" | ... 29 more ... | "trimRight"' is not assignable to parameter of type 'string'.
-  Type 'number' is not assignable to type 'string'.
-
-
-
-Standard error:
diff --git a/tests/baselines/reference/varianceRepeatedlyPropegatesWithUnreliableFlag.js b/tests/baselines/reference/varianceRepeatedlyPropegatesWithUnreliableFlag.js
new file mode 100644
index 00000000000..73062e82014
--- /dev/null
+++ b/tests/baselines/reference/varianceRepeatedlyPropegatesWithUnreliableFlag.js
@@ -0,0 +1,25 @@
+//// [varianceRepeatedlyPropegatesWithUnreliableFlag.ts]
+type A = { a: number };
+type B = { b: number };
+type X<T> = ({ [K in keyof T]: T[K] } & Record<string, void>)[keyof T];
+type P1<T> = { data: X<T> };
+type P2<T> = { data: X<T> };
+
+interface I<T> {
+    fn<K extends keyof T>(p1: P1<Pick<T, K>>, p2: P2<Pick<T, K>>): void;
+}
+
+const i: I<A & B> = null as any;
+const p2: P2<A> = null as any;
+
+// Commenting out the below line will remove the error on the `const _i: I<A> = i;`
+i.fn(null as any, p2);
+
+const _i: I<A> = i;
+
+//// [varianceRepeatedlyPropegatesWithUnreliableFlag.js]
+var i = null;
+var p2 = null;
+// Commenting out the below line will remove the error on the `const _i: I<A> = i;`
+i.fn(null, p2);
+var _i = i;
diff --git a/tests/baselines/reference/varianceRepeatedlyPropegatesWithUnreliableFlag.symbols b/tests/baselines/reference/varianceRepeatedlyPropegatesWithUnreliableFlag.symbols
new file mode 100644
index 00000000000..b2e1f46f1e8
--- /dev/null
+++ b/tests/baselines/reference/varianceRepeatedlyPropegatesWithUnreliableFlag.symbols
@@ -0,0 +1,77 @@
+=== tests/cases/compiler/varianceRepeatedlyPropegatesWithUnreliableFlag.ts ===
+type A = { a: number };
+>A : Symbol(A, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 0, 0))
+>a : Symbol(a, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 0, 10))
+
+type B = { b: number };
+>B : Symbol(B, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 0, 23))
+>b : Symbol(b, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 1, 10))
+
+type X<T> = ({ [K in keyof T]: T[K] } & Record<string, void>)[keyof T];
+>X : Symbol(X, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 1, 23))
+>T : Symbol(T, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 2, 7))
+>K : Symbol(K, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 2, 16))
+>T : Symbol(T, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 2, 7))
+>T : Symbol(T, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 2, 7))
+>K : Symbol(K, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 2, 16))
+>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --))
+>T : Symbol(T, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 2, 7))
+
+type P1<T> = { data: X<T> };
+>P1 : Symbol(P1, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 2, 71))
+>T : Symbol(T, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 3, 8))
+>data : Symbol(data, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 3, 14))
+>X : Symbol(X, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 1, 23))
+>T : Symbol(T, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 3, 8))
+
+type P2<T> = { data: X<T> };
+>P2 : Symbol(P2, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 3, 28))
+>T : Symbol(T, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 4, 8))
+>data : Symbol(data, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 4, 14))
+>X : Symbol(X, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 1, 23))
+>T : Symbol(T, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 4, 8))
+
+interface I<T> {
+>I : Symbol(I, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 4, 28))
+>T : Symbol(T, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 6, 12))
+
+    fn<K extends keyof T>(p1: P1<Pick<T, K>>, p2: P2<Pick<T, K>>): void;
+>fn : Symbol(I.fn, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 6, 16))
+>K : Symbol(K, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 7, 7))
+>T : Symbol(T, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 6, 12))
+>p1 : Symbol(p1, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 7, 26))
+>P1 : Symbol(P1, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 2, 71))
+>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --))
+>T : Symbol(T, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 6, 12))
+>K : Symbol(K, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 7, 7))
+>p2 : Symbol(p2, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 7, 45))
+>P2 : Symbol(P2, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 3, 28))
+>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --))
+>T : Symbol(T, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 6, 12))
+>K : Symbol(K, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 7, 7))
+}
+
+const i: I<A & B> = null as any;
+>i : Symbol(i, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 10, 5))
+>I : Symbol(I, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 4, 28))
+>A : Symbol(A, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 0, 0))
+>B : Symbol(B, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 0, 23))
+
+const p2: P2<A> = null as any;
+>p2 : Symbol(p2, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 11, 5))
+>P2 : Symbol(P2, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 3, 28))
+>A : Symbol(A, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 0, 0))
+
+// Commenting out the below line will remove the error on the `const _i: I<A> = i;`
+i.fn(null as any, p2);
+>i.fn : Symbol(I.fn, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 6, 16))
+>i : Symbol(i, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 10, 5))
+>fn : Symbol(I.fn, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 6, 16))
+>p2 : Symbol(p2, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 11, 5))
+
+const _i: I<A> = i;
+>_i : Symbol(_i, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 16, 5))
+>I : Symbol(I, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 4, 28))
+>A : Symbol(A, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 0, 0))
+>i : Symbol(i, Decl(varianceRepeatedlyPropegatesWithUnreliableFlag.ts, 10, 5))
+
diff --git a/tests/baselines/reference/varianceRepeatedlyPropegatesWithUnreliableFlag.types b/tests/baselines/reference/varianceRepeatedlyPropegatesWithUnreliableFlag.types
new file mode 100644
index 00000000000..82bf01d05d9
--- /dev/null
+++ b/tests/baselines/reference/varianceRepeatedlyPropegatesWithUnreliableFlag.types
@@ -0,0 +1,51 @@
+=== tests/cases/compiler/varianceRepeatedlyPropegatesWithUnreliableFlag.ts ===
+type A = { a: number };
+>A : A
+>a : number
+
+type B = { b: number };
+>B : B
+>b : number
+
+type X<T> = ({ [K in keyof T]: T[K] } & Record<string, void>)[keyof T];
+>X : ({ [K in keyof T]: T[K]; } & Record<string, void>)[keyof T]
+
+type P1<T> = { data: X<T> };
+>P1 : P1<T>
+>data : ({ [K in keyof T]: T[K]; } & Record<string, void>)[keyof T]
+
+type P2<T> = { data: X<T> };
+>P2 : P2<T>
+>data : ({ [K in keyof T]: T[K]; } & Record<string, void>)[keyof T]
+
+interface I<T> {
+    fn<K extends keyof T>(p1: P1<Pick<T, K>>, p2: P2<Pick<T, K>>): void;
+>fn : <K extends keyof T>(p1: P1<Pick<T, K>>, p2: P2<Pick<T, K>>) => void
+>p1 : P1<Pick<T, K>>
+>p2 : P2<Pick<T, K>>
+}
+
+const i: I<A & B> = null as any;
+>i : I<A & B>
+>null as any : any
+>null : null
+
+const p2: P2<A> = null as any;
+>p2 : P2<A>
+>null as any : any
+>null : null
+
+// Commenting out the below line will remove the error on the `const _i: I<A> = i;`
+i.fn(null as any, p2);
+>i.fn(null as any, p2) : void
+>i.fn : <K extends "a" | "b">(p1: P1<Pick<A & B, K>>, p2: P2<Pick<A & B, K>>) => void
+>i : I<A & B>
+>fn : <K extends "a" | "b">(p1: P1<Pick<A & B, K>>, p2: P2<Pick<A & B, K>>) => void
+>null as any : any
+>null : null
+>p2 : P2<A>
+
+const _i: I<A> = i;
+>_i : I<A>
+>i : I<A & B>
+
diff --git a/tests/cases/compiler/contextualSignatureInstantiation4.ts b/tests/cases/compiler/contextualSignatureInstantiation4.ts
new file mode 100644
index 00000000000..6c29ca3d40a
--- /dev/null
+++ b/tests/cases/compiler/contextualSignatureInstantiation4.ts
@@ -0,0 +1,20 @@
+// @strict: true
+
+// Repros from #32976
+
+declare class Banana<T extends string> { constructor(a: string, property: T) }
+
+declare function fruitFactory1<TFruit>(Fruit: new (...args: any[]) => TFruit): TFruit
+const banana1 = fruitFactory1(Banana) // Banana<any>
+
+declare function fruitFactory2<TFruit>(Fruit: new (a: string, ...args: any[]) => TFruit): TFruit
+const banana2 = fruitFactory2(Banana) // Banana<any>
+
+declare function fruitFactory3<TFruit>(Fruit: new (a: string, s: "foo", ...args: any[]) => TFruit): TFruit
+const banana3 = fruitFactory3(Banana) // Banana<"foo">
+
+declare function fruitFactory4<TFruit>(Fruit: new (a: string, ...args: "foo"[]) => TFruit): TFruit
+const banana4 = fruitFactory4(Banana) // Banana<"foo">
+
+declare function fruitFactory5<TFruit>(Fruit: new (...args: "foo"[]) => TFruit): TFruit
+const banana5 = fruitFactory5(Banana) // Banana<"foo">
diff --git a/tests/cases/compiler/correctOrderOfPromiseMethod.ts b/tests/cases/compiler/correctOrderOfPromiseMethod.ts
index 85f4be9843c..70c730c6b20 100644
--- a/tests/cases/compiler/correctOrderOfPromiseMethod.ts
+++ b/tests/cases/compiler/correctOrderOfPromiseMethod.ts
@@ -17,7 +17,7 @@ async function countEverything(): Promise<number> {
     const [resultA, resultB] = await Promise.all([
         providerA(),
         providerB(),
-    ]);
+    ] as const);
 
     const dataA: A[] = resultA;
     const dataB: B[] = resultB;
@@ -25,4 +25,4 @@ async function countEverything(): Promise<number> {
         return dataA.length + dataB.length;
     }
     return 0;
-}
\ No newline at end of file
+}
diff --git a/tests/cases/compiler/deeplyNestedAssignabilityErrorsCombined.ts b/tests/cases/compiler/deeplyNestedAssignabilityErrorsCombined.ts
new file mode 100644
index 00000000000..d802c707830
--- /dev/null
+++ b/tests/cases/compiler/deeplyNestedAssignabilityErrorsCombined.ts
@@ -0,0 +1,15 @@
+let x = { a: { b: { c: { d: { e: { f() { return { g: "hello" }; } } } } } } };
+let y = { a: { b: { c: { d: { e: { f() { return { g: 12345 }; } } } } } } };
+x = y;
+
+class Ctor1 {
+    g = "ok"
+}
+
+class Ctor2 {
+    g = 12;
+}
+
+let x2 = { a: { b: { c: { d: { e: { f: Ctor1 } } } } } };
+let y2 = { a: { b: { c: { d: { e: { f: Ctor2 } } } } } };
+x2 = y2;
\ No newline at end of file
diff --git a/tests/cases/compiler/exhaustiveSwitchImplicitReturn.ts b/tests/cases/compiler/exhaustiveSwitchImplicitReturn.ts
index b87baffdaf9..7355a5dba30 100644
--- a/tests/cases/compiler/exhaustiveSwitchImplicitReturn.ts
+++ b/tests/cases/compiler/exhaustiveSwitchImplicitReturn.ts
@@ -40,3 +40,17 @@ function foo5(bar: "a" | "b"): number {
             return 1;
     }
 }
+
+function foo6(bar: "a", a: boolean, b: boolean): number {
+    if (a) {
+        switch (bar) {
+            case "a": return 1;
+        }
+    }
+    else {
+        switch (b) {
+            case true: return -1;
+            case false: return 0;
+        }
+    }
+}
diff --git a/tests/cases/compiler/mixinIntersectionIsValidbaseType.ts b/tests/cases/compiler/mixinIntersectionIsValidbaseType.ts
new file mode 100644
index 00000000000..4f446a9db8d
--- /dev/null
+++ b/tests/cases/compiler/mixinIntersectionIsValidbaseType.ts
@@ -0,0 +1,27 @@
+export type Constructor<T extends object = object> = new (...args: any[]) => T;
+
+export interface Initable {
+    init(...args: any[]): void;
+}
+
+/**
+ * Plain mixin where the superclass must be Initable
+ */
+export const Serializable = <K extends Constructor<Initable> & Initable>(
+    SuperClass: K
+) => {
+    const LocalMixin = (InnerSuperClass: K) => {
+        return class SerializableLocal extends InnerSuperClass {
+        }
+    };
+    let ResultClass = LocalMixin(SuperClass);
+    return ResultClass;
+};
+
+const AMixin = <K extends Constructor<Initable> & Initable>(SuperClass: K) => {
+    let SomeHowOkay = class A extends SuperClass {
+    };
+
+    let SomeHowNotOkay = class A extends Serializable(SuperClass) {
+    };
+};
\ No newline at end of file
diff --git a/tests/cases/compiler/nestedCallbackErrorNotFlattened.ts b/tests/cases/compiler/nestedCallbackErrorNotFlattened.ts
new file mode 100644
index 00000000000..76a1fabdf6e
--- /dev/null
+++ b/tests/cases/compiler/nestedCallbackErrorNotFlattened.ts
@@ -0,0 +1,7 @@
+// @strict: true
+type Cb<T> = {noAlias: () => T}["noAlias"]; // `"noAlias"` here prevents an alias symbol from being made
+// which means the comparison will definitely be structural, rather than by variance
+
+declare const x: Cb<Cb<Cb<Cb<number>>>>; // one more layer of `Cb` adn we'd get a `true` from the deeply-nested symbol check
+declare let y: Cb<Cb<Cb<Cb<string>>>>;
+y = x;
\ No newline at end of file
diff --git a/tests/cases/compiler/varianceRepeatedlyPropegatesWithUnreliableFlag.ts b/tests/cases/compiler/varianceRepeatedlyPropegatesWithUnreliableFlag.ts
new file mode 100644
index 00000000000..03cdaee0e9d
--- /dev/null
+++ b/tests/cases/compiler/varianceRepeatedlyPropegatesWithUnreliableFlag.ts
@@ -0,0 +1,17 @@
+type A = { a: number };
+type B = { b: number };
+type X<T> = ({ [K in keyof T]: T[K] } & Record<string, void>)[keyof T];
+type P1<T> = { data: X<T> };
+type P2<T> = { data: X<T> };
+
+interface I<T> {
+    fn<K extends keyof T>(p1: P1<Pick<T, K>>, p2: P2<Pick<T, K>>): void;
+}
+
+const i: I<A & B> = null as any;
+const p2: P2<A> = null as any;
+
+// Commenting out the below line will remove the error on the `const _i: I<A> = i;`
+i.fn(null as any, p2);
+
+const _i: I<A> = i;
\ No newline at end of file
diff --git a/tests/cases/conformance/controlFlow/assertionTypePredicates1.ts b/tests/cases/conformance/controlFlow/assertionTypePredicates1.ts
new file mode 100644
index 00000000000..b20cd42414b
--- /dev/null
+++ b/tests/cases/conformance/controlFlow/assertionTypePredicates1.ts
@@ -0,0 +1,128 @@
+// @strict: true
+// @declaration: true
+
+declare function isString(value: unknown): value is string;
+declare function isArrayOfStrings(value: unknown): value is string[];
+
+const assert: (value: unknown) => asserts value = value => {}
+
+declare function assertIsString(value: unknown): asserts value is string;
+declare function assertIsArrayOfStrings(value: unknown): asserts value is string[];
+declare function assertDefined<T>(value: T): asserts value is NonNullable<T>;
+
+function f01(x: unknown) {
+    if (!!true) {
+        assert(typeof x === "string");
+        x.length;
+    }
+    if (!!true) {
+        assert(x instanceof Error);
+        x.message;
+    }
+    if (!!true) {
+        assert(typeof x === "boolean" || typeof x === "number");
+        x.toLocaleString;
+    }
+    if (!!true) {
+        assert(isArrayOfStrings(x));
+        x[0].length;
+    }
+    if (!!true) {
+        assertIsArrayOfStrings(x);
+        x[0].length;
+    }
+    if (!!true) {
+        assert(x === undefined || typeof x === "string");
+        x;  // string | undefined
+        assertDefined(x);
+        x;  // string
+    }
+}
+
+function f02(x: string | undefined) {
+    if (!!true) {
+        assert(x);
+        x.length;
+    }
+    if (!!true) {
+        assert(x !== undefined);
+        x.length;
+    }
+    if (!!true) {
+        assertDefined(x);
+        x.length;
+    }
+}
+
+function f03(x: string | undefined, assert: (value: unknown) => asserts value) {
+    assert(x);
+    x.length;
+}
+
+namespace Debug {
+    export declare function assert(value: unknown, message?: string): asserts value;
+    export declare function assertDefined<T>(value: T): asserts value is NonNullable<T>;
+}
+
+function f10(x: string | undefined) {
+    if (!!true) {
+        Debug.assert(x);
+        x.length;
+    }
+    if (!!true) {
+        Debug.assert(x !== undefined);
+        x.length;
+    }
+    if (!!true) {
+        Debug.assertDefined(x);
+        x.length;
+    }
+}
+
+class Test {
+    assert(value: unknown): asserts value {
+        if (value) return;
+        throw new Error();
+    }
+    isTest2(): this is Test2 {
+        return this instanceof Test2;
+    }
+    assertIsTest2(): asserts this is Test2 {
+        if (this instanceof Test2) return;
+        throw new Error();
+    }
+    assertThis(): asserts this {
+        if (!this) return;
+        throw new Error();
+    }
+    bar() {
+        this.assertThis();
+        this;
+    }
+    foo(x: unknown) {
+        this.assert(typeof x === "string");
+        x.length;
+        if (this.isTest2()) {
+            this.z;
+        }
+        this.assertIsTest2();
+        this.z;
+    }
+}
+
+class Test2 extends Test {
+    z = 0;
+}
+
+// Invalid constructs
+
+declare let Q1: new (x: unknown) => x is string;
+declare let Q2: new (x: boolean) => asserts x;
+declare let Q3: new (x: unknown) => asserts x is string;
+
+declare class Wat {
+    get p1(): this is string;
+    set p1(x: this is string);
+    get p2(): asserts this is string;
+    set p2(x: asserts this is string);
+}
diff --git a/tests/cases/conformance/controlFlow/exhaustiveSwitchStatements1.ts b/tests/cases/conformance/controlFlow/exhaustiveSwitchStatements1.ts
new file mode 100644
index 00000000000..9fd0f608ddb
--- /dev/null
+++ b/tests/cases/conformance/controlFlow/exhaustiveSwitchStatements1.ts
@@ -0,0 +1,199 @@
+// @strict: true
+// @allowUnreachableCode: false
+// @declaration: true
+
+function f1(x: 1 | 2): string {
+    if (!!true) {
+        switch (x) {
+            case 1: return 'a';
+            case 2: return 'b';
+        }
+        x;  // Unreachable
+    }
+    else {
+        throw 0;
+    }
+}
+
+function f2(x: 1 | 2) {
+    let z: number;
+    switch (x) {
+        case 1: z = 10; break;
+        case 2: z = 20; break;
+    }
+    z;  // Definitely assigned
+}
+
+function f3(x: 1 | 2) {
+    switch (x) {
+        case 1: return 10;
+        case 2: return 20;
+        // Default considered reachable to allow defensive coding
+        default: throw new Error("Bad input");
+    }
+}
+
+// Repro from #11572
+
+enum E { A, B }
+
+function f(e: E): number {
+    switch (e) {
+        case E.A: return 0
+        case E.B: return 1
+    }
+}
+
+function g(e: E): number {
+    if (!true)
+        return -1
+    else
+        switch (e) {
+            case E.A: return 0
+            case E.B: return 1
+        }
+}
+
+// Repro from #12668
+
+interface Square { kind: "square"; size: number; }
+
+interface Rectangle { kind: "rectangle"; width: number; height: number; }
+
+interface Circle { kind: "circle"; radius: number; }
+
+interface Triangle { kind: "triangle"; side: number; }
+
+type Shape = Square | Rectangle | Circle | Triangle;
+
+function area(s: Shape): number {
+    let area;
+    switch (s.kind) {
+        case "square": area = s.size * s.size; break;
+        case "rectangle": area = s.width * s.height; break;
+        case "circle": area = Math.PI * s.radius * s.radius; break;
+        case "triangle": area = Math.sqrt(3) / 4 * s.side * s.side; break;
+    }
+    return area;
+}
+
+function areaWrapped(s: Shape): number {
+    let area;
+    area = (() => {
+        switch (s.kind) {
+            case "square": return s.size * s.size;
+            case "rectangle": return s.width * s.height;
+            case "circle": return Math.PI * s.radius * s.radius;
+            case "triangle": return Math.sqrt(3) / 4 * s.side * s.side;
+        }
+    })();
+    return area;
+}
+
+// Repro from #13241
+
+enum MyEnum {
+	A,
+	B
+}
+
+function thisGivesError(e: MyEnum): string {
+	let s: string;
+	switch (e) {
+		case MyEnum.A: s = "it was A"; break;
+		case MyEnum.B: s = "it was B"; break;
+	}
+	return s;
+}
+
+function good1(e: MyEnum): string {
+	let s: string;
+	switch (e) {
+		case MyEnum.A: s = "it was A"; break;
+		case MyEnum.B: s = "it was B"; break;
+		default: s = "it was something else"; break;
+	}
+	return s;
+}
+
+function good2(e: MyEnum): string {
+	switch (e) {
+		case MyEnum.A: return "it was A";
+		case MyEnum.B: return "it was B";
+	}
+}
+
+// Repro from #18362
+
+enum Level {
+  One,
+  Two,
+}
+
+const doSomethingWithLevel = (level: Level) => {
+  let next: Level;
+  switch (level) {
+    case Level.One:
+      next = Level.Two;
+      break;
+    case Level.Two:
+      next = Level.One;
+      break;
+  }
+  return next;
+};
+
+// Repro from #20409
+
+interface Square2 {
+    kind: "square";
+    size: number;
+}
+
+interface Circle2 {
+    kind: "circle";
+    radius: number;
+}
+
+type Shape2 = Square2 | Circle2;
+
+function withDefault(s1: Shape2, s2: Shape2): string {
+    switch (s1.kind) {
+        case "square":
+            return "1";
+        case "circle":
+            switch (s2.kind) {
+                case "square":
+                    return "2";
+                case "circle":
+                    return "3";
+                default:
+                    return "never";
+            }
+    }
+}
+
+function withoutDefault(s1: Shape2, s2: Shape2): string {
+    switch (s1.kind) {
+        case "square":
+            return "1";
+        case "circle":
+            switch (s2.kind) {
+                case "square":
+                    return "2";
+                case "circle":
+                    return "3";
+            }
+    }
+}
+
+// Repro from #20823
+
+function test4(value: 1 | 2) {
+    let x: string;
+    switch (value) {
+        case 1: x = "one"; break;
+        case 2: x = "two"; break;
+    }
+    return x;
+}
diff --git a/tests/cases/conformance/controlFlow/neverReturningFunctions1.ts b/tests/cases/conformance/controlFlow/neverReturningFunctions1.ts
new file mode 100644
index 00000000000..63e7ecf786f
--- /dev/null
+++ b/tests/cases/conformance/controlFlow/neverReturningFunctions1.ts
@@ -0,0 +1,158 @@
+// @strict: true
+// @allowUnreachableCode: false
+// @declaration: true
+
+function fail(message?: string): never {
+    throw new Error(message);
+}
+
+function f01(x: string | undefined) {
+    if (x === undefined) fail("undefined argument");
+    x.length;  // string
+}
+
+function f02(x: number): number {
+    if (x >= 0) return x;
+    fail("negative number");
+    x;  // Unreachable
+}
+
+function f03(x: string) {
+    x;  // string
+    fail();
+    x;  // Unreachable
+}
+
+function f11(x: string | undefined, fail: (message?: string) => never) {
+    if (x === undefined) fail("undefined argument");
+    x.length;  // string
+}
+
+function f12(x: number, fail: (message?: string) => never): number {
+    if (x >= 0) return x;
+    fail("negative number");
+    x;  // Unreachable
+}
+
+function f13(x: string, fail: (message?: string) => never) {
+    x;  // string
+    fail();
+    x;  // Unreachable
+}
+
+namespace Debug {
+    export declare function fail(message?: string): never;
+}
+
+function f21(x: string | undefined) {
+    if (x === undefined) Debug.fail("undefined argument");
+    x.length;  // string
+}
+
+function f22(x: number): number {
+    if (x >= 0) return x;
+    Debug.fail("negative number");
+    x;  // Unreachable
+}
+
+function f23(x: string) {
+    x;  // string
+    Debug.fail();
+    x;  // Unreachable
+}
+
+function f24(x: string) {
+    x;  // string
+    ((Debug).fail)();
+    x;  // Unreachable
+}
+
+class Test {
+    fail(message?: string): never {
+        throw new Error(message);
+    }
+    f1(x: string | undefined) {
+        if (x === undefined) this.fail("undefined argument");
+        x.length;  // string
+    }
+    f2(x: number): number {
+        if (x >= 0) return x;
+        this.fail("negative number");
+        x;  // Unreachable
+    }
+    f3(x: string) {
+        x;  // string
+        this.fail();
+        x;  // Unreachable
+    }
+}
+
+function f30(x: string | number | undefined) {
+    if (typeof x === "string") {
+        fail();
+        x;  // Unreachable
+    }
+    else {
+        x;  // number | undefined
+        if (x !== undefined) {
+            x;  // number
+            fail();
+            x;  // Unreachable
+        }
+        else {
+            x;  // undefined
+            fail();
+            x;  // Unreachable
+        }
+        x;  // Unreachable
+    }
+    x;  // Unreachable
+}
+
+function f31(x: { a: string | number }) {
+    if (typeof x.a === "string") {
+        fail();
+        x;    // Unreachable
+        x.a;  // Unreachable
+    }
+    x;    // { a: string | number }
+    x.a;  // number
+}
+
+function f40(x: number) {
+    try {
+        x;
+        fail();
+        x;  // Unreachable
+    }
+    finally {
+        x;
+        fail();
+        x;  // Unreachable
+    }
+    x;  // Unreachable
+}
+
+function f41(x: number) {
+    try {
+        x;
+    }
+    finally {
+        x;
+        fail();
+        x;  // Unreachable
+    }
+    x;  // Unreachable
+}
+
+function f42(x: number) {
+    try {
+        x;
+        fail();
+        x;  // Unreachable
+    }
+    finally {
+        x;
+    }
+    x;  // Unreachable
+}
diff --git a/tests/cases/conformance/jsdoc/assertionsAndNonReturningFunctions.ts b/tests/cases/conformance/jsdoc/assertionsAndNonReturningFunctions.ts
new file mode 100644
index 00000000000..9a15a5b5245
--- /dev/null
+++ b/tests/cases/conformance/jsdoc/assertionsAndNonReturningFunctions.ts
@@ -0,0 +1,65 @@
+// @allowJs: true
+// @checkJs: true
+// @noEmit: true
+// @allowUnreachableCode: false
+// @filename: assertionsAndNonReturningFunctions.js
+
+/** @typedef {(check: boolean) => asserts check} AssertFunc */
+
+/** @type {AssertFunc} */
+const assert = check => {
+    if (!check) throw new Error();
+}
+
+/** @type {(x: unknown) => asserts x is string } */
+function assertIsString(x) {
+    if (!(typeof x === "string")) throw new Error();
+}
+
+/**
+ * @param {boolean} check
+ * @returns {asserts check}
+*/
+function assert2(check) {
+    if (!check) throw new Error();
+}
+
+/**
+ * @returns {never}
+ */
+function fail() {
+    throw new Error();
+}
+
+/**
+ * @param {*} x 
+ */
+function f1(x) {
+    if (!!true) {
+        assert(typeof x === "string");
+        x.length;
+    }
+    if (!!true) {
+        assert2(typeof x === "string");
+        x.length;
+    }
+    if (!!true) {
+        assertIsString(x);
+        x.length;
+    }
+    if (!!true) {
+        fail();
+        x;  // Unreachable
+    }
+}
+
+/**
+ * @param {boolean} b 
+ */
+function f2(b) {
+    switch (b) {
+        case true: return 1;
+        case false: return 0;
+    }
+    b;  // Unreachable
+}
diff --git a/tests/cases/conformance/jsdoc/typeParameterExtendsUnionConstraintDistributed.ts b/tests/cases/conformance/jsdoc/typeParameterExtendsUnionConstraintDistributed.ts
new file mode 100644
index 00000000000..2a87bb3ccaa
--- /dev/null
+++ b/tests/cases/conformance/jsdoc/typeParameterExtendsUnionConstraintDistributed.ts
@@ -0,0 +1,5 @@
+type A = 1 | 2;
+function f<T extends A>(a: T): A & T { return a; } // Shouldn't error
+
+type B = 2 | 3;
+function f2<T extends A, U extends B>(ab: T & U): (A | B) & T & U { return ab; } // Also shouldn't error
diff --git a/tests/cases/fourslash/codeFixInferFromCallInAssignment.ts b/tests/cases/fourslash/codeFixInferFromCallInAssignment.ts
new file mode 100644
index 00000000000..85e1d3bc509
--- /dev/null
+++ b/tests/cases/fourslash/codeFixInferFromCallInAssignment.ts
@@ -0,0 +1,9 @@
+/// <reference path='fourslash.ts' />
+
+// @noImplicitAny: true
+//// function inferAny( [| app |] ) {
+////     const result = app.use('hi')
+////     return result
+//// }
+
+verify.rangeAfterCodeFix("app: { use: (arg0: string) => any; }");
diff --git a/tests/cases/fourslash/codeFixInferFromExpressionStatement.ts b/tests/cases/fourslash/codeFixInferFromExpressionStatement.ts
new file mode 100644
index 00000000000..b5969c79378
--- /dev/null
+++ b/tests/cases/fourslash/codeFixInferFromExpressionStatement.ts
@@ -0,0 +1,8 @@
+/// <reference path='fourslash.ts' />
+
+// @noImplicitAny: true
+//// function inferVoid( [| app |] ) {
+////     app.use('hi')
+//// }
+
+verify.rangeAfterCodeFix("app: { use: (arg0: string) => void; }");
diff --git a/tests/cases/fourslash/codeFixInferFromFunctionUsage.ts b/tests/cases/fourslash/codeFixInferFromFunctionUsage.ts
index 27a039878ba..f2dbad67b4b 100644
--- a/tests/cases/fourslash/codeFixInferFromFunctionUsage.ts
+++ b/tests/cases/fourslash/codeFixInferFromFunctionUsage.ts
@@ -2,8 +2,8 @@
 
 // @noImplicitAny: true
 ////function wrap( [| arr |] ) {
-////     arr.sort(function (a: number, b: number) { return a < b ? -1 : 1 })
+////     arr.other(function (a: number, b: number) { return a < b ? -1 : 1 })
 //// }
 
 // https://github.com/Microsoft/TypeScript/issues/29330
-verify.rangeAfterCodeFix("arr: { sort: (arg0: (a: number, b: number) => 1 | -1) => void; }");
+verify.rangeAfterCodeFix("arr: { other: (arg0: (a: number, b: number) => 1 | -1) => void; }");
diff --git a/tests/cases/fourslash/codeFixInferFromPrimitiveUsage.ts b/tests/cases/fourslash/codeFixInferFromPrimitiveUsage.ts
new file mode 100644
index 00000000000..b74e49b4d39
--- /dev/null
+++ b/tests/cases/fourslash/codeFixInferFromPrimitiveUsage.ts
@@ -0,0 +1,10 @@
+/// <reference path='fourslash.ts' />
+
+// @noImplicitAny: true
+//// function wrap( [| s |] ) {
+////     return s.length + s.indexOf('hi')
+//// }
+
+// https://github.com/Microsoft/TypeScript/issues/29330
+verify.rangeAfterCodeFix("s: string | string[]");
+
diff --git a/tests/cases/fourslash/codeFixInferFromUsageAddition.ts b/tests/cases/fourslash/codeFixInferFromUsageAddition.ts
new file mode 100644
index 00000000000..4b57d0603f1
--- /dev/null
+++ b/tests/cases/fourslash/codeFixInferFromUsageAddition.ts
@@ -0,0 +1,9 @@
+/// <reference path='fourslash.ts' />
+
+// @noImplicitAny: true
+//// function foo([|a, m |]) {
+////     return a + m
+//// }
+
+verify.rangeAfterCodeFix("a: any, m: any", /*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, /*index*/0);
+
diff --git a/tests/cases/fourslash/codeFixInferFromUsageArray.ts b/tests/cases/fourslash/codeFixInferFromUsageArray.ts
new file mode 100644
index 00000000000..75f923d5aee
--- /dev/null
+++ b/tests/cases/fourslash/codeFixInferFromUsageArray.ts
@@ -0,0 +1,14 @@
+/// <reference path='fourslash.ts' />
+
+// @noImplicitAny: true
+//// function foo([|p, a, b, c, d, e |]) {
+////     var x: string = a.pop()
+////     b.reverse()
+////     var rr: boolean[] = c.reverse()
+////     d.some(t => t > 1); // can't infer from callbacks right now
+////     var y = e.concat(12); // can't infer from overloaded functions right now
+////     return p.push(12)
+//// }
+
+verify.rangeAfterCodeFix("p: number[], a: string[], b: any[], c: boolean[], d: any[], e: any[]", /*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, /*index*/0);
+
diff --git a/tests/cases/fourslash/codeFixInferFromUsageCallBodyBoth.ts b/tests/cases/fourslash/codeFixInferFromUsageCallBodyBoth.ts
index 859d5ea2ce7..f59d1bc1907 100644
--- a/tests/cases/fourslash/codeFixInferFromUsageCallBodyBoth.ts
+++ b/tests/cases/fourslash/codeFixInferFromUsageCallBodyBoth.ts
@@ -1,7 +1,7 @@
 /// <reference path='fourslash.ts' />
 
 ////class C {
-////
+////    p = 2
 ////}
 ////var c = new C()
 ////function f([|x, y |]) {
diff --git a/tests/cases/fourslash/codeFixInferFromUsageCommentAfterParameter.ts b/tests/cases/fourslash/codeFixInferFromUsageCommentAfterParameter.ts
index bdefd2b5dea..866bfe04c13 100644
--- a/tests/cases/fourslash/codeFixInferFromUsageCommentAfterParameter.ts
+++ b/tests/cases/fourslash/codeFixInferFromUsageCommentAfterParameter.ts
@@ -16,7 +16,7 @@ verify.codeFix({
     index: 0,
     newFileContent:
 `/**
- * @param {(arg0: any) => void} callback
+ * @param {(arg0: any) => any} callback
  */
 function coll(callback /*, name1, name2, ... */) {
     return callback(this);
diff --git a/tests/cases/fourslash/codeFixInferFromUsageJSXElement.ts b/tests/cases/fourslash/codeFixInferFromUsageJSXElement.ts
index 3200fffafb8..abe35fe46c8 100644
--- a/tests/cases/fourslash/codeFixInferFromUsageJSXElement.ts
+++ b/tests/cases/fourslash/codeFixInferFromUsageJSXElement.ts
@@ -30,4 +30,4 @@
 //// }
 
 
-verify.rangeAfterCodeFix("props: { isLoading: any; update: (arg0: any) => void; }",/*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, 0);
+verify.rangeAfterCodeFix("props: { isLoading: any; update: (arg0: any) => any; }",/*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, 0);
diff --git a/tests/cases/fourslash/codeFixInferFromUsageLiteralTypes.ts b/tests/cases/fourslash/codeFixInferFromUsageLiteralTypes.ts
new file mode 100644
index 00000000000..3b8c9441159
--- /dev/null
+++ b/tests/cases/fourslash/codeFixInferFromUsageLiteralTypes.ts
@@ -0,0 +1,10 @@
+/// <reference path='fourslash.ts' />
+
+// @noImplicitAny: true
+//// function foo([|a, m |]) {
+////     a = 'hi'
+////     m = 1
+//// }
+
+verify.rangeAfterCodeFix("a: string, m: number", /*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, /*index*/0);
+
diff --git a/tests/cases/fourslash/codeFixInferFromUsagePromise.ts b/tests/cases/fourslash/codeFixInferFromUsagePromise.ts
new file mode 100644
index 00000000000..d06bb3b6a0f
--- /dev/null
+++ b/tests/cases/fourslash/codeFixInferFromUsagePromise.ts
@@ -0,0 +1,9 @@
+/// <reference path='fourslash.ts' />
+
+// @noImplicitAny: true
+//// function foo([|p |]) {
+////     return p.then((x: string[]) => x[0])
+//// }
+
+verify.rangeAfterCodeFix("p: Promise<string[]>", /*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, /*index*/0);
+
diff --git a/tests/cases/fourslash/codeFixInferFromUsagePropertyAccess.ts b/tests/cases/fourslash/codeFixInferFromUsagePropertyAccess.ts
index c8b85ee11e8..44d2e2d7b1c 100644
--- a/tests/cases/fourslash/codeFixInferFromUsagePropertyAccess.ts
+++ b/tests/cases/fourslash/codeFixInferFromUsagePropertyAccess.ts
@@ -12,4 +12,4 @@
 ////    return x.y.z
 ////}
 
-verify.rangeAfterCodeFix("a: { b: { c: any; }; }, m: { n: () => number; }, x: { y: { z: number[]; }; }", /*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, /*index*/0);
\ No newline at end of file
+verify.rangeAfterCodeFix("a: { b: { c: void; }; }, m: { n: () => number; }, x: { y: { z: number[]; }; }", /*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, /*index*/0);
diff --git a/tests/cases/fourslash/codeFixInferFromUsagePropertyAccessJS.ts b/tests/cases/fourslash/codeFixInferFromUsagePropertyAccessJS.ts
index ed9d4b33b37..357b1a991ba 100644
--- a/tests/cases/fourslash/codeFixInferFromUsagePropertyAccessJS.ts
+++ b/tests/cases/fourslash/codeFixInferFromUsagePropertyAccessJS.ts
@@ -21,7 +21,7 @@ verify.codeFix({
     index: 0,
     newFileContent:
 `/**
- * @param {{ b: { c: any; }; }} a
+ * @param {{ b: { c: void; }; }} a
  * @param {{ n: () => number; }} m
  * @param {{ y: { z: number[]; }; }} x
  */
diff --git a/tests/cases/fourslash/codeFixInferFromUsageString.ts b/tests/cases/fourslash/codeFixInferFromUsageString.ts
new file mode 100644
index 00000000000..d58998cf4a3
--- /dev/null
+++ b/tests/cases/fourslash/codeFixInferFromUsageString.ts
@@ -0,0 +1,12 @@
+/// <reference path='fourslash.ts' />
+
+// @noImplicitAny: true
+//// function foo([|p, a, b |]) {
+////     var x
+////     p.charAt(x)
+////     a.charAt(0)
+////     b.concat('hi')
+//// }
+
+verify.rangeAfterCodeFix("p: string, a: string, b: string | any[]", /*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, /*index*/0);
+