Merge branch 'master' of https://github.com/microsoft/TypeScript into small_ts

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}";

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();

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)
                 );
             }

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",

src/compiler/core.ts

@@ -1654,7 +1654,7 @@ namespace ts {
      */
     export function compose<T>(...args: ((t: T) => T)[]): (t: T) => T;
     export function compose<T>(a: (t: T) => T, b: (t: T) => T, c: (t: T) => T, d: (t: T) => T, e: (t: T) => T): (t: T) => T {
-        if (e) {
+        if (!!e) {
             const args: ((t: T) => T)[] = [];
             for (let i = 0; i < arguments.length; i++) {
                 args[i] = arguments[i];

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
@@ -2693,7 +2722,10 @@
         "category": "Error",
         "code": 2773
     },
-
+    "This condition will always return true since the function is always defined. Did you mean to call it instead?": {
+        "category": "Error",
+        "code": 2774
+    },
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
         "code": 4000
@@ -4007,6 +4039,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",

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) {

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;
     }
 

src/compiler/moduleSpecifiers.ts

@@ -186,6 +186,18 @@ namespace ts.moduleSpecifiers {
         return result;
     }
 
+    function numberOfDirectorySeparators(str: string) {
+        const match = str.match(/\//g);
+        return match ? match.length : 0;
+    }
+
+    function comparePathsByNumberOfDirectrorySeparators(a: string, b: string) {
+        return compareValues(
+            numberOfDirectorySeparators(a),
+            numberOfDirectorySeparators(b)
+        );
+    }
+
     /**
      * Looks for existing imports that use symlinks to this module.
      * Symlinks will be returned first so they are preferred over the real path.
@@ -214,7 +226,32 @@ namespace ts.moduleSpecifiers {
             }
         });
         result.push(...targets);
-        return result;
+        if (result.length < 2) return result;
+
+        // Sort by paths closest to importing file Name directory
+        const allFileNames = arrayToMap(result, identity, getCanonicalFileName);
+        const sortedPaths: string[] = [];
+        for (
+            let directory = getDirectoryPath(toPath(importingFileName, cwd, getCanonicalFileName));
+            allFileNames.size !== 0;
+            directory = getDirectoryPath(directory)
+        ) {
+            const directoryStart = ensureTrailingDirectorySeparator(directory);
+            let pathsInDirectory: string[] | undefined;
+            allFileNames.forEach((canonicalFileName, fileName) => {
+                if (startsWith(canonicalFileName, directoryStart)) {
+                    (pathsInDirectory || (pathsInDirectory = [])).push(fileName);
+                    allFileNames.delete(fileName);
+                }
+            });
+            if (pathsInDirectory) {
+                if (pathsInDirectory.length > 1) {
+                    pathsInDirectory.sort(comparePathsByNumberOfDirectrorySeparators);
+                }
+                sortedPaths.push(...pathsInDirectory);
+            }
+        }
+        return sortedPaths;
     }
 
     function tryGetModuleNameFromAmbientModule(moduleSymbol: Symbol): string | undefined {

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.

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
@@ -1359,18 +1389,16 @@ namespace ts {
             // try to verify results of module resolution
             for (const { oldFile: oldSourceFile, newFile: newSourceFile } of modifiedSourceFiles) {
                 const newSourceFilePath = getNormalizedAbsolutePath(newSourceFile.originalFileName, currentDirectory);
-                if (resolveModuleNamesWorker) {
-                    const moduleNames = getModuleNames(newSourceFile);
-                    const resolutions = resolveModuleNamesReusingOldState(moduleNames, newSourceFilePath, newSourceFile);
-                    // ensure that module resolution results are still correct
-                    const resolutionsChanged = hasChangesInResolutions(moduleNames, resolutions, oldSourceFile.resolvedModules, moduleResolutionIsEqualTo);
-                    if (resolutionsChanged) {
-                        oldProgram.structureIsReused = StructureIsReused.SafeModules;
-                        newSourceFile.resolvedModules = zipToMap(moduleNames, resolutions);
-                    }
-                    else {
-                        newSourceFile.resolvedModules = oldSourceFile.resolvedModules;
-                    }
+                const moduleNames = getModuleNames(newSourceFile);
+                const resolutions = resolveModuleNamesReusingOldState(moduleNames, newSourceFilePath, newSourceFile);
+                // ensure that module resolution results are still correct
+                const resolutionsChanged = hasChangesInResolutions(moduleNames, resolutions, oldSourceFile.resolvedModules, moduleResolutionIsEqualTo);
+                if (resolutionsChanged) {
+                    oldProgram.structureIsReused = StructureIsReused.SafeModules;
+                    newSourceFile.resolvedModules = zipToMap(moduleNames, resolutions);
+                }
+                else {
+                    newSourceFile.resolvedModules = oldSourceFile.resolvedModules;
                 }
                 if (resolveTypeReferenceDirectiveNamesWorker) {
                     // We lower-case all type references because npm automatically lowercases all packages. See GH#9824.
@@ -1403,6 +1431,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 +1717,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 +2269,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 +2327,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 +2496,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 +2933,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,

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,

src/compiler/symbolWalker.ts

@@ -10,7 +10,8 @@ namespace ts {
         getResolvedSymbol: (node: Node) => Symbol,
         getIndexTypeOfStructuredType: (type: Type, kind: IndexKind) => Type | undefined,
         getConstraintOfTypeParameter: (typeParameter: TypeParameter) => Type | undefined,
-        getFirstIdentifier: (node: EntityNameOrEntityNameExpression) => Identifier) {
+        getFirstIdentifier: (node: EntityNameOrEntityNameExpression) => Identifier,
+        getTypeArguments: (type: TypeReference) => readonly Type[]) {
 
         return getSymbolWalker;
 
@@ -89,7 +90,7 @@ namespace ts {
 
             function visitTypeReference(type: TypeReference): void {
                 visitType(type.target);
-                forEach(type.typeArguments, visitType);
+                forEach(getTypeArguments(type), visitType);
             }
 
             function visitTypeParameter(type: TypeParameter): void {

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";
 
@@ -651,6 +678,8 @@ namespace ts {
         base64decode?(input: string): string;
         base64encode?(input: string): string;
         /*@internal*/ bufferFrom?(input: string, encoding?: string): Buffer;
+        // For testing
+        /*@internal*/ now?(): Date;
     }
 
     export interface FileWatcher {
@@ -1365,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();
@@ -1387,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!;
     })();

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:

src/compiler/tsbuild.ts

@@ -316,7 +316,7 @@ namespace ts {
      */
     export function createBuilderStatusReporter(system: System, pretty?: boolean): DiagnosticReporter {
         return diagnostic => {
-            let output = pretty ? `[${formatColorAndReset(new Date().toLocaleTimeString(), ForegroundColorEscapeSequences.Grey)}] ` : `${new Date().toLocaleTimeString()} - `;
+            let output = pretty ? `[${formatColorAndReset(getLocaleTimeString(system), ForegroundColorEscapeSequences.Grey)}] ` : `${getLocaleTimeString(system)} - `;
             output += `${flattenDiagnosticMessageText(diagnostic.messageText, system.newLine)}${system.newLine + system.newLine}`;
             system.write(output);
         };

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;
     }
@@ -3165,6 +3193,7 @@ namespace ts {
         /* @internal */ getParameterType(signature: Signature, parameterIndex: number): Type;
         getNullableType(type: Type, flags: TypeFlags): Type;
         getNonNullableType(type: Type): Type;
+        getTypeArguments(type: TypeReference): readonly Type[];
 
         // TODO: GH#18217 `xToDeclaration` calls are frequently asserted as defined.
         /** Note that the resulting nodes cannot be checked. */
@@ -3289,6 +3318,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 +3557,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 +4013,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 +4028,9 @@ 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
+        outerTypeParameters?: TypeParameter[];  // Outer type parameters of anonymous object type
+        instantiations?: Map<Type>;         // Instantiations of generic type alias (undefined if non-generic)
+        isExhaustive?: boolean;           // Is node an exhaustive switch statement
     }
 
     export const enum TypeFlags {
@@ -4202,7 +4255,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
@@ -4224,11 +4277,22 @@ namespace ts {
      */
     export interface TypeReference extends ObjectType {
         target: GenericType;    // Type reference target
-        typeArguments?: readonly Type[];  // Type reference type arguments (undefined if none)
+        node?: TypeReferenceNode | ArrayTypeNode | TupleTypeNode;
+        /* @internal */
+        mapper?: TypeMapper;
+        /* @internal */
+        resolvedTypeArguments?: readonly Type[];  // Resolved type reference type arguments
         /* @internal */
         literalType?: TypeReference;  // Clone of type with ObjectFlags.ArrayLiteral set
     }
 
+    export interface DeferredTypeReference extends TypeReference {
+        /* @internal */
+        node: TypeReferenceNode | ArrayTypeNode | TupleTypeNode;
+        /* @internal */
+        mapper?: TypeMapper;
+    }
+
     /* @internal */
     export const enum VarianceFlags {
         Invariant     =      0,  // Neither covariant nor contravariant
@@ -4631,6 +4695,8 @@ namespace ts {
         code: number;
         message: string;
         reportsUnnecessary?: {};
+        /* @internal */
+        elidedInCompatabilityPyramid?: boolean;
     }
 
     /**
@@ -4725,6 +4791,7 @@ namespace ts {
         /* @internal */ diagnostics?: boolean;
         /* @internal */ extendedDiagnostics?: boolean;
         disableSizeLimit?: boolean;
+        disableSourceOfProjectReferenceRedirect?: boolean;
         downlevelIteration?: boolean;
         emitBOM?: boolean;
         emitDecoratorMetadata?: boolean;
@@ -5253,11 +5320,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,

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 {

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));
 

src/compiler/watch.ts

@@ -54,6 +54,15 @@ namespace ts {
             : newLine;
     }
 
+    /**
+     * Get locale specific time based on whether we are in test mode
+     */
+    export function getLocaleTimeString(system: System) {
+        return !system.now ?
+            new Date().toLocaleTimeString() :
+            system.now().toLocaleTimeString("en-US", { timeZone: "UTC" });
+    }
+
     /**
      * Create a function that reports watch status by writing to the system and handles the formating of the diagnostic
      */
@@ -61,7 +70,7 @@ namespace ts {
         return pretty ?
             (diagnostic, newLine, options) => {
                 clearScreenIfNotWatchingForFileChanges(system, diagnostic, options);
-                let output = `[${formatColorAndReset(new Date().toLocaleTimeString(), ForegroundColorEscapeSequences.Grey)}] `;
+                let output = `[${formatColorAndReset(getLocaleTimeString(system), ForegroundColorEscapeSequences.Grey)}] `;
                 output += `${flattenDiagnosticMessageText(diagnostic.messageText, system.newLine)}${newLine + newLine}`;
                 system.write(output);
             } :
@@ -72,7 +81,7 @@ namespace ts {
                     output += newLine;
                 }
 
-                output += `${new Date().toLocaleTimeString()} - `;
+                output += `${getLocaleTimeString(system)} - `;
                 output += `${flattenDiagnosticMessageText(diagnostic.messageText, system.newLine)}${getPlainDiagnosticFollowingNewLines(diagnostic, newLine)}`;
 
                 system.write(output);
@@ -122,7 +131,11 @@ namespace ts {
     export function listFiles(program: ProgramToEmitFilesAndReportErrors, writeFileName: (s: string) => void) {
         if (program.getCompilerOptions().listFiles) {
             forEach(program.getSourceFiles(), file => {
-                writeFileName(file.fileName);
+                writeFileName(
+                    !file.redirectInfo ?
+                        file.fileName :
+                        `${file.fileName} -> ${file.redirectInfo.redirectTarget.fileName}`
+                );
             });
         }
     }

src/harness/fakes.ts

@@ -140,7 +140,7 @@ namespace fakes {
         }
 
         public createHash(data: string): string {
-            return data;
+            return `${ts.generateDjb2Hash(data)}-${data}`;
         }
 
         public realpath(path: string) {
@@ -164,6 +164,10 @@ namespace fakes {
                 return undefined;
             }
         }
+
+        now() {
+            return new Date(this.vfs.time());
+        }
     }
 
     /**
@@ -520,39 +524,51 @@ ${indentText}${text}`;
 
     export const version = "FakeTSVersion";
 
-    export class SolutionBuilderHost extends CompilerHost implements ts.SolutionBuilderHost<ts.BuilderProgram> {
-        createProgram: ts.CreateProgram<ts.BuilderProgram>;
-
-        constructor(sys: System | vfs.FileSystem, options?: ts.CompilerOptions, setParentNodes?: boolean, createProgram?: ts.CreateProgram<ts.BuilderProgram>) {
-            super(sys, options, setParentNodes);
-            this.createProgram = createProgram || ts.createEmitAndSemanticDiagnosticsBuilderProgram;
-        }
-
-        readFile(path: string) {
-            const value = super.readFile(path);
+    export function patchSolutionBuilderHost(host: ts.SolutionBuilderHost<ts.BuilderProgram>, sys: System) {
+        const originalReadFile = host.readFile;
+        host.readFile = (path, encoding) => {
+            const value = originalReadFile.call(host, path, encoding);
             if (!value || !ts.isBuildInfoFile(path)) return value;
             const buildInfo = ts.getBuildInfo(value);
             ts.Debug.assert(buildInfo.version === version);
             buildInfo.version = ts.version;
             return ts.getBuildInfoText(buildInfo);
+        };
+
+        if (host.writeFile) {
+            const originalWriteFile = host.writeFile;
+            host.writeFile = (fileName, content, writeByteOrderMark) => {
+                if (!ts.isBuildInfoFile(fileName)) return originalWriteFile.call(host, fileName, content, writeByteOrderMark);
+                const buildInfo = ts.getBuildInfo(content);
+                sanitizeBuildInfoProgram(buildInfo);
+                buildInfo.version = version;
+                originalWriteFile.call(host, fileName, ts.getBuildInfoText(buildInfo), writeByteOrderMark);
+            };
         }
 
-        public writeFile(fileName: string, content: string, writeByteOrderMark: boolean) {
-            if (!ts.isBuildInfoFile(fileName)) return super.writeFile(fileName, content, writeByteOrderMark);
-            const buildInfo = ts.getBuildInfo(content);
-            sanitizeBuildInfoProgram(buildInfo);
-            buildInfo.version = version;
-            super.writeFile(fileName, ts.getBuildInfoText(buildInfo), writeByteOrderMark);
+        ts.Debug.assert(host.now === undefined);
+        host.now = () => new Date(sys.vfs.time());
+        ts.Debug.assertDefined(host.createHash);
+    }
+
+    export class SolutionBuilderHost extends CompilerHost implements ts.SolutionBuilderHost<ts.BuilderProgram> {
+        createProgram: ts.CreateProgram<ts.BuilderProgram>;
+
+        private constructor(sys: System | vfs.FileSystem, options?: ts.CompilerOptions, setParentNodes?: boolean, createProgram?: ts.CreateProgram<ts.BuilderProgram>) {
+            super(sys, options, setParentNodes);
+            this.createProgram = createProgram || ts.createEmitAndSemanticDiagnosticsBuilderProgram;
+        }
+
+        static create(sys: System | vfs.FileSystem, options?: ts.CompilerOptions, setParentNodes?: boolean, createProgram?: ts.CreateProgram<ts.BuilderProgram>) {
+            const host = new SolutionBuilderHost(sys, options, setParentNodes, createProgram);
+            patchSolutionBuilderHost(host, host.sys);
+            return host;
         }
 
         createHash(data: string) {
             return `${ts.generateDjb2Hash(data)}-${data}`;
         }
 
-        now() {
-            return new Date(this.sys.vfs.time());
-        }
-
         diagnostics: SolutionBuilderDiagnostic[] = [];
 
         reportDiagnostic(diagnostic: ts.Diagnostic) {

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}`;

src/lib/es5.d.ts

@@ -1235,7 +1235,12 @@ interface Array<T> {
     slice(start?: number, end?: number): T[];
     /**
      * Sorts an array.
-     * @param compareFn The name of the function used to determine the order of the elements. If omitted, the elements are sorted in ascending, ASCII character order.
+     * @param compareFn Function used to determine the order of the elements. It is expected to return
+     * a negative value if first argument is less than second argument, zero if they're equal and a positive
+     * value otherwise. If omitted, the elements are sorted in ascending, ASCII character order.
+     * ```ts
+     * [11,2,22,1].sort((a, b) => a - b)
+     * ```
      */
     sort(compareFn?: (a: T, b: T) => number): this;
     /**
@@ -1876,8 +1881,12 @@ interface Int8Array {
 
     /**
      * Sorts an array.
-     * @param compareFn The name of the function used to determine the order of the elements. If
-     * omitted, the elements are sorted in ascending, ASCII character order.
+     * @param compareFn Function used to determine the order of the elements. It is expected to return
+     * a negative value if first argument is less than second argument, zero if they're equal and a positive
+     * value otherwise. If omitted, the elements are sorted in ascending, ASCII character order.
+     * ```ts
+     * [11,2,22,1].sort((a, b) => a - b)
+     * ```
      */
     sort(compareFn?: (a: number, b: number) => number): this;
 
@@ -2151,8 +2160,12 @@ interface Uint8Array {
 
     /**
      * Sorts an array.
-     * @param compareFn The name of the function used to determine the order of the elements. If
-     * omitted, the elements are sorted in ascending, ASCII character order.
+     * @param compareFn Function used to determine the order of the elements. It is expected to return
+     * a negative value if first argument is less than second argument, zero if they're equal and a positive
+     * value otherwise. If omitted, the elements are sorted in ascending, ASCII character order.
+     * ```ts
+     * [11,2,22,1].sort((a, b) => a - b)
+     * ```
      */
     sort(compareFn?: (a: number, b: number) => number): this;
 
@@ -2426,8 +2439,12 @@ interface Uint8ClampedArray {
 
     /**
      * Sorts an array.
-     * @param compareFn The name of the function used to determine the order of the elements. If
-     * omitted, the elements are sorted in ascending, ASCII character order.
+     * @param compareFn Function used to determine the order of the elements. It is expected to return
+     * a negative value if first argument is less than second argument, zero if they're equal and a positive
+     * value otherwise. If omitted, the elements are sorted in ascending, ASCII character order.
+     * ```ts
+     * [11,2,22,1].sort((a, b) => a - b)
+     * ```
      */
     sort(compareFn?: (a: number, b: number) => number): this;
 
@@ -2699,8 +2716,12 @@ interface Int16Array {
 
     /**
      * Sorts an array.
-     * @param compareFn The name of the function used to determine the order of the elements. If
-     * omitted, the elements are sorted in ascending, ASCII character order.
+     * @param compareFn Function used to determine the order of the elements. It is expected to return
+     * a negative value if first argument is less than second argument, zero if they're equal and a positive
+     * value otherwise. If omitted, the elements are sorted in ascending, ASCII character order.
+     * ```ts
+     * [11,2,22,1].sort((a, b) => a - b)
+     * ```
      */
     sort(compareFn?: (a: number, b: number) => number): this;
 
@@ -2975,8 +2996,12 @@ interface Uint16Array {
 
     /**
      * Sorts an array.
-     * @param compareFn The name of the function used to determine the order of the elements. If
-     * omitted, the elements are sorted in ascending, ASCII character order.
+     * @param compareFn Function used to determine the order of the elements. It is expected to return
+     * a negative value if first argument is less than second argument, zero if they're equal and a positive
+     * value otherwise. If omitted, the elements are sorted in ascending, ASCII character order.
+     * ```ts
+     * [11,2,22,1].sort((a, b) => a - b)
+     * ```
      */
     sort(compareFn?: (a: number, b: number) => number): this;
 
@@ -3250,8 +3275,12 @@ interface Int32Array {
 
     /**
      * Sorts an array.
-     * @param compareFn The name of the function used to determine the order of the elements. If
-     * omitted, the elements are sorted in ascending, ASCII character order.
+     * @param compareFn Function used to determine the order of the elements. It is expected to return
+     * a negative value if first argument is less than second argument, zero if they're equal and a positive
+     * value otherwise. If omitted, the elements are sorted in ascending, ASCII character order.
+     * ```ts
+     * [11,2,22,1].sort((a, b) => a - b)
+     * ```
      */
     sort(compareFn?: (a: number, b: number) => number): this;
 
@@ -3524,8 +3553,12 @@ interface Uint32Array {
 
     /**
      * Sorts an array.
-     * @param compareFn The name of the function used to determine the order of the elements. If
-     * omitted, the elements are sorted in ascending, ASCII character order.
+     * @param compareFn Function used to determine the order of the elements. It is expected to return
+     * a negative value if first argument is less than second argument, zero if they're equal and a positive
+     * value otherwise. If omitted, the elements are sorted in ascending, ASCII character order.
+     * ```ts
+     * [11,2,22,1].sort((a, b) => a - b)
+     * ```
      */
     sort(compareFn?: (a: number, b: number) => number): this;
 
@@ -3799,8 +3832,12 @@ interface Float32Array {
 
     /**
      * Sorts an array.
-     * @param compareFn The name of the function used to determine the order of the elements. If
-     * omitted, the elements are sorted in ascending, ASCII character order.
+     * @param compareFn Function used to determine the order of the elements. It is expected to return
+     * a negative value if first argument is less than second argument, zero if they're equal and a positive
+     * value otherwise. If omitted, the elements are sorted in ascending, ASCII character order.
+     * ```ts
+     * [11,2,22,1].sort((a, b) => a - b)
+     * ```
      */
     sort(compareFn?: (a: number, b: number) => number): this;
 
@@ -4075,8 +4112,12 @@ interface Float64Array {
 
     /**
      * Sorts an array.
-     * @param compareFn The name of the function used to determine the order of the elements. If
-     * omitted, the elements are sorted in ascending, ASCII character order.
+     * @param compareFn Function used to determine the order of the elements. It is expected to return
+     * a negative value if first argument is less than second argument, zero if they're equal and a positive
+     * value otherwise. If omitted, the elements are sorted in ascending, ASCII character order.
+     * ```ts
+     * [11,2,22,1].sort((a, b) => a - b)
+     * ```
      */
     sort(compareFn?: (a: number, b: number) => number): this;
 

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);

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();
         }
 

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];
             }
         }
 

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 };
             });
         }

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 = checker.getTypeArguments(genericType as TypeReference);
+                const usageArgs = checker.getTypeArguments(usageType as TypeReference);
+                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;
-        }
     }
 }

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 = {

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;
 

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 */

src/testRunner/tsconfig.json

@@ -38,6 +38,7 @@
 
         "unittests/services/extract/helpers.ts",
         "unittests/tsbuild/helpers.ts",
+        "unittests/tsc/helpers.ts",
         "unittests/tscWatch/helpers.ts",
         "unittests/tsserver/helpers.ts",
 
@@ -108,6 +109,7 @@
         "unittests/tsbuild/transitiveReferences.ts",
         "unittests/tsbuild/watchEnvironment.ts",
         "unittests/tsbuild/watchMode.ts",
+        "unittests/tsc/declarationEmit.ts",
         "unittests/tscWatch/consoleClearing.ts",
         "unittests/tscWatch/emit.ts",
         "unittests/tscWatch/emitAndErrorUpdates.ts",
@@ -145,6 +147,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",

src/testRunner/unittests/tsbuild/amdModulesWithOut.ts

@@ -1,7 +1,6 @@
 namespace ts {
     describe("unittests:: tsbuild:: outFile:: on amd modules with --out", () => {
         let outFileFs: vfs.FileSystem;
-        const { time, tick } = getTime();
         const enum project { lib, app }
         function relName(path: string) { return path.slice(1); }
         type Sources = [string, readonly string[]];
@@ -25,54 +24,52 @@ namespace ts {
             ]
         ];
         before(() => {
-            outFileFs = loadProjectFromDisk("tests/projects/amdModulesWithOut", time);
+            outFileFs = loadProjectFromDisk("tests/projects/amdModulesWithOut");
         });
         after(() => {
             outFileFs = undefined!;
         });
 
         interface VerifyOutFileScenarioInput {
-            scenario: string;
-            modifyFs: (fs: vfs.FileSystem) => void;
+            subScenario: string;
+            modifyFs?: (fs: vfs.FileSystem) => void;
             modifyAgainFs?: (fs: vfs.FileSystem) => void;
         }
 
         function verifyOutFileScenario({
-            scenario,
+            subScenario,
             modifyFs,
             modifyAgainFs
         }: VerifyOutFileScenarioInput) {
-            verifyTsbuildOutput({
-                scenario,
-                projFs: () => outFileFs,
-                time,
-                tick,
-                proj: "amdModulesWithOut",
-                rootNames: ["/src/app"],
+            verifyTscIncrementalEdits({
+                scenario: "amdModulesWithOut",
+                subScenario,
+                fs: () => outFileFs,
+                commandLineArgs: ["--b", "/src/app", "--verbose"],
                 baselineSourceMap: true,
-                initialBuild: {
-                    modifyFs
-                },
-                incrementalDtsUnchangedBuild: {
-                    modifyFs: fs => appendText(fs, relName(sources[project.lib][source.ts][1]), "console.log(x);")
-                },
-                incrementalHeaderChangedBuild: modifyAgainFs ? {
-                    modifyFs: modifyAgainFs
-                } : undefined,
-                baselineOnly: true
+                modifyFs,
+                incrementalScenarios: [
+                    {
+                        buildKind: BuildKind.IncrementalDtsUnchanged,
+                        modifyFs: fs => appendText(fs, relName(sources[project.lib][source.ts][1]), "console.log(x);")
+                    },
+                    ...(modifyAgainFs ? [{
+                        buildKind: BuildKind.IncrementalHeadersChange,
+                        modifyFs: modifyAgainFs
+                    }] : emptyArray),
+                ]
             });
         }
 
         describe("Prepend output with .tsbuildinfo", () => {
             verifyOutFileScenario({
-                scenario: "modules and globals mixed in amd",
-                modifyFs: noop
+                subScenario: "modules and globals mixed in amd",
             });
 
             // Prologues
             describe("Prologues", () => {
                 verifyOutFileScenario({
-                    scenario: "multiple prologues in all projects",
+                    subScenario: "multiple prologues in all projects",
                     modifyFs: fs => {
                         enableStrict(fs, sources[project.lib][source.config]);
                         addTestPrologue(fs, sources[project.lib][source.ts][0], `"myPrologue"`);
@@ -90,7 +87,7 @@ namespace ts {
             describe("Shebang", () => {
                 // changes declaration because its emitted in .d.ts file
                 verifyOutFileScenario({
-                    scenario: "shebang in all projects",
+                    subScenario: "shebang in all projects",
                     modifyFs: fs => {
                         addShebang(fs, "lib", "file0");
                         addShebang(fs, "lib", "file1");
@@ -102,7 +99,7 @@ namespace ts {
             // emitHelpers
             describe("emitHelpers", () => {
                 verifyOutFileScenario({
-                    scenario: "multiple emitHelpers in all projects",
+                    subScenario: "multiple emitHelpers in all projects",
                     modifyFs: fs => {
                         addSpread(fs, "lib", "file0");
                         addRest(fs, "lib", "file1");
@@ -117,7 +114,7 @@ namespace ts {
             describe("triple slash refs", () => {
                 // changes declaration because its emitted in .d.ts file
                 verifyOutFileScenario({
-                    scenario: "triple slash refs in all projects",
+                    subScenario: "triple slash refs in all projects",
                     modifyFs: fs => {
                         addTripleSlashRef(fs, "lib", "file0");
                         addTripleSlashRef(fs, "app", "file4");
@@ -161,7 +158,7 @@ ${internal} export enum internalEnum { a, b, c }`);
 
                 // Verify initial + incremental edits
                 verifyOutFileScenario({
-                    scenario: "stripInternal",
+                    subScenario: "stripInternal",
                     modifyFs: stripInternalScenario,
                     modifyAgainFs: fs => replaceText(fs, sources[project.lib][source.ts][1], `export const`, `/*@internal*/ export const`),
                 });
@@ -175,26 +172,13 @@ ${internal} export enum internalEnum { a, b, c }`);
                     replaceText(fs, sources[project.app][source.ts][0], "file1", "lib/file1");
                 }
 
-                verifyTsbuildOutput({
-                    scenario: "when the module resolution finds original source file",
-                    projFs: () => outFileFs,
-                    time,
-                    tick,
-                    proj: "amdModulesWithOut",
-                    rootNames: ["/src/app"],
+                verifyTsc({
+                    scenario: "amdModulesWithOut",
+                    subScenario: "when the module resolution finds original source file",
+                    fs: () => outFileFs,
+                    commandLineArgs: ["-b", "/src/app", "--verbose"],
+                    modifyFs,
                     baselineSourceMap: true,
-                    initialBuild: {
-                        modifyFs,
-                        expectedDiagnostics: [
-                            getExpectedDiagnosticForProjectsInBuild("src/lib/tsconfig.json", "src/app/tsconfig.json"),
-                            [Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist, "src/lib/tsconfig.json", "src/module.js"],
-                            [Diagnostics.Building_project_0, sources[project.lib][source.config]],
-                            [Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist, "src/app/tsconfig.json", "src/app/module.js"],
-                            [Diagnostics.Building_project_0, sources[project.app][source.config]],
-                        ]
-                    },
-                    baselineOnly: true,
-                    verifyDiagnostics: true
                 });
             });
         });

src/testRunner/unittests/tsbuild/containerOnlyReferenced.ts

@@ -19,7 +19,7 @@ namespace ts {
 
         it("verify that subsequent builds after initial build doesnt build anything", () => {
             const fs = projFs.shadow();
-            const host = new fakes.SolutionBuilderHost(fs);
+            const host = fakes.SolutionBuilderHost.create(fs);
             createSolutionBuilder(host, ["/src"], { verbose: true }).build();
             host.assertDiagnosticMessages(
                 getExpectedDiagnosticForProjectsInBuild("src/src/folder/tsconfig.json", "src/src/folder2/tsconfig.json", "src/src/tsconfig.json", "src/tests/tsconfig.json", "src/tsconfig.json"),

src/testRunner/unittests/tsbuild/demo.ts

@@ -1,10 +1,8 @@
 namespace ts {
     describe("unittests:: tsbuild:: on demo project", () => {
         let projFs: vfs.FileSystem;
-        const { time } = getTime();
-
         before(() => {
-            projFs = loadProjectFromDisk("tests/projects/demo", time);
+            projFs = loadProjectFromDisk("tests/projects/demo");
         });
 
         after(() => {
@@ -49,7 +47,7 @@ namespace ts {
 
         function verifyBuild({ modifyDiskLayout, expectedExitStatus, expectedDiagnostics, expectedOutputs, notExpectedOutputs }: VerifyBuild) {
             const fs = projFs.shadow();
-            const host = new fakes.SolutionBuilderHost(fs);
+            const host = fakes.SolutionBuilderHost.create(fs);
             modifyDiskLayout(fs);
             const builder = createSolutionBuilder(host, ["/src/tsconfig.json"], { verbose: true });
             const exitStatus = builder.build();

src/testRunner/unittests/tsbuild/emitDeclarationOnly.ts

@@ -1,85 +1,53 @@
 namespace ts {
     describe("unittests:: tsbuild:: on project with emitDeclarationOnly set to true", () => {
         let projFs: vfs.FileSystem;
-        const { time, tick } = getTime();
         before(() => {
-            projFs = loadProjectFromDisk("tests/projects/emitDeclarationOnly", time);
+            projFs = loadProjectFromDisk("tests/projects/emitDeclarationOnly");
         });
         after(() => {
             projFs = undefined!;
         });
 
         function verifyEmitDeclarationOnly(disableMap?: true) {
-            verifyTsbuildOutput({
-                scenario: `only dts output in circular import project with emitDeclarationOnly${disableMap ? "" : " and declarationMap"}`,
-                projFs: () => projFs,
-                time,
-                tick,
-                proj: "emitDeclarationOnly",
-                rootNames: ["/src"],
-                initialBuild: {
-                    modifyFs: disableMap ?
-                        (fs => replaceText(fs, "/src/tsconfig.json", `"declarationMap": true,`, "")) :
-                        noop,
-                    expectedDiagnostics: [
-                        getExpectedDiagnosticForProjectsInBuild("src/tsconfig.json"),
-                        [Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist, "src/tsconfig.json", "src/lib/a.d.ts"],
-                        [Diagnostics.Building_project_0, "/src/tsconfig.json"]
-                    ]
-                },
-                incrementalDtsChangedBuild: {
+            verifyTscIncrementalEdits({
+                subScenario: `only dts output in circular import project with emitDeclarationOnly${disableMap ? "" : " and declarationMap"}`,
+                fs: () => projFs,
+                scenario: "emitDeclarationOnly",
+                commandLineArgs: ["--b", "/src", "--verbose"],
+                modifyFs: disableMap ?
+                    (fs => replaceText(fs, "/src/tsconfig.json", `"declarationMap": true,`, "")) :
+                    undefined,
+                incrementalScenarios: [{
+                    buildKind: BuildKind.IncrementalDtsChange,
                     modifyFs: fs => replaceText(fs, "/src/src/a.ts", "b: B;", "b: B; foo: any;"),
-                    expectedDiagnostics: [
-                        getExpectedDiagnosticForProjectsInBuild("src/tsconfig.json"),
-                        [Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, "src/tsconfig.json", "src/lib/a.d.ts", "src/src/a.ts"],
-                        [Diagnostics.Building_project_0, "/src/tsconfig.json"]
-                    ]
-                },
-                baselineOnly: true,
-                verifyDiagnostics: true
+                }],
             });
         }
         verifyEmitDeclarationOnly();
         verifyEmitDeclarationOnly(/*disableMap*/ true);
 
-        verifyTsbuildOutput({
-            scenario: `only dts output in non circular imports project with emitDeclarationOnly`,
-            projFs: () => projFs,
-            time,
-            tick,
-            proj: "emitDeclarationOnly",
-            rootNames: ["/src"],
-            initialBuild: {
-                modifyFs: fs => {
-                    fs.rimrafSync("/src/src/index.ts");
-                    replaceText(fs, "/src/src/a.ts", `import { B } from "./b";`, `export class B { prop = "hello"; }`);
+        verifyTscIncrementalEdits({
+            subScenario: `only dts output in non circular imports project with emitDeclarationOnly`,
+            fs: () => projFs,
+            scenario: "emitDeclarationOnly",
+            commandLineArgs: ["--b", "/src", "--verbose"],
+            modifyFs: fs => {
+                fs.rimrafSync("/src/src/index.ts");
+                replaceText(fs, "/src/src/a.ts", `import { B } from "./b";`, `export class B { prop = "hello"; }`);
+            },
+            incrementalScenarios: [
+                {
+                    buildKind: BuildKind.IncrementalDtsChange,
+                    modifyFs: fs => replaceText(fs, "/src/src/a.ts", "b: B;", "b: B; foo: any;"),
+
                 },
-                expectedDiagnostics: [
-                    getExpectedDiagnosticForProjectsInBuild("src/tsconfig.json"),
-                    [Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist, "src/tsconfig.json", "src/lib/a.d.ts"],
-                    [Diagnostics.Building_project_0, "/src/tsconfig.json"]
-                ]
-            },
-            incrementalDtsChangedBuild: {
-                modifyFs: fs => replaceText(fs, "/src/src/a.ts", "b: B;", "b: B; foo: any;"),
-                expectedDiagnostics: [
-                    getExpectedDiagnosticForProjectsInBuild("src/tsconfig.json"),
-                    [Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, "src/tsconfig.json", "src/lib/a.d.ts", "src/src/a.ts"],
-                    [Diagnostics.Building_project_0, "/src/tsconfig.json"]
-                ]
-            },
-            incrementalDtsUnchangedBuild: {
-                modifyFs: fs => replaceText(fs, "/src/src/a.ts", "export interface A {", `class C { }
+                {
+                    buildKind: BuildKind.IncrementalDtsUnchanged,
+                    modifyFs: fs => replaceText(fs, "/src/src/a.ts", "export interface A {", `class C { }
 export interface A {`),
-                expectedDiagnostics: [
-                    getExpectedDiagnosticForProjectsInBuild("src/tsconfig.json"),
-                    [Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, "src/tsconfig.json", "src/lib/a.d.ts", "src/src/a.ts"],
-                    [Diagnostics.Building_project_0, "/src/tsconfig.json"],
-                    [Diagnostics.Updating_unchanged_output_timestamps_of_project_0, "/src/tsconfig.json"]
-                ]
-            },
-            baselineOnly: true,
-            verifyDiagnostics: true
+
+                },
+            ],
         });
     });
 }

src/testRunner/unittests/tsbuild/emptyFiles.ts

@@ -10,7 +10,7 @@ namespace ts {
     describe("unittests:: tsbuild - empty files option in tsconfig", () => {
         it("has empty files diagnostic when files is empty and no references are provided", () => {
             const fs = projFs.shadow();
-            const host = new fakes.SolutionBuilderHost(fs);
+            const host = fakes.SolutionBuilderHost.create(fs);
             const builder = createSolutionBuilder(host, ["/src/no-references"], { dry: false, force: false, verbose: false });
 
             host.clearDiagnostics();
@@ -26,7 +26,7 @@ namespace ts {
 
         it("does not have empty files diagnostic when files is empty and references are provided", () => {
             const fs = projFs.shadow();
-            const host = new fakes.SolutionBuilderHost(fs);
+            const host = fakes.SolutionBuilderHost.create(fs);
             const builder = createSolutionBuilder(host, ["/src/with-references"], { dry: false, force: false, verbose: false });
 
             host.clearDiagnostics();

src/testRunner/unittests/tsbuild/graphOrdering.ts

@@ -17,7 +17,7 @@ namespace ts {
 
         before(() => {
             const fs = new vfs.FileSystem(false);
-            host = new fakes.SolutionBuilderHost(fs);
+            host = fakes.SolutionBuilderHost.create(fs);
             writeProjects(fs, ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"], deps);
         });
 

src/testRunner/unittests/tsbuild/helpers.ts

@@ -113,9 +113,11 @@ interface Symbol {
 }
 `;
 
+    /**
+     * Load project from disk into /src folder
+     */
     export function loadProjectFromDisk(
         root: string,
-        time?: vfs.FileSystemOptions["time"],
         libContentToAppend?: string
     ): vfs.FileSystem {
         const resolver = vfs.createResolver(Harness.IO);
@@ -125,22 +127,22 @@ interface Symbol {
             },
             cwd: "/",
             meta: { defaultLibLocation: "/lib" },
-            time
         });
         addLibAndMakeReadonly(fs, libContentToAppend);
         return fs;
     }
 
+    /**
+     * All the files must be in /src
+     */
     export function loadProjectFromFiles(
         files: vfs.FileSet,
-        time?: vfs.FileSystemOptions["time"],
         libContentToAppend?: string
     ): vfs.FileSystem {
         const fs = new vfs.FileSystem(/*ignoreCase*/ true, {
             files,
             cwd: "/",
             meta: { defaultLibLocation: "/lib" },
-            time
         });
         addLibAndMakeReadonly(fs, libContentToAppend);
         return fs;
@@ -152,6 +154,26 @@ interface Symbol {
         fs.makeReadonly();
     }
 
+    /**
+     * Gets the FS mountuing existing fs's /src and /lib folder
+     */
+    export function getFsWithTime(baseFs: vfs.FileSystem) {
+        const { time, tick } = getTime();
+        const host = new fakes.System(baseFs) as any as vfs.FileSystemResolverHost;
+        host.getWorkspaceRoot = notImplemented;
+        const resolver = vfs.createResolver(host);
+        const fs = new vfs.FileSystem(/*ignoreCase*/ true, {
+            files: {
+                ["/src"]: new vfs.Mount("/src", resolver),
+                ["/lib"]: new vfs.Mount("/lib", resolver)
+            },
+            cwd: "/",
+            meta: { defaultLibLocation: "/lib" },
+            time
+        });
+        return { fs, time, tick };
+    }
+
     export function verifyOutputsPresent(fs: vfs.FileSystem, outputs: readonly string[]) {
         for (const output of outputs) {
             assert(fs.existsSync(output), `Expect file ${output} to exist`);
@@ -164,7 +186,7 @@ interface Symbol {
         }
     }
 
-    function generateSourceMapBaselineFiles(fs: vfs.FileSystem, mapFileNames: Iterator<string>) {
+    export function generateSourceMapBaselineFiles(fs: vfs.FileSystem, mapFileNames: Iterator<string>) {
         while (true) {
             const { value: mapFile, done } = mapFileNames.next();
             if (done) break;
@@ -230,251 +252,117 @@ interface Symbol {
         }
     }
 
-    export interface BuildInput {
-        fs: vfs.FileSystem;
-        tick: () => void;
-        rootNames: readonly string[];
-        modifyFs: (fs: vfs.FileSystem) => void;
-        baselineSourceMap?: true;
-        baselineBuildInfo?: true;
-    }
-
-    export function tscBuild({ fs, tick, rootNames, modifyFs, baselineSourceMap, baselineBuildInfo }: BuildInput) {
-        const actualReadFileMap = createMap<number>();
-        modifyFs(fs);
-        tick();
-
-        const host = new fakes.SolutionBuilderHost(fs);
-        const writtenFiles = createMap<true>();
-        const originalWriteFile = host.writeFile;
-        host.writeFile = (fileName, content, writeByteOrderMark) => {
-            assert.isFalse(writtenFiles.has(fileName));
-            writtenFiles.set(fileName, true);
-            return originalWriteFile.call(host, fileName, content, writeByteOrderMark);
-        };
-        const builder = createSolutionBuilder(host, rootNames, { dry: false, force: false, verbose: true });
-        host.clearDiagnostics();
-        const originalReadFile = host.readFile;
-        host.readFile = path => {
-            // Dont record libs
-            if (path.startsWith("/src/")) {
-                actualReadFileMap.set(path, (actualReadFileMap.get(path) || 0) + 1);
-            }
-            return originalReadFile.call(host, path);
-        };
-        builder.build();
-        if (baselineSourceMap) generateSourceMapBaselineFiles(fs, mapDefinedIterator(writtenFiles.keys(), f => f.endsWith(".map") ? f : undefined));
-        if (baselineBuildInfo) {
-            let expectedBuildInfoFiles: BuildInfoSectionBaselineFiles[] | undefined;
-            for (const { options } of builder.getAllParsedConfigs()) {
-                const out = options.outFile || options.out;
-                if (out) {
-                    const { jsFilePath, declarationFilePath, buildInfoPath } = getOutputPathsForBundle(options, /*forceDts*/ false);
-                    if (buildInfoPath && writtenFiles.has(buildInfoPath)) {
-                        (expectedBuildInfoFiles || (expectedBuildInfoFiles = [])).push(
-                            [buildInfoPath, jsFilePath, declarationFilePath]
-                        );
-                    }
+    export function baselineBuildInfo(
+        configs: readonly ParsedCommandLine[],
+        fs: vfs.FileSystem,
+        writtenFiles: Map<true>
+    ) {
+        let expectedBuildInfoFiles: BuildInfoSectionBaselineFiles[] | undefined;
+        for (const { options } of configs) {
+            const out = options.outFile || options.out;
+            if (out) {
+                const { jsFilePath, declarationFilePath, buildInfoPath } = getOutputPathsForBundle(options, /*forceDts*/ false);
+                if (buildInfoPath && writtenFiles.has(buildInfoPath)) {
+                    (expectedBuildInfoFiles || (expectedBuildInfoFiles = [])).push(
+                        [buildInfoPath, jsFilePath, declarationFilePath]
+                    );
                 }
             }
-            if (expectedBuildInfoFiles) generateBuildInfoSectionBaselineFiles(fs, expectedBuildInfoFiles);
         }
-        fs.makeReadonly();
-        return { fs, actualReadFileMap, host, builder, writtenFiles };
+        if (expectedBuildInfoFiles) generateBuildInfoSectionBaselineFiles(fs, expectedBuildInfoFiles);
     }
 
-    function generateBaseline(fs: vfs.FileSystem, proj: string, scenario: string, subScenario: string, baseFs: vfs.FileSystem) {
-        const patch = fs.diff(baseFs, { includeChangedFileWithSameContent: true });
-        // eslint-disable-next-line no-null/no-null
-        Harness.Baseline.runBaseline(`tsbuild/${proj}/${subScenario.split(" ").join("-")}/${scenario.split(" ").join("-")}.js`, patch ? vfs.formatPatch(patch) : null);
-    }
-
-    function verifyReadFileCalls(actualReadFileMap: Map<number>, expectedReadFiles: ReadonlyMap<number>) {
-        TestFSWithWatch.verifyMapSize("readFileCalls", actualReadFileMap, arrayFrom(expectedReadFiles.keys()));
-        expectedReadFiles.forEach((expected, expectedFile) => {
-            const actual = actualReadFileMap.get(expectedFile);
-            assert.equal(actual, expected, `Mismatch in read file call number for: ${expectedFile}
-Not in Actual: ${JSON.stringify(arrayFrom(mapDefinedIterator(expectedReadFiles.keys(), f => actualReadFileMap.has(f) ? undefined : f)))}
-Mismatch Actual(path, actual, expected): ${JSON.stringify(arrayFrom(mapDefinedIterator(actualReadFileMap.entries(), ([p, v]) => expectedReadFiles.get(p) !== v ? [p, v, expectedReadFiles.get(p) || 0] : undefined)))}`);
-        });
-    }
-
-    export function getReadFilesMap(filesReadOnce: readonly string[], ...filesWithTwoReadCalls: string[]) {
-        const map = arrayToMap(filesReadOnce, identity, () => 1);
-        for (const fileWithTwoReadCalls of filesWithTwoReadCalls) {
-            map.set(fileWithTwoReadCalls, 2);
-        }
-        return map;
-    }
-
-    export interface ExpectedBuildOutput {
-        expectedDiagnostics?: readonly fakes.ExpectedDiagnostic[];
-        expectedReadFiles?: ReadonlyMap<number>;
-    }
-
-    export interface BuildState extends ExpectedBuildOutput {
+    export interface TscIncremental {
+        buildKind: BuildKind;
         modifyFs: (fs: vfs.FileSystem) => void;
+        subScenario?: string;
     }
 
-    export interface VerifyTsBuildInput {
-        scenario: string;
-        projFs: () => vfs.FileSystem;
-        time: () => number;
-        tick: () => void;
-        proj: string;
-        rootNames: readonly string[];
-        initialBuild: BuildState;
-        incrementalDtsChangedBuild?: BuildState;
-        incrementalDtsUnchangedBuild?: BuildState;
-        incrementalHeaderChangedBuild?: BuildState;
-        baselineOnly?: true;
-        verifyDiagnostics?: true;
-        baselineSourceMap?: true;
+    export interface VerifyTsBuildInput extends TscCompile {
+        incrementalScenarios: TscIncremental[];
     }
 
-    export function verifyTsbuildOutput({
-        scenario, projFs, time, tick, proj, rootNames,
-        baselineOnly, verifyDiagnostics, baselineSourceMap,
-        initialBuild, incrementalDtsChangedBuild, incrementalDtsUnchangedBuild, incrementalHeaderChangedBuild
+    export function verifyTscIncrementalEdits({
+        subScenario, fs, scenario, commandLineArgs,
+        baselineSourceMap, modifyFs, baselineReadFileCalls,
+        incrementalScenarios
     }: VerifyTsBuildInput) {
-        describe(`tsc --b ${proj}:: ${scenario}`, () => {
-            let fs: vfs.FileSystem;
-            let actualReadFileMap: Map<number>;
-            let firstBuildTime: number;
-            let host: fakes.SolutionBuilderHost;
-            let initialWrittenFiles: Map<true>;
+        describe(`tsc --b ${scenario}:: ${subScenario}`, () => {
+            let tick: () => void;
+            let sys: TscCompileSystem;
             before(() => {
-                const result = tscBuild({
-                    fs: projFs().shadow(),
-                    tick,
-                    rootNames,
-                    modifyFs: initialBuild.modifyFs,
+                let baseFs: vfs.FileSystem;
+                ({ fs: baseFs, tick } = getFsWithTime(fs()));
+                sys = tscCompile({
+                    scenario,
+                    subScenario,
+                    fs: () => baseFs.makeReadonly(),
+                    commandLineArgs,
+                    modifyFs: fs => {
+                        if (modifyFs) modifyFs(fs);
+                        tick();
+                    },
                     baselineSourceMap,
-                    baselineBuildInfo: true,
+                    baselineReadFileCalls
                 });
-                ({ fs, actualReadFileMap, host, writtenFiles: initialWrittenFiles } = result);
-                firstBuildTime = time();
+                Debug.assert(!!incrementalScenarios.length, `${scenario}/${subScenario}:: No incremental scenarios, you probably want to use verifyTsc instead.`);
             });
             after(() => {
-                fs = undefined!;
-                actualReadFileMap = undefined!;
-                host = undefined!;
-                initialWrittenFiles = undefined!;
+                sys = undefined!;
+                tick = undefined!;
             });
             describe("initialBuild", () => {
-                if (!baselineOnly || verifyDiagnostics) {
-                    it(`verify diagnostics`, () => {
-                        host.assertDiagnosticMessages(...(initialBuild.expectedDiagnostics || emptyArray));
-                    });
-                }
-                it(`Generates files matching the baseline`, () => {
-                    generateBaseline(fs, proj, scenario, "initial Build", projFs());
-                });
-                if (!baselineOnly) {
-                    it("verify readFile calls", () => {
-                        verifyReadFileCalls(actualReadFileMap, Debug.assertDefined(initialBuild.expectedReadFiles));
-                    });
-                }
+                verifyTscBaseline(() => sys);
             });
 
-            function incrementalBuild(subScenario: string, incrementalModifyFs: (fs: vfs.FileSystem) => void, incrementalExpectedDiagnostics: readonly fakes.ExpectedDiagnostic[] | undefined, incrementalExpectedReadFiles: ReadonlyMap<number> | undefined) {
-                describe(subScenario, () => {
-                    let newFs: vfs.FileSystem;
-                    let actualReadFileMap: Map<number>;
-                    let host: fakes.SolutionBuilderHost;
-                    let beforeBuildTime: number;
-                    let afterBuildTime: number;
+            for (const { buildKind, modifyFs, subScenario: incrementalSubScenario } of incrementalScenarios) {
+                describe(incrementalSubScenario || buildKind, () => {
+                    let newSys: TscCompileSystem;
                     before(() => {
-                        const lastProjectOutput = last(arrayFrom(initialWrittenFiles.keys()));
-                        beforeBuildTime = fs.statSync(lastProjectOutput).mtimeMs;
+                        Debug.assert(buildKind !== BuildKind.Initial, "Incremental edit cannot be initial compilation");
                         tick();
-                        newFs = fs.shadow();
-                        tick();
-                        ({ actualReadFileMap, host } = tscBuild({
-                            fs: newFs,
-                            tick,
-                            rootNames,
-                            modifyFs: incrementalModifyFs,
+                        newSys = tscCompile({
+                            scenario,
+                            subScenario: incrementalSubScenario || subScenario,
+                            buildKind,
+                            fs: () => sys.vfs,
+                            commandLineArgs,
+                            modifyFs: fs => {
+                                tick();
+                                modifyFs(fs);
+                                tick();
+                            },
                             baselineSourceMap,
-                            baselineBuildInfo: true,
-                        }));
-                        afterBuildTime = newFs.statSync(lastProjectOutput).mtimeMs;
+                            baselineReadFileCalls
+                        });
                     });
                     after(() => {
-                        newFs = undefined!;
-                        actualReadFileMap = undefined!;
-                        host = undefined!;
+                        newSys = undefined!;
                     });
-                    it("verify build output times", () => {
-                        assert.equal(beforeBuildTime, firstBuildTime, "First build timestamp is correct");
-                        assert.equal(afterBuildTime, time(), "Second build timestamp is correct");
-                    });
-                    if (!baselineOnly || verifyDiagnostics) {
-                        it(`verify diagnostics`, () => {
-                            host.assertDiagnosticMessages(...(incrementalExpectedDiagnostics || emptyArray));
-                        });
-                    }
-                    else {
-                        // Build should pass without errors if not verifying diagnostics
-                        it(`verify no errors`, () => {
-                            host.assertErrors(/*empty*/);
-                        });
-                    }
-                    it(`Generates files matching the baseline`, () => {
-                        generateBaseline(newFs, proj, scenario, subScenario, fs);
-                    });
-                    if (!baselineOnly) {
-                        it("verify readFile calls", () => {
-                            verifyReadFileCalls(actualReadFileMap, Debug.assertDefined(incrementalExpectedReadFiles));
-                        });
-                    }
+                    verifyTscBaseline(() => newSys);
                     it(`Verify emit output file text is same when built clean`, () => {
-                        const { fs, writtenFiles } = tscBuild({
-                            fs: newFs.shadow(),
-                            tick,
-                            rootNames,
+                        const sys = tscCompile({
+                            scenario,
+                            subScenario,
+                            fs: () => newSys.vfs,
+                            commandLineArgs,
                             modifyFs: fs => {
+                                tick();
                                 // Delete output files
-                                const host = new fakes.SolutionBuilderHost(fs);
-                                const builder = createSolutionBuilder(host, rootNames, { clean: true });
+                                const host = fakes.SolutionBuilderHost.create(fs);
+                                const builder = createSolutionBuilder(host, commandLineArgs, { clean: true });
                                 builder.clean();
                             },
                         });
 
-                        for (const outputFile of arrayFrom(writtenFiles.keys())) {
-                            const expectedText = fs.existsSync(outputFile) ? fs.readFileSync(outputFile, "utf8") : undefined;
-                            const actualText = newFs.existsSync(outputFile) ? newFs.readFileSync(outputFile, "utf8") : undefined;
+                        for (const outputFile of arrayFrom(sys.writtenFiles.keys())) {
+                            const expectedText = sys.readFile(outputFile);
+                            const actualText = newSys.readFile(outputFile);
                             assert.equal(actualText, expectedText, `File: ${outputFile}`);
                         }
                     });
                 });
             }
-            if (incrementalDtsChangedBuild) {
-                incrementalBuild(
-                    "incremental declaration changes",
-                    incrementalDtsChangedBuild.modifyFs,
-                    incrementalDtsChangedBuild.expectedDiagnostics,
-                    incrementalDtsChangedBuild.expectedReadFiles,
-                );
-            }
-
-            if (incrementalDtsUnchangedBuild) {
-                incrementalBuild(
-                    "incremental declaration doesnt change",
-                    incrementalDtsUnchangedBuild.modifyFs,
-                    incrementalDtsUnchangedBuild.expectedDiagnostics,
-                    incrementalDtsUnchangedBuild.expectedReadFiles
-                );
-            }
-
-            if (incrementalHeaderChangedBuild) {
-                incrementalBuild(
-                    "incremental headers change without dts changes",
-                    incrementalHeaderChangedBuild.modifyFs,
-                    incrementalHeaderChangedBuild.expectedDiagnostics,
-                    incrementalHeaderChangedBuild.expectedReadFiles
-                );
-            }
         });
     }
 

src/testRunner/unittests/tsbuild/inferredTypeFromTransitiveModule.ts

@@ -1,82 +1,51 @@
 namespace ts {
     describe("unittests:: tsbuild:: inferredTypeFromTransitiveModule::", () => {
         let projFs: vfs.FileSystem;
-        const { time, tick } = getTime();
         before(() => {
-            projFs = loadProjectFromDisk("tests/projects/inferredTypeFromTransitiveModule", time);
+            projFs = loadProjectFromDisk("tests/projects/inferredTypeFromTransitiveModule");
         });
         after(() => {
             projFs = undefined!;
         });
 
-        verifyTsbuildOutput({
-            scenario: "inferred type from transitive module",
-            projFs: () => projFs,
-            time,
-            tick,
-            proj: "inferredTypeFromTransitiveModule",
-            rootNames: ["/src"],
-            initialBuild: {
-                modifyFs: noop,
-                expectedDiagnostics: [
-                    getExpectedDiagnosticForProjectsInBuild("src/tsconfig.json"),
-                    [Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist, "src/tsconfig.json", "src/obj/bar.js"],
-                    [Diagnostics.Building_project_0, "/src/tsconfig.json"]
-                ]
-            },
-            incrementalDtsChangedBuild: {
+        verifyTscIncrementalEdits({
+            scenario: "inferredTypeFromTransitiveModule",
+            subScenario: "inferred type from transitive module",
+            fs: () => projFs,
+            commandLineArgs: ["--b", "/src", "--verbose"],
+            incrementalScenarios: [{
+                buildKind: BuildKind.IncrementalDtsChange,
                 modifyFs: changeBarParam,
-                expectedDiagnostics: [
-                    getExpectedDiagnosticForProjectsInBuild("src/tsconfig.json"),
-                    [Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, "src/tsconfig.json", "src/obj/bar.js", "src/bar.ts"],
-                    [Diagnostics.Building_project_0, "/src/tsconfig.json"],
-                    [Diagnostics.Updating_unchanged_output_timestamps_of_project_0, "/src/tsconfig.json"]
-                ]
-            },
-            baselineOnly: true,
-            verifyDiagnostics: true
+            }],
         });
 
-        verifyTsbuildOutput({
-            scenario: "inferred type from transitive module with isolatedModules",
-            projFs: () => projFs,
-            time,
-            tick,
-            proj: "inferredTypeFromTransitiveModule",
-            rootNames: ["/src"],
-            initialBuild: { modifyFs: changeToIsolatedModules },
-            incrementalDtsChangedBuild: { modifyFs: changeBarParam },
-            baselineOnly: true,
+        verifyTscIncrementalEdits({
+            subScenario: "inferred type from transitive module with isolatedModules",
+            fs: () => projFs,
+            scenario: "inferredTypeFromTransitiveModule",
+            commandLineArgs: ["--b", "/src", "--verbose"],
+            modifyFs: changeToIsolatedModules,
+            incrementalScenarios: [{
+                buildKind: BuildKind.IncrementalDtsChange,
+                modifyFs: changeBarParam
+            }]
         });
 
-        it("reports errors in files affected by change in signature", () => {
-            const { fs, host } = tscBuild({
-                fs: projFs.shadow(),
-                tick,
-                rootNames: ["/src"],
-                modifyFs: fs => {
-                    changeToIsolatedModules(fs);
-                    appendText(fs, "/src/lazyIndex.ts", `
+        verifyTscIncrementalEdits({
+            scenario: "inferredTypeFromTransitiveModule",
+            subScenario: "reports errors in files affected by change in signature with isolatedModules",
+            fs: () => projFs,
+            commandLineArgs: ["--b", "/src", "--verbose"],
+            modifyFs: fs => {
+                changeToIsolatedModules(fs);
+                appendText(fs, "/src/lazyIndex.ts", `
 import { default as bar } from './bar';
 bar("hello");`);
-                }
-            });
-            host.assertErrors(/*empty*/);
-
-            tick();
-            const { fs: newFs, host: newHost, writtenFiles } = tscBuild({
-                fs: fs.shadow(),
-                tick,
-                rootNames: ["/src"],
+            },
+            incrementalScenarios: [{
+                buildKind: BuildKind.IncrementalDtsChange,
                 modifyFs: changeBarParam
-            });
-            // Has errors
-            newHost.assertErrors({
-                message: [Diagnostics.Expected_0_arguments_but_got_1, 0, 1],
-                location: expectedLocationIndexOf(newFs, "/src/lazyIndex.ts", `"hello"`)
-            });
-            // No written files
-            assert.equal(writtenFiles.size, 0);
+            }]
         });
     });
 

src/testRunner/unittests/tsbuild/lateBoundSymbol.ts

@@ -1,40 +1,22 @@
 namespace ts {
     describe("unittests:: tsbuild:: lateBoundSymbol:: interface is merged and contains late bound member", () => {
         let projFs: vfs.FileSystem;
-        const { time, tick } = getTime();
         before(() => {
-            projFs = loadProjectFromDisk("tests/projects/lateBoundSymbol", time);
+            projFs = loadProjectFromDisk("tests/projects/lateBoundSymbol");
         });
         after(() => {
             projFs = undefined!; // Release the contents
         });
 
-        verifyTsbuildOutput({
-            scenario: "interface is merged and contains late bound member",
-            projFs: () => projFs,
-            time,
-            tick,
-            proj: "lateBoundSymbol",
-            rootNames: ["/src/tsconfig.json"],
-            initialBuild: {
-                modifyFs: noop,
-                expectedDiagnostics: [
-                    getExpectedDiagnosticForProjectsInBuild("src/tsconfig.json"),
-                    [Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist, "src/tsconfig.json", "src/src/hkt.js"],
-                    [Diagnostics.Building_project_0, "/src/tsconfig.json"]
-                ]
-            },
-            incrementalDtsUnchangedBuild: {
+        verifyTscIncrementalEdits({
+            subScenario: "interface is merged and contains late bound member",
+            fs: () => projFs,
+            scenario: "lateBoundSymbol",
+            commandLineArgs: ["--b", "/src/tsconfig.json", "--verbose"],
+            incrementalScenarios: [{
+                buildKind: BuildKind.IncrementalDtsUnchanged,
                 modifyFs: fs => replaceText(fs, "/src/src/main.ts", "const x = 10;", ""),
-                expectedDiagnostics: [
-                    getExpectedDiagnosticForProjectsInBuild("src/tsconfig.json"),
-                    [Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, "src/tsconfig.json", "src/src/hkt.js", "src/src/main.ts"],
-                    [Diagnostics.Building_project_0, "/src/tsconfig.json"],
-                    [Diagnostics.Updating_unchanged_output_timestamps_of_project_0, "/src/tsconfig.json"]
-                ]
-            },
-            baselineOnly: true,
-            verifyDiagnostics: true
+            }]
         });
     });
 }

src/testRunner/unittests/tsbuild/missingExtendedFile.ts

@@ -3,7 +3,7 @@ namespace ts {
         it("unittests:: tsbuild - when tsconfig extends the missing file", () => {
             const projFs = loadProjectFromDisk("tests/projects/missingExtendedConfig");
             const fs = projFs.shadow();
-            const host = new fakes.SolutionBuilderHost(fs);
+            const host = fakes.SolutionBuilderHost.create(fs);
             const builder = createSolutionBuilder(host, ["/src/tsconfig.json"], {});
             builder.build();
             host.assertDiagnosticMessages(

src/testRunner/unittests/tsbuild/moduleSpecifiers.ts

@@ -1,16 +1,16 @@
 namespace ts {
     // https://github.com/microsoft/TypeScript/issues/31696
     describe("unittests:: tsbuild:: moduleSpecifiers:: synthesized module specifiers to referenced projects resolve correctly", () => {
-        let projFs: vfs.FileSystem;
-        const { time, tick } = getTime();
-        before(() => {
-            projFs = loadProjectFromFiles({
-                "/src/common/nominal.ts": utils.dedent`
+        verifyTsc({
+            scenario: "moduleSpecifiers",
+            subScenario: `synthesized module specifiers resolve correctly`,
+            fs: () => loadProjectFromFiles({
+                "/src/solution/common/nominal.ts": utils.dedent`
                     export declare type Nominal<T, Name extends string> = T & {
                         [Symbol.species]: Name;
                     };
                     `,
-                "/src/common/tsconfig.json": utils.dedent`
+                "/src/solution/common/tsconfig.json": utils.dedent`
                     {
                         "extends": "../../tsconfig.base.json",
                         "compilerOptions": {
@@ -18,12 +18,12 @@ namespace ts {
                         },
                         "include": ["nominal.ts"]
                     }`,
-                "/src/sub-project/index.ts": utils.dedent`
+                "/src/solution/sub-project/index.ts": utils.dedent`
                     import { Nominal } from '../common/nominal';
 
                     export type MyNominal = Nominal<string, 'MyNominal'>;
                     `,
-                "/src/sub-project/tsconfig.json": utils.dedent`
+                "/src/solution/sub-project/tsconfig.json": utils.dedent`
                     {
                         "extends": "../../tsconfig.base.json",
                         "compilerOptions": {
@@ -34,7 +34,7 @@ namespace ts {
                         ],
                         "include": ["./index.ts"]
                     }`,
-                "/src/sub-project-2/index.ts": utils.dedent`
+                "/src/solution/sub-project-2/index.ts": utils.dedent`
                     import { MyNominal } from '../sub-project/index';
 
                     const variable = {
@@ -45,7 +45,7 @@ namespace ts {
                         return 'key';
                     }
                     `,
-                "/src/sub-project-2/tsconfig.json": utils.dedent`
+                "/src/solution/sub-project-2/tsconfig.json": utils.dedent`
                     {
                         "extends": "../../tsconfig.base.json",
                         "compilerOptions": {
@@ -56,7 +56,7 @@ namespace ts {
                         ],
                         "include": ["./index.ts"]
                     }`,
-                "/src/tsconfig.json": utils.dedent`
+                "/src/solution/tsconfig.json": utils.dedent`
                     {
                         "compilerOptions": {
                             "composite": true
@@ -67,7 +67,7 @@ namespace ts {
                         ],
                         "include": []
                     }`,
-                "/tsconfig.base.json": utils.dedent`
+                "/src/tsconfig.base.json": utils.dedent`
                     {
                         "compilerOptions": {
                             "skipLibCheck": true,
@@ -75,31 +75,17 @@ namespace ts {
                             "outDir": "lib",
                         }
                     }`,
-                "/tsconfig.json": utils.dedent`{
+                "/src/tsconfig.json": utils.dedent`{
                     "compilerOptions": {
                         "composite": true
                     },
                     "references": [
-                        { "path": "./src" }
+                        { "path": "./solution" }
                     ],
                     "include": []
                 }`
-            }, time, symbolLibContent);
-        });
-        after(() => {
-            projFs = undefined!;
-        });
-        verifyTsbuildOutput({
-            scenario: `synthesized module specifiers resolve correctly`,
-            projFs: () => projFs,
-            time,
-            tick,
-            proj: "moduleSpecifiers",
-            rootNames: ["/"],
-            initialBuild: {
-                modifyFs: noop,
-            },
-            baselineOnly: true
+            }, symbolLibContent),
+            commandLineArgs: ["-b", "/src", "--verbose"]
         });
     });
 }

src/testRunner/unittests/tsbuild/outFile.ts

@@ -56,7 +56,6 @@ namespace ts {
             ]
         ];
         const relSources = sources.map(([config, sources]) => [relName(config), sources.map(relName)]) as any as [Sources, Sources, Sources];
-        const { time, tick } = getTime();
         let expectedOutputFiles = [
             ...outputFiles[project.first],
             ...outputFiles[project.second],
@@ -71,242 +70,78 @@ namespace ts {
             [Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist, relSources[project.third][source.config], relOutputFiles[project.third][ext.js]],
             [Diagnostics.Building_project_0, sources[project.third][source.config]]
         ];
-        let initialExpectedReadFiles: ReadonlyMap<number> = getReadFilesMap(
-            [
-                // Configs
-                sources[project.first][source.config],
-                sources[project.second][source.config],
-                sources[project.third][source.config],
-
-                // Source files
-                ...sources[project.first][source.ts],
-                ...sources[project.second][source.ts],
-                ...sources[project.third][source.ts],
-
-                // outputs
-                ...outputFiles[project.first],
-                ...outputFiles[project.second],
-            ]
-        );
-
-        let dtsChangedExpectedDiagnostics: readonly fakes.ExpectedDiagnostic[] = [
-            getExpectedDiagnosticForProjectsInBuild(relSources[project.first][source.config], relSources[project.second][source.config], relSources[project.third][source.config]),
-            [Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, relSources[project.first][source.config], relOutputFiles[project.first][ext.js], relSources[project.first][source.ts][part.one]],
-            [Diagnostics.Building_project_0, sources[project.first][source.config]],
-            [Diagnostics.Project_0_is_up_to_date_because_newest_input_1_is_older_than_oldest_output_2, relSources[project.second][source.config], relSources[project.second][source.ts][part.one], relOutputFiles[project.second][ext.js]],
-            [Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, relSources[project.third][source.config], relOutputFiles[project.third][ext.js], "src/first"],
-            [Diagnostics.Building_project_0, sources[project.third][source.config]]
-        ];
-        let dtsChangedExpectedReadFiles: ReadonlyMap<number> = getReadFilesMap(
-            [
-                // Configs
-                sources[project.first][source.config],
-                sources[project.second][source.config],
-                sources[project.third][source.config],
-
-                // Source files
-                ...sources[project.first][source.ts],
-                ...sources[project.third][source.ts],
-
-                // outputs
-                ...outputFiles[project.first],
-                ...outputFiles[project.second],
-                outputFiles[project.third][ext.dts],
-            ],
-            outputFiles[project.first][ext.dts], // dts changes so once read old content, and once new (to emit third)
-        );
-
-        let dtsChangedExpectedDiagnosticsDependOrdered: readonly fakes.ExpectedDiagnostic[] = [
-            getExpectedDiagnosticForProjectsInBuild(relSources[project.first][source.config], relSources[project.second][source.config], relSources[project.third][source.config]),
-            [Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, relSources[project.first][source.config], relOutputFiles[project.first][ext.js], relSources[project.first][source.ts][part.one]],
-            [Diagnostics.Building_project_0, sources[project.first][source.config]],
-            [Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, relSources[project.second][source.config], relOutputFiles[project.second][ext.js], "src/first"],
-            [Diagnostics.Building_project_0, sources[project.second][source.config]],
-            [Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, relSources[project.third][source.config], relOutputFiles[project.third][ext.js], "src/second"],
-            [Diagnostics.Building_project_0, sources[project.third][source.config]]
-        ];
-        let dtsChangedExpectedReadFilesDependOrdered: ReadonlyMap<number> = getDtsChangedReadFilesDependOrdered();
-
-        let dtsUnchangedExpectedDiagnostics: readonly fakes.ExpectedDiagnostic[] = [
-            getExpectedDiagnosticForProjectsInBuild(relSources[project.first][source.config], relSources[project.second][source.config], relSources[project.third][source.config]),
-            [Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, relSources[project.first][source.config], relOutputFiles[project.first][ext.js], relSources[project.first][source.ts][part.one]],
-            [Diagnostics.Building_project_0, sources[project.first][source.config]],
-            [Diagnostics.Project_0_is_up_to_date_because_newest_input_1_is_older_than_oldest_output_2, relSources[project.second][source.config], relSources[project.second][source.ts][part.one], relOutputFiles[project.second][ext.js]],
-            [Diagnostics.Project_0_is_out_of_date_because_output_of_its_dependency_1_has_changed, relSources[project.third][source.config], "src/first"],
-            [Diagnostics.Updating_output_of_project_0, sources[project.third][source.config]],
-            [Diagnostics.Updating_unchanged_output_timestamps_of_project_0, sources[project.third][source.config]],
-        ];
-        let dtsUnchangedExpectedReadFiles: ReadonlyMap<number> = getReadFilesMap(
-            [
-                // Configs
-                sources[project.first][source.config],
-                sources[project.second][source.config],
-                sources[project.third][source.config],
-
-                // Source files
-                ...sources[project.first][source.ts],
-
-                // outputs to prepend
-                ...outputFiles[project.first],
-                ...outputFiles[project.second],
-                ...outputFiles[project.third],
-            ]
-        );
-
-        let dtsUnchangedExpectedDiagnosticsDependOrdered: readonly fakes.ExpectedDiagnostic[] = [
-            getExpectedDiagnosticForProjectsInBuild(relSources[project.first][source.config], relSources[project.second][source.config], relSources[project.third][source.config]),
-            [Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, relSources[project.first][source.config], relOutputFiles[project.first][ext.js], relSources[project.first][source.ts][part.one]],
-            [Diagnostics.Building_project_0, sources[project.first][source.config]],
-            [Diagnostics.Project_0_is_out_of_date_because_output_of_its_dependency_1_has_changed, relSources[project.second][source.config], "src/first"],
-            [Diagnostics.Updating_output_of_project_0, sources[project.second][source.config]],
-            [Diagnostics.Updating_unchanged_output_timestamps_of_project_0, sources[project.second][source.config]],
-            [Diagnostics.Project_0_is_out_of_date_because_output_of_its_dependency_1_has_changed, relSources[project.third][source.config], "src/second"],
-            [Diagnostics.Updating_output_of_project_0, sources[project.third][source.config]],
-            [Diagnostics.Updating_unchanged_output_timestamps_of_project_0, sources[project.third][source.config]],
-        ];
-        let dtsUnchangedExpectedReadFilesDependOrdered: ReadonlyMap<number> = getDtsUnchangedExpectedReadFilesDependOrdered();
-
         before(() => {
-            outFileFs = loadProjectFromDisk("tests/projects/outfile-concat", time);
+            outFileFs = loadProjectFromDisk("tests/projects/outfile-concat");
         });
         after(() => {
             outFileFs = undefined!;
             expectedOutputFiles = undefined!;
             initialExpectedDiagnostics = undefined!;
-            initialExpectedReadFiles = undefined!;
-            dtsChangedExpectedDiagnostics = undefined!;
-            dtsChangedExpectedReadFiles = undefined!;
-            dtsChangedExpectedDiagnosticsDependOrdered = undefined!;
-            dtsChangedExpectedReadFilesDependOrdered = undefined!;
-            dtsUnchangedExpectedDiagnostics = undefined!;
-            dtsUnchangedExpectedReadFiles = undefined!;
-            dtsUnchangedExpectedDiagnosticsDependOrdered = undefined!;
-            dtsUnchangedExpectedReadFilesDependOrdered = undefined!;
         });
 
         function createSolutionBuilder(host: fakes.SolutionBuilderHost, baseOptions?: BuildOptions) {
             return ts.createSolutionBuilder(host, ["/src/third"], { dry: false, force: false, verbose: true, ...(baseOptions || {}) });
         }
 
-        function getInitialExpectedReadFiles(additionalSourceFiles?: readonly string[]) {
-            if (!additionalSourceFiles) return initialExpectedReadFiles;
-            const expectedReadFiles = cloneMap(initialExpectedReadFiles);
-            for (const path of additionalSourceFiles) {
-                expectedReadFiles.set(path, 1);
-            }
-            return expectedReadFiles;
-        }
-
-        function getDtsChangedReadFilesDependOrdered() {
-            const value = cloneMap(dtsChangedExpectedReadFiles);
-            for (const path of sources[project.second][source.ts]) {
-                value.set(path, 1);
-            }
-            value.set(outputFiles[project.second][ext.dts], 2); // dts changes so once read old content, and once new (to emit third)
-            return value;
-        }
-
-        function getDtsChangedReadFiles(dependOrdered?: boolean, additionalSourceFiles?: readonly string[]) {
-            const value = dependOrdered ? dtsChangedExpectedReadFilesDependOrdered : dtsChangedExpectedReadFiles;
-            if (!additionalSourceFiles) return value;
-            const expectedReadFiles = cloneMap(value);
-            for (const path of additionalSourceFiles) {
-                expectedReadFiles.set(path, 1);
-            }
-            return expectedReadFiles;
-        }
-
-        function getDtsUnchangedExpectedReadFilesDependOrdered() {
-            const value = cloneMap(dtsUnchangedExpectedReadFiles);
-            // Since this changes too
-            for (const path of outputFiles[project.second]) {
-                value.set(path, 2);
-            }
-            return value;
-        }
-
-        function getDtsUnchangedReadFiles(dependOrdered?: boolean, additionalSourceFiles?: readonly string[]) {
-            const value = dependOrdered ? dtsUnchangedExpectedReadFilesDependOrdered : dtsUnchangedExpectedReadFiles;
-            if (!additionalSourceFiles || additionalSourceFiles.length !== 3) return value;
-            const expectedReadFiles = cloneMap(value);
-            // Additional source Files
-            expectedReadFiles.set(additionalSourceFiles[project.first], 1);
-            return expectedReadFiles;
-        }
-
         interface VerifyOutFileScenarioInput {
-            scenario: string;
-            modifyFs: (fs: vfs.FileSystem) => void;
+            subScenario: string;
+            modifyFs?: (fs: vfs.FileSystem) => void;
             modifyAgainFs?: (fs: vfs.FileSystem) => void;
-            additionalSourceFiles?: readonly string[];
-            dependOrdered?: true;
             ignoreDtsChanged?: true;
             ignoreDtsUnchanged?: true;
             baselineOnly?: true;
         }
 
         function verifyOutFileScenario({
-            scenario,
+            subScenario,
             modifyFs,
             modifyAgainFs,
-            additionalSourceFiles,
-            dependOrdered,
             ignoreDtsChanged,
             ignoreDtsUnchanged,
             baselineOnly
         }: VerifyOutFileScenarioInput) {
-            const initialExpectedReadFiles = !baselineOnly ? getInitialExpectedReadFiles(additionalSourceFiles) : undefined;
-            const dtsChangedReadFiles = !baselineOnly && !ignoreDtsChanged ? getDtsChangedReadFiles(dependOrdered, additionalSourceFiles) : undefined;
-            const dtsUnchanged: ExpectedBuildOutput | undefined = !baselineOnly && (!ignoreDtsUnchanged || !modifyAgainFs) ? {
-                expectedDiagnostics: dependOrdered ?
-                    dtsUnchangedExpectedDiagnosticsDependOrdered :
-                    dtsUnchangedExpectedDiagnostics,
-                expectedReadFiles: getDtsUnchangedReadFiles(dependOrdered, additionalSourceFiles)
-            } : undefined;
-
-            verifyTsbuildOutput({
-                scenario,
-                projFs: () => outFileFs,
-                time,
-                tick,
-                proj: "outfile-concat",
-                rootNames: ["/src/third"],
-                baselineSourceMap: true,
-                initialBuild: {
-                    modifyFs,
-                    expectedDiagnostics: initialExpectedDiagnostics,
-                    expectedReadFiles: initialExpectedReadFiles
-                },
-                incrementalDtsChangedBuild: !ignoreDtsChanged ? {
+            const incrementalScenarios: TscIncremental[] = [];
+            if (!ignoreDtsChanged) {
+                incrementalScenarios.push({
+                    buildKind: BuildKind.IncrementalDtsChange,
                     modifyFs: fs => replaceText(fs, relSources[project.first][source.ts][part.one], "Hello", "Hola"),
-                    expectedDiagnostics: dependOrdered ?
-                        dtsChangedExpectedDiagnosticsDependOrdered :
-                        dtsChangedExpectedDiagnostics,
-                    expectedReadFiles: dtsChangedReadFiles
-                } : undefined,
-                incrementalDtsUnchangedBuild: !ignoreDtsUnchanged ? {
+                });
+            }
+            if (!ignoreDtsUnchanged) {
+                incrementalScenarios.push({
+                    buildKind: BuildKind.IncrementalDtsUnchanged,
                     modifyFs: fs => appendText(fs, relSources[project.first][source.ts][part.one], "console.log(s);"),
-                    expectedDiagnostics: dtsUnchanged && dtsUnchanged.expectedDiagnostics,
-                    expectedReadFiles: dtsUnchanged && dtsUnchanged.expectedReadFiles
-                } : undefined,
-                incrementalHeaderChangedBuild: modifyAgainFs ? {
-                    modifyFs: modifyAgainFs,
-                    expectedDiagnostics: dtsUnchanged && dtsUnchanged.expectedDiagnostics,
-                    expectedReadFiles: dtsUnchanged && dtsUnchanged.expectedReadFiles
-                } : undefined,
-                baselineOnly
-            });
+                });
+            }
+            if (modifyAgainFs) {
+                incrementalScenarios.push({
+                    buildKind: BuildKind.IncrementalHeadersChange,
+                    modifyFs: modifyAgainFs
+                });
+            }
+            const input: VerifyTsBuildInput = {
+                subScenario,
+                fs: () => outFileFs,
+                scenario: "outfile-concat",
+                commandLineArgs: ["--b", "/src/third", "--verbose"],
+                baselineSourceMap: true,
+                modifyFs,
+                baselineReadFileCalls: !baselineOnly,
+                incrementalScenarios,
+            };
+            return incrementalScenarios.length ?
+                verifyTscIncrementalEdits(input) :
+                verifyTsc(input);
         }
 
         // Verify initial + incremental edits
         verifyOutFileScenario({
-            scenario: "baseline sectioned sourcemaps",
-            modifyFs: noop
+            subScenario: "baseline sectioned sourcemaps",
         });
 
         // Verify baseline with build info + dts unChanged
         verifyOutFileScenario({
-            scenario: "when final project is not composite but uses project references",
+            subScenario: "when final project is not composite but uses project references",
             modifyFs: fs => replaceText(fs, sources[project.third][source.config], `"composite": true,`, ""),
             ignoreDtsChanged: true,
             baselineOnly: true
@@ -314,7 +149,7 @@ namespace ts {
 
         // Verify baseline with build info
         verifyOutFileScenario({
-            scenario: "when final project is not composite but incremental",
+            subScenario: "when final project is not composite but incremental",
             modifyFs: fs => replaceText(fs, sources[project.third][source.config], `"composite": true,`, `"incremental": true,`),
             ignoreDtsChanged: true,
             ignoreDtsUnchanged: true,
@@ -323,7 +158,7 @@ namespace ts {
 
         // Verify baseline with build info
         verifyOutFileScenario({
-            scenario: "when final project specifies tsBuildInfoFile",
+            subScenario: "when final project specifies tsBuildInfoFile",
             modifyFs: fs => replaceText(fs, sources[project.third][source.config], `"composite": true,`, `"composite": true,
         "tsBuildInfoFile": "./thirdjs/output/third.tsbuildinfo",`),
             ignoreDtsChanged: true,
@@ -338,7 +173,7 @@ namespace ts {
                 ...outputFiles[project.second],
                 ...outputFiles[project.third]
             ];
-            const host = new fakes.SolutionBuilderHost(fs);
+            const host = fakes.SolutionBuilderHost.create(fs);
             const builder = createSolutionBuilder(host);
             builder.build();
             host.assertDiagnosticMessages(...initialExpectedDiagnostics);
@@ -354,13 +189,13 @@ namespace ts {
         });
 
         it("verify buildInfo absence results in new build", () => {
-            const fs = outFileFs.shadow();
+            const { fs, tick } = getFsWithTime(outFileFs);
             const expectedOutputs = [
                 ...outputFiles[project.first],
                 ...outputFiles[project.second],
                 ...outputFiles[project.third]
             ];
-            const host = new fakes.SolutionBuilderHost(fs);
+            const host = fakes.SolutionBuilderHost.create(fs);
             let builder = createSolutionBuilder(host);
             builder.build();
             host.assertDiagnosticMessages(...initialExpectedDiagnostics);
@@ -368,7 +203,11 @@ namespace ts {
             verifyOutputsPresent(fs, expectedOutputs);
             // Delete bundle info
             host.clearDiagnostics();
+
+            tick();
             host.deleteFile(outputFiles[project.first][ext.buildinfo]);
+            tick();
+
             builder = createSolutionBuilder(host);
             builder.build();
             host.assertDiagnosticMessages(
@@ -384,7 +223,7 @@ namespace ts {
 
         it("verify that if incremental is set to false, tsbuildinfo is not generated", () => {
             const fs = outFileFs.shadow();
-            const host = new fakes.SolutionBuilderHost(fs);
+            const host = fakes.SolutionBuilderHost.create(fs);
             replaceText(fs, sources[project.third][source.config], `"composite": true,`, "");
             const builder = createSolutionBuilder(host);
             builder.build();
@@ -395,14 +234,16 @@ namespace ts {
         });
 
         it("rebuilds completely when version in tsbuildinfo doesnt match ts version", () => {
-            const fs = outFileFs.shadow();
-            const host = new fakes.SolutionBuilderHost(fs);
+            const { fs, tick } = getFsWithTime(outFileFs);
+            const host = fakes.SolutionBuilderHost.create(fs);
             let builder = createSolutionBuilder(host);
             builder.build();
             host.assertDiagnosticMessages(...initialExpectedDiagnostics);
             host.clearDiagnostics();
+            tick();
             builder = createSolutionBuilder(host);
             changeCompilerVersion(host);
+            tick();
             builder.build();
             host.assertDiagnosticMessages(
                 getExpectedDiagnosticForProjectsInBuild(relSources[project.first][source.config], relSources[project.second][source.config], relSources[project.third][source.config]),
@@ -416,12 +257,12 @@ namespace ts {
         });
 
         it("rebuilds completely when command line incremental flag changes between non dts changes", () => {
-            const fs = outFileFs.shadow();
+            const { fs, tick } = getFsWithTime(outFileFs);
             // Make non composite third project
             replaceText(fs, sources[project.third][source.config], `"composite": true,`, "");
 
             // Build with command line incremental
-            const host = new fakes.SolutionBuilderHost(fs);
+            const host = fakes.SolutionBuilderHost.create(fs);
             let builder = createSolutionBuilder(host, { incremental: true });
             builder.build();
             host.assertDiagnosticMessages(...initialExpectedDiagnostics);
@@ -460,7 +301,7 @@ namespace ts {
 
         it("builds till project specified", () => {
             const fs = outFileFs.shadow();
-            const host = new fakes.SolutionBuilderHost(fs);
+            const host = fakes.SolutionBuilderHost.create(fs);
             const builder = createSolutionBuilder(host, { verbose: false });
             const result = builder.build(sources[project.second][source.config]);
             host.assertDiagnosticMessages(/*empty*/);
@@ -473,7 +314,7 @@ namespace ts {
 
         it("cleans till project specified", () => {
             const fs = outFileFs.shadow();
-            const host = new fakes.SolutionBuilderHost(fs);
+            const host = fakes.SolutionBuilderHost.create(fs);
             const builder = createSolutionBuilder(host, { verbose: false });
             builder.build();
             const result = builder.clean(sources[project.second][source.config]);
@@ -490,7 +331,7 @@ namespace ts {
             describe("Prologues", () => {
                 // Verify initial + incremental edits
                 verifyOutFileScenario({
-                    scenario: "strict in all projects",
+                    subScenario: "strict in all projects",
                     modifyFs: fs => {
                         enableStrict(fs, sources[project.first][source.config]);
                         enableStrict(fs, sources[project.second][source.config]);
@@ -501,7 +342,7 @@ namespace ts {
 
                 // Verify ignore dtsChanged
                 verifyOutFileScenario({
-                    scenario: "strict in one dependency",
+                    subScenario: "strict in one dependency",
                     modifyFs: fs => enableStrict(fs, sources[project.second][source.config]),
                     modifyAgainFs: fs => addTestPrologue(fs, "src/first/first_PART1.ts", `"myPrologue"`),
                     ignoreDtsChanged: true,
@@ -510,7 +351,7 @@ namespace ts {
 
                 // Verify initial + incremental edits - sourcemap verification
                 verifyOutFileScenario({
-                    scenario: "multiple prologues in all projects",
+                    subScenario: "multiple prologues in all projects",
                     modifyFs: fs => {
                         enableStrict(fs, sources[project.first][source.config]);
                         addTestPrologue(fs, sources[project.first][source.ts][part.one], `"myPrologue"`);
@@ -526,7 +367,7 @@ namespace ts {
 
                 // Verify ignore dtsChanged
                 verifyOutFileScenario({
-                    scenario: "multiple prologues in different projects",
+                    subScenario: "multiple prologues in different projects",
                     modifyFs: fs => {
                         enableStrict(fs, sources[project.first][source.config]);
                         addTestPrologue(fs, sources[project.second][source.ts][part.one], `"myPrologue"`);
@@ -544,7 +385,7 @@ namespace ts {
                 // changes declaration because its emitted in .d.ts file
                 // Verify initial + incremental edits
                 verifyOutFileScenario({
-                    scenario: "shebang in all projects",
+                    subScenario: "shebang in all projects",
                     modifyFs: fs => {
                         addShebang(fs, "first", "first_PART1");
                         addShebang(fs, "first", "first_part2");
@@ -555,7 +396,7 @@ namespace ts {
 
                 // Verify ignore dtsChanged
                 verifyOutFileScenario({
-                    scenario: "shebang in only one dependency project",
+                    subScenario: "shebang in only one dependency project",
                     modifyFs: fs => addShebang(fs, "second", "second_part1"),
                     ignoreDtsChanged: true,
                     baselineOnly: true
@@ -566,7 +407,7 @@ namespace ts {
             describe("emitHelpers", () => {
                 // Verify initial + incremental edits
                 verifyOutFileScenario({
-                    scenario: "emitHelpers in all projects",
+                    subScenario: "emitHelpers in all projects",
                     modifyFs: fs => {
                         addRest(fs, "first", "first_PART1");
                         addRest(fs, "second", "second_part1");
@@ -577,7 +418,7 @@ namespace ts {
 
                 // Verify ignore dtsChanged
                 verifyOutFileScenario({
-                    scenario: "emitHelpers in only one dependency project",
+                    subScenario: "emitHelpers in only one dependency project",
                     modifyFs: fs => {
                         addStubFoo(fs, "first", "first_PART1");
                         addRest(fs, "second", "second_part1");
@@ -589,7 +430,7 @@ namespace ts {
 
                 // Verify ignore dtsChanged
                 verifyOutFileScenario({
-                    scenario: "multiple emitHelpers in all projects",
+                    subScenario: "multiple emitHelpers in all projects",
                     modifyFs: fs => {
                         addRest(fs, "first", "first_PART1");
                         addSpread(fs, "first", "first_part3");
@@ -605,7 +446,7 @@ namespace ts {
 
                 // Verify ignore dtsChanged
                 verifyOutFileScenario({
-                    scenario: "multiple emitHelpers in different projects",
+                    subScenario: "multiple emitHelpers in different projects",
                     modifyFs: fs => {
                         addRest(fs, "first", "first_PART1");
                         addSpread(fs, "second", "second_part1");
@@ -622,24 +463,18 @@ namespace ts {
                 // changes declaration because its emitted in .d.ts file
                 // Verify initial + incremental edits
                 verifyOutFileScenario({
-                    scenario: "triple slash refs in all projects",
+                    subScenario: "triple slash refs in all projects",
                     modifyFs: fs => {
                         addTripleSlashRef(fs, "first", "first_part2");
                         addTripleSlashRef(fs, "second", "second_part1");
                         addTripleSlashRef(fs, "third", "third_part1");
-                    },
-                    additionalSourceFiles: [
-                        getTripleSlashRef("first"), getTripleSlashRef("second"), getTripleSlashRef("third")
-                    ]
+                    }
                 });
 
                 // Verify ignore dtsChanged
                 verifyOutFileScenario({
-                    scenario: "triple slash refs in one project",
+                    subScenario: "triple slash refs in one project",
                     modifyFs: fs => addTripleSlashRef(fs, "second", "second_part1"),
-                    additionalSourceFiles: [
-                        getTripleSlashRef("second")
-                    ],
                     ignoreDtsChanged: true,
                     baselineOnly: true
                 });
@@ -698,14 +533,14 @@ ${internal} enum internalEnum { a, b, c }`);
 
                 // Verify initial + incremental edits
                 verifyOutFileScenario({
-                    scenario: "stripInternal",
+                    subScenario: "stripInternal",
                     modifyFs: stripInternalScenario,
                     modifyAgainFs: fs => replaceText(fs, sources[project.first][source.ts][part.one], `/*@internal*/ interface`, "interface"),
                 });
 
                 // Verify ignore dtsChanged
                 verifyOutFileScenario({
-                    scenario: "stripInternal with comments emit enabled",
+                    subScenario: "stripInternal with comments emit enabled",
                     modifyFs: fs => stripInternalScenario(fs, /*removeCommentsDisabled*/ true),
                     modifyAgainFs: fs => replaceText(fs, sources[project.first][source.ts][part.one], `/*@internal*/ interface`, "interface"),
                     ignoreDtsChanged: true,
@@ -714,7 +549,7 @@ ${internal} enum internalEnum { a, b, c }`);
 
                 // Verify ignore dtsChanged
                 verifyOutFileScenario({
-                    scenario: "stripInternal jsdoc style comment",
+                    subScenario: "stripInternal jsdoc style comment",
                     modifyFs: fs => stripInternalScenario(fs, /*removeCommentsDisabled*/ false, /*jsDocStyle*/ true),
                     modifyAgainFs: fs => replaceText(fs, sources[project.first][source.ts][part.one], `/**@internal*/ interface`, "interface"),
                     ignoreDtsChanged: true,
@@ -723,7 +558,7 @@ ${internal} enum internalEnum { a, b, c }`);
 
                 // Verify ignore dtsChanged
                 verifyOutFileScenario({
-                    scenario: "stripInternal jsdoc style with comments emit enabled",
+                    subScenario: "stripInternal jsdoc style with comments emit enabled",
                     modifyFs: fs => stripInternalScenario(fs, /*removeCommentsDisabled*/ true, /*jsDocStyle*/ true),
                     ignoreDtsChanged: true,
                     baselineOnly: true
@@ -743,37 +578,33 @@ ${internal} enum internalEnum { a, b, c }`);
 
                     // Verify initial + incremental edits
                     verifyOutFileScenario({
-                        scenario: "stripInternal when one-two-three are prepended in order",
+                        subScenario: "stripInternal when one-two-three are prepended in order",
                         modifyFs: stripInternalWithDependentOrder,
                         modifyAgainFs: fs => replaceText(fs, sources[project.first][source.ts][part.one], `/*@internal*/ interface`, "interface"),
-                        dependOrdered: true,
                     });
 
                     // Verify ignore dtsChanged
                     verifyOutFileScenario({
-                        scenario: "stripInternal with comments emit enabled when one-two-three are prepended in order",
+                        subScenario: "stripInternal with comments emit enabled when one-two-three are prepended in order",
                         modifyFs: fs => stripInternalWithDependentOrder(fs, /*removeCommentsDisabled*/ true),
                         modifyAgainFs: fs => replaceText(fs, sources[project.first][source.ts][part.one], `/*@internal*/ interface`, "interface"),
-                        dependOrdered: true,
                         ignoreDtsChanged: true,
                         baselineOnly: true
                     });
 
                     // Verify ignore dtsChanged
                     verifyOutFileScenario({
-                        scenario: "stripInternal jsdoc style comment when one-two-three are prepended in order",
+                        subScenario: "stripInternal jsdoc style comment when one-two-three are prepended in order",
                         modifyFs: fs => stripInternalWithDependentOrder(fs, /*removeCommentsDisabled*/ false, /*jsDocStyle*/ true),
                         modifyAgainFs: fs => replaceText(fs, sources[project.first][source.ts][part.one], `/**@internal*/ interface`, "interface"),
-                        dependOrdered: true,
                         ignoreDtsChanged: true,
                         baselineOnly: true
                     });
 
                     // Verify ignore dtsChanged
                     verifyOutFileScenario({
-                        scenario: "stripInternal jsdoc style with comments emit enabled when one-two-three are prepended in order",
+                        subScenario: "stripInternal jsdoc style with comments emit enabled when one-two-three are prepended in order",
                         modifyFs: fs => stripInternalWithDependentOrder(fs, /*removeCommentsDisabled*/ true, /*jsDocStyle*/ true),
-                        dependOrdered: true,
                         ignoreDtsChanged: true,
                         baselineOnly: true
                     });
@@ -781,7 +612,7 @@ ${internal} enum internalEnum { a, b, c }`);
 
                 // only baseline
                 verifyOutFileScenario({
-                    scenario: "stripInternal baseline when internal is inside another internal",
+                    subScenario: "stripInternal baseline when internal is inside another internal",
                     modifyFs: fs => {
                         stripInternalOfThird(fs);
                         prependText(fs, sources[project.first][source.ts][part.one], `namespace ts {
@@ -820,7 +651,7 @@ ${internal} enum internalEnum { a, b, c }`);
 
                 // only baseline
                 verifyOutFileScenario({
-                    scenario: "stripInternal when few members of enum are internal",
+                    subScenario: "stripInternal when few members of enum are internal",
                     modifyFs: fs => {
                         stripInternalOfThird(fs);
                         prependText(fs, sources[project.first][source.ts][part.one], `enum TokenFlags {
@@ -860,7 +691,7 @@ ${internal} enum internalEnum { a, b, c }`);
 
                 // Verify ignore dtsChanged
                 verifyOutFileScenario({
-                    scenario: "when source files are empty in the own file",
+                    subScenario: "when source files are empty in the own file",
                     modifyFs: makeThirdEmptySourceFile,
                     ignoreDtsChanged: true,
                     baselineOnly: true
@@ -868,7 +699,7 @@ ${internal} enum internalEnum { a, b, c }`);
 
                 // only baseline
                 verifyOutFileScenario({
-                    scenario: "declarationMap and sourceMap disabled",
+                    subScenario: "declarationMap and sourceMap disabled",
                     modifyFs: fs => {
                         makeThirdEmptySourceFile(fs);
                         replaceText(fs, sources[project.third][source.config], `"composite": true,`, "");
@@ -898,7 +729,7 @@ ${internal} enum internalEnum { a, b, c }`);
             replaceText(fs, sources[project.second][source.config], `"outFile": "../2/second-output.js",`, "");
             replaceText(fs, sources[project.third][source.config], `"outFile": "./thirdjs/output/third-output.js",`, "");
 
-            const host = new fakes.SolutionBuilderHost(fs);
+            const host = fakes.SolutionBuilderHost.create(fs);
             const builder = createSolutionBuilder(host);
             builder.build();
             host.assertDiagnosticMessages(

src/testRunner/unittests/tsbuild/referencesWithRootDirInParent.ts

@@ -16,7 +16,7 @@ namespace ts {
                 "/src/dist/main/b.js", "/src/dist/main/b.d.ts"
             ];
             const fs = projFs.shadow();
-            const host = new fakes.SolutionBuilderHost(fs);
+            const host = fakes.SolutionBuilderHost.create(fs);
             const builder = createSolutionBuilder(host, ["/src/src/main", "/src/src/other"], {});
             builder.build();
             host.assertDiagnosticMessages(/*empty*/);
@@ -34,7 +34,7 @@ namespace ts {
             ];
             const fs = projFs.shadow();
             replaceText(fs, "/src/tsconfig.base.json", `"rootDir": "./src/",`, "");
-            const host = new fakes.SolutionBuilderHost(fs);
+            const host = fakes.SolutionBuilderHost.create(fs);
             const builder = createSolutionBuilder(host, ["/src/src/main"], { verbose: true });
             builder.build();
             host.assertDiagnosticMessages(
@@ -69,7 +69,7 @@ namespace ts {
             fs.writeFileSync("/src/src/other/tsconfig.json", JSON.stringify({
                 compilerOptions: { composite: true, outDir: "../../dist/" },
             }));
-            const host = new fakes.SolutionBuilderHost(fs);
+            const host = fakes.SolutionBuilderHost.create(fs);
             const builder = createSolutionBuilder(host, ["/src/src/main"], { verbose: true });
             builder.build();
             host.assertDiagnosticMessages(
@@ -105,7 +105,7 @@ namespace ts {
             fs.writeFileSync("/src/src/other/tsconfig.other.json", JSON.stringify({
                 compilerOptions: { composite: true, outDir: "../../dist/" },
             }));
-            const host = new fakes.SolutionBuilderHost(fs);
+            const host = fakes.SolutionBuilderHost.create(fs);
             const builder = createSolutionBuilder(host, ["/src/src/main/tsconfig.main.json"], { verbose: true });
             builder.build();
             host.assertDiagnosticMessages(

src/testRunner/unittests/tsbuild/resolveJsonModule.ts

@@ -1,10 +1,9 @@
 namespace ts {
     describe("unittests:: tsbuild:: with resolveJsonModule option on project resolveJsonModuleAndComposite", () => {
         let projFs: vfs.FileSystem;
-        const { time, tick } = getTime();
         const allExpectedOutputs = ["/src/dist/src/index.js", "/src/dist/src/index.d.ts", "/src/dist/src/hello.json"];
         before(() => {
-            projFs = loadProjectFromDisk("tests/projects/resolveJsonModuleAndComposite", time);
+            projFs = loadProjectFromDisk("tests/projects/resolveJsonModuleAndComposite");
         });
 
         after(() => {
@@ -17,7 +16,7 @@ namespace ts {
         }
 
         function verifyProjectWithResolveJsonModuleWithFs(fs: vfs.FileSystem, configFile: string, allExpectedOutputs: readonly string[], ...expectedDiagnosticMessages: fakes.ExpectedDiagnostic[]) {
-            const host = new fakes.SolutionBuilderHost(fs);
+            const host = fakes.SolutionBuilderHost.create(fs);
             const builder = createSolutionBuilder(host, [configFile], { dry: false, force: false, verbose: false });
             builder.build();
             host.assertDiagnosticMessages(...expectedDiagnosticMessages);
@@ -65,10 +64,10 @@ export default hello.hello`);
         });
 
         it("with resolveJsonModule and sourceMap", () => {
-            const fs = projFs.shadow();
+            const { fs, tick } = getFsWithTime(projFs);
             const configFile = "src/tsconfig_withFiles.json";
             replaceText(fs, configFile, `"composite": true,`, `"composite": true, "sourceMap": true,`);
-            const host = new fakes.SolutionBuilderHost(fs);
+            const host = fakes.SolutionBuilderHost.create(fs);
             let builder = createSolutionBuilder(host, [configFile], { verbose: true });
             builder.build();
             host.assertDiagnosticMessages(
@@ -88,10 +87,10 @@ export default hello.hello`);
         });
 
         it("with resolveJsonModule and without outDir", () => {
-            const fs = projFs.shadow();
+            const { fs, tick } = getFsWithTime(projFs);
             const configFile = "src/tsconfig_withFiles.json";
             replaceText(fs, configFile, `"outDir": "dist",`, "");
-            const host = new fakes.SolutionBuilderHost(fs);
+            const host = fakes.SolutionBuilderHost.create(fs);
             let builder = createSolutionBuilder(host, [configFile], { verbose: true });
             builder.build();
             host.assertDiagnosticMessages(
@@ -112,10 +111,9 @@ export default hello.hello`);
     });
 
     describe("unittests:: tsbuild:: with resolveJsonModule option on project importJsonFromProjectReference", () => {
-        const { time, tick } = getTime();
         let projFs: vfs.FileSystem;
         before(() => {
-            projFs = loadProjectFromDisk("tests/projects/importJsonFromProjectReference", time);
+            projFs = loadProjectFromDisk("tests/projects/importJsonFromProjectReference");
         });
 
         after(() => {
@@ -124,11 +122,11 @@ export default hello.hello`);
 
         it("when importing json module from project reference", () => {
             const expectedOutput = "/src/main/index.js";
-            const fs = projFs.shadow();
+            const { fs, tick } = getFsWithTime(projFs);
             const configFile = "src/tsconfig.json";
             const stringsConfigFile = "src/strings/tsconfig.json";
             const mainConfigFile = "src/main/tsconfig.json";
-            const host = new fakes.SolutionBuilderHost(fs);
+            const host = fakes.SolutionBuilderHost.create(fs);
             let builder = createSolutionBuilder(host, [configFile], { verbose: true });
             builder.build();
             host.assertDiagnosticMessages(

src/testRunner/unittests/tsbuild/sample.ts

@@ -1,14 +1,13 @@
 namespace ts {
     describe("unittests:: tsbuild:: on 'sample1' project", () => {
         let projFs: vfs.FileSystem;
-        const { time, tick } = getTime();
         const testsOutputs = ["/src/tests/index.js", "/src/tests/index.d.ts", "/src/tests/tsconfig.tsbuildinfo"];
         const logicOutputs = ["/src/logic/index.js", "/src/logic/index.js.map", "/src/logic/index.d.ts", "/src/logic/tsconfig.tsbuildinfo"];
         const coreOutputs = ["/src/core/index.js", "/src/core/index.d.ts", "/src/core/index.d.ts.map", "/src/core/tsconfig.tsbuildinfo"];
         const allExpectedOutputs = [...testsOutputs, ...logicOutputs, ...coreOutputs];
 
         before(() => {
-            projFs = loadProjectFromDisk("tests/projects/sample1", time);
+            projFs = loadProjectFromDisk("tests/projects/sample1");
         });
 
         after(() => {
@@ -18,7 +17,7 @@ namespace ts {
         describe("sanity check of clean build of 'sample1' project", () => {
             it("can build the sample project 'sample1' without error", () => {
                 const fs = projFs.shadow();
-                const host = new fakes.SolutionBuilderHost(fs);
+                const host = fakes.SolutionBuilderHost.create(fs);
                 const builder = createSolutionBuilder(host, ["/src/tests"], { dry: false, force: false, verbose: false });
 
                 host.clearDiagnostics();
@@ -36,7 +35,7 @@ namespace ts {
                     references: [{ path: "../core" }]
                 }));
 
-                const host = new fakes.SolutionBuilderHost(fs);
+                const host = fakes.SolutionBuilderHost.create(fs);
                 const builder = createSolutionBuilder(host, ["/src/tests"], {});
                 builder.build();
                 host.assertDiagnosticMessages(/*empty*/);
@@ -52,7 +51,7 @@ namespace ts {
                     references: [{ path: "../core" }]
                 }));
 
-                const host = new fakes.SolutionBuilderHost(fs);
+                const host = fakes.SolutionBuilderHost.create(fs);
                 const builder = createSolutionBuilder(host, ["/src/tests"], {});
                 builder.build();
                 host.assertDiagnosticMessages(/*empty*/);
@@ -64,7 +63,7 @@ namespace ts {
             it("builds correctly when project is not composite or doesnt have any references", () => {
                 const fs = projFs.shadow();
                 replaceText(fs, "/src/core/tsconfig.json", `"composite": true,`, "");
-                const host = new fakes.SolutionBuilderHost(fs);
+                const host = fakes.SolutionBuilderHost.create(fs);
                 const builder = createSolutionBuilder(host, ["/src/core"], { verbose: true });
                 builder.build();
                 host.assertDiagnosticMessages(
@@ -79,7 +78,7 @@ namespace ts {
         describe("dry builds", () => {
             it("doesn't write any files in a dry build", () => {
                 const fs = projFs.shadow();
-                const host = new fakes.SolutionBuilderHost(fs);
+                const host = fakes.SolutionBuilderHost.create(fs);
                 const builder = createSolutionBuilder(host, ["/src/tests"], { dry: true, force: false, verbose: false });
                 builder.build();
                 host.assertDiagnosticMessages(
@@ -93,8 +92,8 @@ namespace ts {
             });
 
             it("indicates that it would skip builds during a dry build", () => {
-                const fs = projFs.shadow();
-                const host = new fakes.SolutionBuilderHost(fs);
+                const { fs, tick } = getFsWithTime(projFs);
+                const host = fakes.SolutionBuilderHost.create(fs);
 
                 let builder = createSolutionBuilder(host, ["/src/tests"], { dry: false, force: false, verbose: false });
                 builder.build();
@@ -114,7 +113,7 @@ namespace ts {
         describe("clean builds", () => {
             it("removes all files it built", () => {
                 const fs = projFs.shadow();
-                const host = new fakes.SolutionBuilderHost(fs);
+                const host = fakes.SolutionBuilderHost.create(fs);
 
                 const builder = createSolutionBuilder(host, ["/src/tests"], { dry: false, force: false, verbose: false });
                 builder.build();
@@ -136,7 +135,7 @@ namespace ts {
 
             it("cleans till project specified", () => {
                 const fs = projFs.shadow();
-                const host = new fakes.SolutionBuilderHost(fs);
+                const host = fakes.SolutionBuilderHost.create(fs);
                 const builder = createSolutionBuilder(host, ["/src/tests"], {});
                 builder.build();
                 const result = builder.clean("/src/logic");
@@ -148,7 +147,7 @@ namespace ts {
 
             it("cleaning project in not build order doesnt throw error", () => {
                 const fs = projFs.shadow();
-                const host = new fakes.SolutionBuilderHost(fs);
+                const host = fakes.SolutionBuilderHost.create(fs);
                 const builder = createSolutionBuilder(host, ["/src/tests"], {});
                 builder.build();
                 const result = builder.clean("/src/logic2");
@@ -160,8 +159,8 @@ namespace ts {
 
         describe("force builds", () => {
             it("always builds under --force", () => {
-                const fs = projFs.shadow();
-                const host = new fakes.SolutionBuilderHost(fs);
+                const { fs, time, tick } = getFsWithTime(projFs);
+                const host = fakes.SolutionBuilderHost.create(fs);
 
                 let builder = createSolutionBuilder(host, ["/src/tests"], { dry: false, force: true, verbose: false });
                 builder.build();
@@ -187,8 +186,8 @@ namespace ts {
 
         describe("can detect when and what to rebuild", () => {
             function initializeWithBuild(opts?: BuildOptions) {
-                const fs = projFs.shadow();
-                const host = new fakes.SolutionBuilderHost(fs);
+                const { fs, tick } = getFsWithTime(projFs);
+                const host = fakes.SolutionBuilderHost.create(fs);
                 let builder = createSolutionBuilder(host, ["/src/tests"], { verbose: true });
                 builder.build();
                 host.clearDiagnostics();
@@ -199,7 +198,7 @@ namespace ts {
 
             it("Builds the project", () => {
                 const fs = projFs.shadow();
-                const host = new fakes.SolutionBuilderHost(fs);
+                const host = fakes.SolutionBuilderHost.create(fs);
                 const builder = createSolutionBuilder(host, ["/src/tests"], { verbose: true });
                 builder.build();
                 host.assertDiagnosticMessages(
@@ -273,8 +272,8 @@ namespace ts {
             });
 
             it("does not rebuild if there is no program and bundle in the ts build info event if version doesnt match ts version", () => {
-                const fs = projFs.shadow();
-                const host = new fakes.SolutionBuilderHost(fs, /*options*/ undefined, /*setParentNodes*/ undefined, createAbstractBuilder);
+                const { fs, tick } = getFsWithTime(projFs);
+                const host = fakes.SolutionBuilderHost.create(fs, /*options*/ undefined, /*setParentNodes*/ undefined, createAbstractBuilder);
                 let builder = createSolutionBuilder(host, ["/src/tests"], { verbose: true });
                 builder.build();
                 host.assertDiagnosticMessages(
@@ -329,10 +328,10 @@ namespace ts {
             });
 
             it("rebuilds when extended config file changes", () => {
-                const fs = projFs.shadow();
+                const { fs, tick } = getFsWithTime(projFs);
                 fs.writeFileSync("/src/tests/tsconfig.base.json", JSON.stringify({ compilerOptions: { target: "es3" } }));
                 replaceText(fs, "/src/tests/tsconfig.json", `"references": [`, `"extends": "./tsconfig.base.json", "references": [`);
-                const host = new fakes.SolutionBuilderHost(fs);
+                const host = fakes.SolutionBuilderHost.create(fs);
                 let builder = createSolutionBuilder(host, ["/src/tests"], { verbose: true });
                 builder.build();
                 host.assertDiagnosticMessages(
@@ -360,7 +359,7 @@ namespace ts {
 
             it("builds till project specified", () => {
                 const fs = projFs.shadow();
-                const host = new fakes.SolutionBuilderHost(fs);
+                const host = fakes.SolutionBuilderHost.create(fs);
                 const builder = createSolutionBuilder(host, ["/src/tests"], {});
                 const result = builder.build("/src/logic");
                 host.assertDiagnosticMessages(/*empty*/);
@@ -371,7 +370,7 @@ namespace ts {
 
             it("building project in not build order doesnt throw error", () => {
                 const fs = projFs.shadow();
-                const host = new fakes.SolutionBuilderHost(fs);
+                const host = fakes.SolutionBuilderHost.create(fs);
                 const builder = createSolutionBuilder(host, ["/src/tests"], {});
                 const result = builder.build("/src/logic2");
                 host.assertDiagnosticMessages(/*empty*/);
@@ -386,7 +385,7 @@ namespace ts {
                 }
 
                 const fs = projFs.shadow();
-                const host = new fakes.SolutionBuilderHost(fs);
+                const host = fakes.SolutionBuilderHost.create(fs);
                 const builder = createSolutionBuilder(host, ["/src/tests"], {});
                 verifyBuildNextResult({
                     project: "/src/core/tsconfig.json" as ResolvedConfigFileName,
@@ -420,7 +419,7 @@ namespace ts {
 
             it("building using buildReferencedProject", () => {
                 const fs = projFs.shadow();
-                const host = new fakes.SolutionBuilderHost(fs);
+                const host = fakes.SolutionBuilderHost.create(fs);
                 const builder = createSolutionBuilder(host, ["/src/tests"], { verbose: true });
                 builder.buildReferences("/src/tests");
                 host.assertDiagnosticMessages(
@@ -438,7 +437,7 @@ namespace ts {
         describe("downstream-blocked compilations", () => {
             it("won't build downstream projects if upstream projects have errors", () => {
                 const fs = projFs.shadow();
-                const host = new fakes.SolutionBuilderHost(fs);
+                const host = fakes.SolutionBuilderHost.create(fs);
                 const builder = createSolutionBuilder(host, ["/src/tests"], { dry: false, force: false, verbose: true });
 
                 // Induce an error in the middle project
@@ -462,8 +461,8 @@ namespace ts {
 
         describe("project invalidation", () => {
             it("invalidates projects correctly", () => {
-                const fs = projFs.shadow();
-                const host = new fakes.SolutionBuilderHost(fs);
+                const { fs, time, tick } = getFsWithTime(projFs);
+                const host = fakes.SolutionBuilderHost.create(fs);
                 const builder = createSolutionBuilder(host, ["/src/tests"], { dry: false, force: false, verbose: false });
 
                 builder.build();
@@ -518,7 +517,7 @@ export class cNew {}`);
         describe("lists files", () => {
             it("listFiles", () => {
                 const fs = projFs.shadow();
-                const host = new fakes.SolutionBuilderHost(fs);
+                const host = fakes.SolutionBuilderHost.create(fs);
                 const builder = createSolutionBuilder(host, ["/src/tests"], { listFiles: true });
                 builder.build();
                 assert.deepEqual(host.traces, [
@@ -545,7 +544,7 @@ export class cNew {}`);
 
             it("listEmittedFiles", () => {
                 const fs = projFs.shadow();
-                const host = new fakes.SolutionBuilderHost(fs);
+                const host = fakes.SolutionBuilderHost.create(fs);
                 const builder = createSolutionBuilder(host, ["/src/tests"], { listEmittedFiles: true });
                 builder.build();
                 assert.deepEqual(host.traces, [
@@ -568,266 +567,73 @@ export class cNew {}`);
         });
 
         describe("emit output", () => {
-            const initialBuild: BuildState = {
-                modifyFs: noop,
-                expectedDiagnostics: [
-                    getExpectedDiagnosticForProjectsInBuild("src/core/tsconfig.json", "src/logic/tsconfig.json", "src/tests/tsconfig.json"),
-                    [Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist, "src/core/tsconfig.json", "src/core/anotherModule.js"],
-                    [Diagnostics.Building_project_0, "/src/core/tsconfig.json"],
-                    [Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist, "src/logic/tsconfig.json", "src/logic/index.js"],
-                    [Diagnostics.Building_project_0, "/src/logic/tsconfig.json"],
-                    [Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist, "src/tests/tsconfig.json", "src/tests/index.js"],
-                    [Diagnostics.Building_project_0, "/src/tests/tsconfig.json"]
-                ],
-                expectedReadFiles: getReadFilesMap(
-                    [
-                        // Configs
-                        "/src/core/tsconfig.json",
-                        "/src/logic/tsconfig.json",
-                        "/src/tests/tsconfig.json",
-
-                        // Source files
-                        "/src/core/anotherModule.ts",
-                        "/src/core/index.ts",
-                        "/src/core/some_decl.d.ts",
-                        "/src/logic/index.ts",
-                        "/src/tests/index.ts",
-
-                        // Modules of generated files
-                        "/src/core/anotherModule.d.ts",
-                        "/src/core/index.d.ts",
-                        "/src/logic/index.d.ts",
-
-                        // build info
-                        "/src/core/tsconfig.tsbuildinfo",
-                        "/src/logic/tsconfig.tsbuildinfo",
-                        "/src/tests/tsconfig.tsbuildinfo"
-                    ]
-                )
-            };
-            verifyTsbuildOutput({
-                scenario: "sample",
-                projFs: () => projFs,
-                time,
-                tick,
-                proj: "sample1",
-                rootNames: ["/src/tests"],
+            verifyTscIncrementalEdits({
+                subScenario: "sample",
+                fs: () => projFs,
+                scenario: "sample1",
+                commandLineArgs: ["--b", "/src/tests", "--verbose"],
                 baselineSourceMap: true,
-                initialBuild,
-                incrementalDtsChangedBuild: {
-                    modifyFs: fs => appendText(fs, "/src/core/index.ts", `
+                baselineReadFileCalls: true,
+                incrementalScenarios: [
+                    {
+                        buildKind: BuildKind.IncrementalDtsChange,
+                        modifyFs: fs => appendText(fs, "/src/core/index.ts", `
 export class someClass { }`),
-                    expectedDiagnostics: [
-                        // Emits only partial core instead of all outputs
-                        getExpectedDiagnosticForProjectsInBuild("src/core/tsconfig.json", "src/logic/tsconfig.json", "src/tests/tsconfig.json"),
-                        [Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, "src/core/tsconfig.json", "src/core/anotherModule.js", "src/core/index.ts"],
-                        [Diagnostics.Building_project_0, "/src/core/tsconfig.json"],
-                        [Diagnostics.Updating_unchanged_output_timestamps_of_project_0, "/src/core/tsconfig.json"],
-                        [Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, "src/logic/tsconfig.json", "src/logic/index.js", "src/core"],
-                        [Diagnostics.Building_project_0, "/src/logic/tsconfig.json"],
-                        [Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, "src/tests/tsconfig.json", "src/tests/index.js", "src/core"],
-                        [Diagnostics.Building_project_0, "/src/tests/tsconfig.json"],
-                    ],
-                    expectedReadFiles: getReadFilesMap(
-                        [
-                            // Configs
-                            "/src/core/tsconfig.json",
-                            "/src/logic/tsconfig.json",
-                            "/src/tests/tsconfig.json",
-
-                            // Source files
-                            "/src/core/anotherModule.ts",
-                            "/src/core/index.ts",
-                            "/src/core/some_decl.d.ts",
-                            "/src/logic/index.ts",
-                            "/src/tests/index.ts",
-
-                            // Modules of generated files
-                            "/src/core/anotherModule.d.ts",
-                            "/src/core/index.d.ts",
-                            "/src/logic/index.d.ts",
-
-                            // build info
-                            "/src/core/tsconfig.tsbuildinfo",
-                            "/src/logic/tsconfig.tsbuildinfo",
-                            "/src/tests/tsconfig.tsbuildinfo",
-
-                            "/src/tests/index.d.ts", // to check if d.ts has changed
-                        ],
-                        "/src/core/index.d.ts", // to check if changed, and to build other projects after change
-                    ),
-                },
-                incrementalDtsUnchangedBuild: {
-                    modifyFs: fs => appendText(fs, "/src/core/index.ts", `
+                    },
+                    {
+                        buildKind: BuildKind.IncrementalDtsUnchanged,
+                        modifyFs: fs => appendText(fs, "/src/core/index.ts", `
 class someClass { }`),
-                    expectedDiagnostics: [
-                        getExpectedDiagnosticForProjectsInBuild("src/core/tsconfig.json", "src/logic/tsconfig.json", "src/tests/tsconfig.json"),
-                        [Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, "src/core/tsconfig.json", "src/core/anotherModule.js", "src/core/index.ts"],
-                        [Diagnostics.Building_project_0, "/src/core/tsconfig.json"],
-                        [Diagnostics.Updating_unchanged_output_timestamps_of_project_0, "/src/core/tsconfig.json"],
-                        [Diagnostics.Project_0_is_up_to_date_with_d_ts_files_from_its_dependencies, "src/logic/tsconfig.json"],
-                        [Diagnostics.Updating_output_timestamps_of_project_0, "/src/logic/tsconfig.json"],
-                        [Diagnostics.Project_0_is_up_to_date_with_d_ts_files_from_its_dependencies, "src/tests/tsconfig.json"],
-                        [Diagnostics.Updating_output_timestamps_of_project_0, "/src/tests/tsconfig.json"]
-                    ],
-                    expectedReadFiles: getReadFilesMap(
-                        [
-                            // Configs
-                            "/src/core/tsconfig.json",
-                            "/src/logic/tsconfig.json",
-                            "/src/tests/tsconfig.json",
-
-                            // Source files
-                            "/src/core/anotherModule.ts",
-                            "/src/core/index.ts",
-                            "/src/core/some_decl.d.ts",
-
-                            // to check if changed
-                            "/src/core/index.d.ts",
-
-                            // build info
-                            "/src/core/tsconfig.tsbuildinfo",
-                            "/src/logic/tsconfig.tsbuildinfo",
-                            "/src/tests/tsconfig.tsbuildinfo",
-                        ],
-                    )
-                },
-            });
-
-            verifyTsbuildOutput({
-                scenario: "when logic config changes declaration dir",
-                projFs: () => projFs,
-                time,
-                tick,
-                proj: "sample1",
-                rootNames: ["/src/tests"],
-                baselineSourceMap: true,
-                initialBuild,
-                incrementalDtsChangedBuild: {
-                    modifyFs: fs => replaceText(fs, "/src/logic/tsconfig.json", `"declaration": true,`, `"declaration": true,
+                    },
+                    {
+                        subScenario: "when logic config changes declaration dir",
+                        buildKind: BuildKind.IncrementalDtsChange,
+                        modifyFs: fs => replaceText(fs, "/src/logic/tsconfig.json", `"declaration": true,`, `"declaration": true,
         "declarationDir": "decls",`),
-                    expectedDiagnostics: [
-                        getExpectedDiagnosticForProjectsInBuild("src/core/tsconfig.json", "src/logic/tsconfig.json", "src/tests/tsconfig.json"),
-                        [Diagnostics.Project_0_is_up_to_date_because_newest_input_1_is_older_than_oldest_output_2, "src/core/tsconfig.json", "src/core/anotherModule.ts", "src/core/anotherModule.js"],
-                        [Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist, "src/logic/tsconfig.json", "src/logic/decls/index.d.ts"],
-                        [Diagnostics.Building_project_0, "/src/logic/tsconfig.json"],
-                        [Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, "src/tests/tsconfig.json", "src/tests/index.js", "src/logic"],
-                        [Diagnostics.Building_project_0, "/src/tests/tsconfig.json"],
-                    ],
-                    expectedReadFiles: getReadFilesMap(
-                        [
-                            // Configs
-                            "/src/core/tsconfig.json",
-                            "/src/logic/tsconfig.json",
-                            "/src/tests/tsconfig.json",
-
-                            // Source files
-                            "/src/logic/index.ts",
-                            "/src/tests/index.ts",
-
-                            // Modules of generated files
-                            "/src/core/anotherModule.d.ts",
-                            "/src/core/index.d.ts",
-                            "/src/logic/decls/index.d.ts",
-
-                            // build info
-                            "/src/core/tsconfig.tsbuildinfo",
-                            "/src/logic/tsconfig.tsbuildinfo",
-                            "/src/tests/tsconfig.tsbuildinfo",
-
-                            "/src/tests/index.d.ts", // to check if d.ts has changed
-                        ]
-                    )
-                },
+                    }
+                ],
             });
 
-            verifyTsbuildOutput({
-                scenario: "when logic specifies tsBuildInfoFile",
-                projFs: () => projFs,
-                time,
-                tick,
-                proj: "sample1",
-                rootNames: ["/src/tests"],
-                baselineSourceMap: true,
-                initialBuild: {
-                    modifyFs: fs => replaceText(fs, "/src/logic/tsconfig.json", `"composite": true,`, `"composite": true,
+            verifyTsc({
+                scenario: "sample1",
+                subScenario: "when logic specifies tsBuildInfoFile",
+                fs: () => projFs,
+                modifyFs: fs => replaceText(fs, "/src/logic/tsconfig.json", `"composite": true,`, `"composite": true,
         "tsBuildInfoFile": "ownFile.tsbuildinfo",`),
-                    expectedDiagnostics: initialBuild.expectedDiagnostics,
-                    expectedReadFiles: getReadFilesMap(
-                        [
-                            // Configs
-                            "/src/core/tsconfig.json",
-                            "/src/logic/tsconfig.json",
-                            "/src/tests/tsconfig.json",
-
-                            // Source files
-                            "/src/core/anotherModule.ts",
-                            "/src/core/index.ts",
-                            "/src/core/some_decl.d.ts",
-                            "/src/logic/index.ts",
-                            "/src/tests/index.ts",
-
-                            // Modules of generated files
-                            "/src/core/anotherModule.d.ts",
-                            "/src/core/index.d.ts",
-                            "/src/logic/index.d.ts",
-
-                            // build info
-                            "/src/core/tsconfig.tsbuildinfo",
-                            "/src/logic/ownFile.tsbuildinfo",
-                            "/src/tests/tsconfig.tsbuildinfo"
-                        ]
-                    )
-                },
+                commandLineArgs: ["--b", "/src/tests", "--verbose"],
+                baselineSourceMap: true,
+                baselineReadFileCalls: true
             });
 
-            verifyTsbuildOutput({
-                scenario: "when declaration option changes",
-                projFs: () => projFs,
-                time,
-                tick,
-                proj: "sample1",
-                rootNames: ["/src/core"],
-                initialBuild: {
-                    modifyFs: fs => fs.writeFileSync("/src/core/tsconfig.json", `{
+            verifyTscIncrementalEdits({
+                subScenario: "when declaration option changes",
+                fs: () => projFs,
+                scenario: "sample1",
+                commandLineArgs: ["--b", "/src/core", "--verbose"],
+                modifyFs: fs => fs.writeFileSync("/src/core/tsconfig.json", `{
     "compilerOptions": {
         "incremental": true,
         "skipDefaultLibCheck": true
     }
 }`),
-                    expectedDiagnostics: [
-                        getExpectedDiagnosticForProjectsInBuild("src/core/tsconfig.json"),
-                        [Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist, "src/core/tsconfig.json", "src/core/anotherModule.js"],
-                        [Diagnostics.Building_project_0, "/src/core/tsconfig.json"],
-                    ]
-                },
-                incrementalDtsChangedBuild: {
+                incrementalScenarios: [{
+                    buildKind: BuildKind.IncrementalDtsChange,
                     modifyFs: fs => replaceText(fs, "/src/core/tsconfig.json", `"incremental": true,`, `"incremental": true, "declaration": true,`),
-                    expectedDiagnostics: [
-                        getExpectedDiagnosticForProjectsInBuild("src/core/tsconfig.json"),
-                        [Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist, "src/core/tsconfig.json", "src/core/anotherModule.d.ts"],
-                        [Diagnostics.Building_project_0, "/src/core/tsconfig.json"]
-                    ]
-                },
-                baselineOnly: true,
-                verifyDiagnostics: true
+                }],
             });
 
-            verifyTsbuildOutput({
-                scenario: "when target option changes",
-                projFs: () => projFs,
-                time,
-                tick,
-                proj: "sample1",
-                rootNames: ["/src/core"],
-                initialBuild: {
-                    modifyFs: fs => {
-                        fs.writeFileSync("/lib/lib.esnext.full.d.ts", `/// <reference no-default-lib="true"/>
+            verifyTscIncrementalEdits({
+                subScenario: "when target option changes",
+                fs: () => projFs,
+                scenario: "sample1",
+                commandLineArgs: ["--b", "/src/core", "--verbose"],
+                modifyFs: fs => {
+                    fs.writeFileSync("/lib/lib.esnext.full.d.ts", `/// <reference no-default-lib="true"/>
 /// <reference lib="esnext" />`);
-                        fs.writeFileSync("/lib/lib.esnext.d.ts", libContent);
-                        fs.writeFileSync("/lib/lib.d.ts", `/// <reference no-default-lib="true"/>
+                    fs.writeFileSync("/lib/lib.esnext.d.ts", libContent);
+                    fs.writeFileSync("/lib/lib.d.ts", `/// <reference no-default-lib="true"/>
 /// <reference lib="esnext" />`);
-                        fs.writeFileSync("/src/core/tsconfig.json", `{
+                    fs.writeFileSync("/src/core/tsconfig.json", `{
     "compilerOptions": {
         "incremental": true,
 "listFiles": true,
@@ -835,66 +641,36 @@ class someClass { }`),
         "target": "esnext",
     }
 }`);
-                    },
-                    expectedDiagnostics: [
-                        getExpectedDiagnosticForProjectsInBuild("src/core/tsconfig.json"),
-                        [Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist, "src/core/tsconfig.json", "src/core/anotherModule.js"],
-                        [Diagnostics.Building_project_0, "/src/core/tsconfig.json"],
-                    ]
                 },
-                incrementalDtsChangedBuild: {
+                incrementalScenarios: [{
+                    buildKind: BuildKind.IncrementalDtsChange,
                     modifyFs: fs => replaceText(fs, "/src/core/tsconfig.json", "esnext", "es5"),
-                    expectedDiagnostics: [
-                        getExpectedDiagnosticForProjectsInBuild("src/core/tsconfig.json"),
-                        [Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, "src/core/tsconfig.json", "src/core/anotherModule.js", "src/core/tsconfig.json"],
-                        [Diagnostics.Building_project_0, "/src/core/tsconfig.json"]
-                    ]
-                },
-                baselineOnly: true,
-                verifyDiagnostics: true
+                }],
             });
 
-            verifyTsbuildOutput({
-                scenario: "when module option changes",
-                projFs: () => projFs,
-                time,
-                tick,
-                proj: "sample1",
-                rootNames: ["/src/core"],
-                initialBuild: {
-                    modifyFs: fs => fs.writeFileSync("/src/core/tsconfig.json", `{
+            verifyTscIncrementalEdits({
+                subScenario: "when module option changes",
+                fs: () => projFs,
+                scenario: "sample1",
+                commandLineArgs: ["--b", "/src/core", "--verbose"],
+                modifyFs: fs => fs.writeFileSync("/src/core/tsconfig.json", `{
     "compilerOptions": {
         "incremental": true,
         "module": "commonjs"
     }
 }`),
-                    expectedDiagnostics: [
-                        getExpectedDiagnosticForProjectsInBuild("src/core/tsconfig.json"),
-                        [Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist, "src/core/tsconfig.json", "src/core/anotherModule.js"],
-                        [Diagnostics.Building_project_0, "/src/core/tsconfig.json"],
-                    ]
-                },
-                incrementalDtsChangedBuild: {
+                incrementalScenarios: [{
+                    buildKind: BuildKind.IncrementalDtsChange,
                     modifyFs: fs => replaceText(fs, "/src/core/tsconfig.json", `"module": "commonjs"`, `"module": "amd"`),
-                    expectedDiagnostics: [
-                        getExpectedDiagnosticForProjectsInBuild("src/core/tsconfig.json"),
-                        [Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, "src/core/tsconfig.json", "src/core/anotherModule.js", "src/core/tsconfig.json"],
-                        [Diagnostics.Building_project_0, "/src/core/tsconfig.json"]
-                    ]
-                },
-                baselineOnly: true,
-                verifyDiagnostics: true
+                }],
             });
 
-            verifyTsbuildOutput({
-                scenario: "when esModuleInterop option changes",
-                projFs: () => projFs,
-                time,
-                tick,
-                proj: "sample1",
-                rootNames: ["/src/tests"],
-                initialBuild: {
-                    modifyFs: fs => fs.writeFileSync("/src/tests/tsconfig.json", `{
+            verifyTscIncrementalEdits({
+                subScenario: "when esModuleInterop option changes",
+                fs: () => projFs,
+                scenario: "sample1",
+                commandLineArgs: ["--b", "/src/tests", "--verbose"],
+                modifyFs: fs => fs.writeFileSync("/src/tests/tsconfig.json", `{
     "references": [
         { "path": "../core" },
         { "path": "../logic" }
@@ -908,28 +684,10 @@ class someClass { }`),
         "esModuleInterop": false
     }
 }`),
-                    expectedDiagnostics: [
-                        getExpectedDiagnosticForProjectsInBuild("src/core/tsconfig.json", "src/logic/tsconfig.json", "src/tests/tsconfig.json"),
-                        [Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist, "src/core/tsconfig.json", "src/core/anotherModule.js"],
-                        [Diagnostics.Building_project_0, "/src/core/tsconfig.json"],
-                        [Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist, "src/logic/tsconfig.json", "src/logic/index.js"],
-                        [Diagnostics.Building_project_0, "/src/logic/tsconfig.json"],
-                        [Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist, "src/tests/tsconfig.json", "src/tests/index.js"],
-                        [Diagnostics.Building_project_0, "/src/tests/tsconfig.json"]
-                    ]
-                },
-                incrementalDtsChangedBuild: {
+                incrementalScenarios: [{
+                    buildKind: BuildKind.IncrementalDtsChange,
                     modifyFs: fs => replaceText(fs, "/src/tests/tsconfig.json", `"esModuleInterop": false`, `"esModuleInterop": true`),
-                    expectedDiagnostics: [
-                        getExpectedDiagnosticForProjectsInBuild("src/core/tsconfig.json", "src/logic/tsconfig.json", "src/tests/tsconfig.json"),
-                        [Diagnostics.Project_0_is_up_to_date_because_newest_input_1_is_older_than_oldest_output_2, "src/core/tsconfig.json", "src/core/anotherModule.ts", "src/core/anotherModule.js"],
-                        [Diagnostics.Project_0_is_up_to_date_because_newest_input_1_is_older_than_oldest_output_2, "src/logic/tsconfig.json", "src/logic/index.ts", "src/logic/index.js"],
-                        [Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, "src/tests/tsconfig.json", "src/tests/index.js", "src/tests/tsconfig.json"],
-                        [Diagnostics.Building_project_0, "/src/tests/tsconfig.json"]
-                    ]
-                },
-                baselineOnly: true,
-                verifyDiagnostics: true
+                }],
             });
         });
     });

src/testRunner/unittests/tsbuild/transitiveReferences.ts

@@ -27,7 +27,7 @@ namespace ts {
 
         function verifyBuild(modifyDiskLayout: (fs: vfs.FileSystem) => void, allExpectedOutputs: readonly string[], expectedFileTraces: readonly string[], ...expectedDiagnostics: fakes.ExpectedDiagnostic[]) {
             const fs = projFs.shadow();
-            const host = new fakes.SolutionBuilderHost(fs);
+            const host = fakes.SolutionBuilderHost.create(fs);
             modifyDiskLayout(fs);
             const builder = createSolutionBuilder(host, ["/src/tsconfig.c.json"], { listFiles: true });
             builder.build();

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),
+                            });
                         });
                     }
 

src/testRunner/unittests/tsc/declarationEmit.ts

@@ -0,0 +1,136 @@
+namespace ts {
+    describe("unittests:: tsc:: declarationEmit::", () => {
+        verifyTsc({
+            scenario: "declarationEmit",
+            subScenario: "when same version is referenced through source and another symlinked package",
+            fs: () => {
+                const fsaPackageJson = utils.dedent`
+                    {
+                        "name": "typescript-fsa",
+                        "version": "3.0.0-beta-2"
+                    }`;
+                const fsaIndex = utils.dedent`
+                    export interface Action<Payload> {
+                        type: string;
+                        payload: Payload;
+                    }
+                    export declare type ActionCreator<Payload> = {
+                        type: string;
+                        (payload: Payload): Action<Payload>;
+                    }
+                    export interface ActionCreatorFactory {
+                        <Payload = void>(type: string): ActionCreator<Payload>;
+                    }
+                    export declare function actionCreatorFactory(prefix?: string | null): ActionCreatorFactory;
+                    export default actionCreatorFactory;`;
+                return loadProjectFromFiles({
+                    "/src/plugin-two/index.d.ts": utils.dedent`
+                        declare const _default: {
+                            features: {
+                                featureOne: {
+                                    actions: {
+                                        featureOne: {
+                                            (payload: {
+                                                name: string;
+                                                order: number;
+                                            }, meta?: {
+                                                [key: string]: any;
+                                            }): import("typescript-fsa").Action<{
+                                                name: string;
+                                                order: number;
+                                            }>;
+                                        };
+                                    };
+                                    path: string;
+                                };
+                            };
+                        };
+                        export default _default;`,
+                    "/src/plugin-two/node_modules/typescript-fsa/package.json": fsaPackageJson,
+                    "/src/plugin-two/node_modules/typescript-fsa/index.d.ts": fsaIndex,
+                    "/src/plugin-one/tsconfig.json": utils.dedent`
+                        {
+                            "compilerOptions": {
+                                "target": "es5",
+                                "declaration": true,
+                            },
+                        }`,
+                    "/src/plugin-one/index.ts": utils.dedent`
+                        import pluginTwo from "plugin-two"; // include this to add reference to symlink`,
+                    "/src/plugin-one/action.ts": utils.dedent`
+                        import { actionCreatorFactory } from "typescript-fsa"; // Include version of shared lib
+                        const action = actionCreatorFactory("somekey");
+                        const featureOne = action<{ route: string }>("feature-one");
+                        export const actions = { featureOne };`,
+                    "/src/plugin-one/node_modules/typescript-fsa/package.json": fsaPackageJson,
+                    "/src/plugin-one/node_modules/typescript-fsa/index.d.ts": fsaIndex,
+                    "/src/plugin-one/node_modules/plugin-two": new vfs.Symlink("/src/plugin-two"),
+                });
+            },
+            commandLineArgs: ["-p", "src/plugin-one", "--listFiles"]
+        });
+
+        verifyTsc({
+            scenario: "declarationEmit",
+            subScenario: "when pkg references sibling package through indirect symlink",
+            fs: () => loadProjectFromFiles({
+                "/src/pkg1/dist/index.d.ts": utils.dedent`
+                        export * from './types';`,
+                "/src/pkg1/dist/types.d.ts": utils.dedent`
+                        export declare type A = {
+                            id: string;
+                        };
+                        export declare type B = {
+                            id: number;
+                        };
+                        export declare type IdType = A | B;
+                        export declare class MetadataAccessor<T, D extends IdType = IdType> {
+                            readonly key: string;
+                            private constructor();
+                            toString(): string;
+                            static create<T, D extends IdType = IdType>(key: string): MetadataAccessor<T, D>;
+                        }`,
+                "/src/pkg1/package.json": utils.dedent`
+                        {
+                            "name": "@raymondfeng/pkg1",
+                            "version": "1.0.0",
+                            "description": "",
+                            "main": "dist/index.js",
+                            "typings": "dist/index.d.ts"
+                        }`,
+                "/src/pkg2/dist/index.d.ts": utils.dedent`
+                        export * from './types';`,
+                "/src/pkg2/dist/types.d.ts": utils.dedent`
+                        export {MetadataAccessor} from '@raymondfeng/pkg1';`,
+                "/src/pkg2/package.json": utils.dedent`
+                        {
+                            "name": "@raymondfeng/pkg2",
+                            "version": "1.0.0",
+                            "description": "",
+                            "main": "dist/index.js",
+                            "typings": "dist/index.d.ts"
+                        }`,
+                "/src/pkg3/src/index.ts": utils.dedent`
+                        export * from './keys';`,
+                "/src/pkg3/src/keys.ts": utils.dedent`
+                        import {MetadataAccessor} from "@raymondfeng/pkg2";
+                        export const ADMIN = MetadataAccessor.create<boolean>('1');`,
+                "/src/pkg3/tsconfig.json": utils.dedent`
+                        {
+                            "compilerOptions": {
+                              "outDir": "dist",
+                              "rootDir": "src",
+                              "target": "es5",
+                              "module": "commonjs",
+                              "strict": true,
+                              "esModuleInterop": true,
+                              "declaration": true
+                            }
+                        }`,
+                "/src/pkg2/node_modules/@raymondfeng/pkg1": new vfs.Symlink("/src/pkg1"),
+                "/src/pkg3/node_modules/@raymondfeng/pkg2": new vfs.Symlink("/src/pkg2"),
+            }),
+            commandLineArgs: ["-p", "src/pkg3", "--listFiles"]
+        });
+    });
+}

src/testRunner/unittests/tsc/helpers.ts

@@ -0,0 +1,243 @@
+namespace ts {
+    export type TscCompileSystem = fakes.System & {
+        writtenFiles: Map<true>;
+        baseLine(): void;
+    };
+    function executeCommandLine(sys: TscCompileSystem, commandLineArgs: readonly string[]) {
+        if (isBuild(commandLineArgs)) {
+            return performBuild(sys, commandLineArgs.slice(1));
+        }
+
+        const reportDiagnostic = createDiagnosticReporter(sys);
+        const commandLine = parseCommandLine(commandLineArgs, path => sys.readFile(path));
+        if (commandLine.options.build) {
+            reportDiagnostic(createCompilerDiagnostic(Diagnostics.Option_build_must_be_the_first_command_line_argument));
+            return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
+        }
+
+        if (commandLine.errors.length > 0) {
+            commandLine.errors.forEach(reportDiagnostic);
+            return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
+        }
+
+        let configFileName: string | undefined;
+        if (commandLine.options.project) {
+            if (commandLine.fileNames.length !== 0) {
+                reportDiagnostic(createCompilerDiagnostic(Diagnostics.Option_project_cannot_be_mixed_with_source_files_on_a_command_line));
+                return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
+            }
+
+            const fileOrDirectory = normalizePath(commandLine.options.project);
+            if (!fileOrDirectory /* current directory "." */ || sys.directoryExists(fileOrDirectory)) {
+                configFileName = combinePaths(fileOrDirectory, "tsconfig.json");
+                if (!sys.fileExists(configFileName)) {
+                    reportDiagnostic(createCompilerDiagnostic(Diagnostics.Cannot_find_a_tsconfig_json_file_at_the_specified_directory_Colon_0, commandLine.options.project));
+                    return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
+                }
+            }
+            else {
+                configFileName = fileOrDirectory;
+                if (!sys.fileExists(configFileName)) {
+                    reportDiagnostic(createCompilerDiagnostic(Diagnostics.The_specified_path_does_not_exist_Colon_0, commandLine.options.project));
+                    return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
+                }
+            }
+        }
+        else if (commandLine.fileNames.length === 0) {
+            const searchPath = normalizePath(sys.getCurrentDirectory());
+            configFileName = findConfigFile(searchPath, sys.fileExists);
+        }
+
+        Debug.assert(commandLine.fileNames.length !== 0 || !!configFileName);
+
+        if (configFileName) {
+            const configParseResult = Debug.assertDefined(parseConfigFileWithSystem(configFileName, commandLine.options, sys, reportDiagnostic));
+            if (isIncrementalCompilation(configParseResult.options)) {
+                performIncrementalCompilation(sys, configParseResult);
+            }
+            else {
+                performCompilation(sys, configParseResult);
+            }
+        }
+        else {
+            if (isIncrementalCompilation(commandLine.options)) {
+                performIncrementalCompilation(sys, commandLine);
+            }
+            else {
+                performCompilation(sys, commandLine);
+            }
+        }
+    }
+
+    function createReportErrorSummary(sys: TscCompileSystem, options: CompilerOptions): ReportEmitErrorSummary | undefined {
+        return options.pretty ?
+            errorCount => sys.write(getErrorSummaryText(errorCount, sys.newLine)) :
+            undefined;
+    }
+
+    function performCompilation(sys: TscCompileSystem, config: ParsedCommandLine) {
+        const { fileNames, options, projectReferences } = config;
+        const reportDiagnostic = createDiagnosticReporter(sys, options.pretty);
+        const host = createCompilerHostWorker(options, /*setParentPos*/ undefined, sys);
+        const currentDirectory = host.getCurrentDirectory();
+        const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames());
+        changeCompilerHostLikeToUseCache(host, fileName => toPath(fileName, currentDirectory, getCanonicalFileName));
+        const program = createProgram({
+            rootNames: fileNames,
+            options,
+            projectReferences,
+            host,
+            configFileParsingDiagnostics: getConfigFileParsingDiagnostics(config)
+        });
+        const exitStatus = emitFilesAndReportErrorsAndGetExitStatus(
+            program,
+            reportDiagnostic,
+            s => sys.write(s + sys.newLine),
+            createReportErrorSummary(sys, options)
+        );
+        baselineBuildInfo([config], sys.vfs, sys.writtenFiles);
+        return sys.exit(exitStatus);
+    }
+
+    function performIncrementalCompilation(sys: TscCompileSystem, config: ParsedCommandLine) {
+        const reportDiagnostic = createDiagnosticReporter(sys, config.options.pretty);
+        const { options, fileNames, projectReferences } = config;
+        const exitCode = ts.performIncrementalCompilation({
+            system: sys,
+            rootNames: fileNames,
+            options,
+            configFileParsingDiagnostics: getConfigFileParsingDiagnostics(config),
+            projectReferences,
+            reportDiagnostic,
+            reportErrorSummary: createReportErrorSummary(sys, options),
+        });
+        baselineBuildInfo([config], sys.vfs, sys.writtenFiles);
+        return sys.exit(exitCode);
+    }
+
+    function performBuild(sys: TscCompileSystem, args: string[]) {
+        const { buildOptions, projects, errors } = parseBuildCommand(args);
+        const reportDiagnostic = createDiagnosticReporter(sys, buildOptions.pretty);
+
+        if (errors.length > 0) {
+            errors.forEach(reportDiagnostic);
+            return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
+        }
+
+        Debug.assert(projects.length !== 0);
+
+        const buildHost = createSolutionBuilderHost(
+            sys,
+            /*createProgram*/ undefined,
+            reportDiagnostic,
+            createBuilderStatusReporter(sys, buildOptions.pretty),
+            createReportErrorSummary(sys, buildOptions)
+        );
+        fakes.patchSolutionBuilderHost(buildHost, sys);
+        const builder = createSolutionBuilder(buildHost, projects, buildOptions);
+        const exitCode = buildOptions.clean ? builder.clean() : builder.build();
+        baselineBuildInfo(builder.getAllParsedConfigs(), sys.vfs, sys.writtenFiles);
+        return sys.exit(exitCode);
+    }
+
+    function isBuild(commandLineArgs: readonly string[]) {
+        if (commandLineArgs.length > 0 && commandLineArgs[0].charCodeAt(0) === CharacterCodes.minus) {
+            const firstOption = commandLineArgs[0].slice(commandLineArgs[0].charCodeAt(1) === CharacterCodes.minus ? 2 : 1).toLowerCase();
+            return firstOption === "build" || firstOption === "b";
+        }
+        return false;
+    }
+
+    export enum BuildKind {
+        Initial = "initial-build",
+        IncrementalDtsChange = "incremental-declaration-changes",
+        IncrementalDtsUnchanged = "incremental-declaration-doesnt-change",
+        IncrementalHeadersChange = "incremental-headers-change-without-dts-changes"
+    }
+
+    export interface TscCompile {
+        scenario: string;
+        subScenario: string;
+        buildKind?: BuildKind; // Should be defined for tsc --b
+        fs: () => vfs.FileSystem;
+        commandLineArgs: readonly string[];
+
+        modifyFs?: (fs: vfs.FileSystem) => void;
+        baselineSourceMap?: boolean;
+        baselineReadFileCalls?: boolean;
+    }
+
+    export function tscCompile(input: TscCompile) {
+        const baseFs = input.fs();
+        const fs = baseFs.shadow();
+        const {
+            scenario, subScenario, buildKind,
+            commandLineArgs, modifyFs,
+            baselineSourceMap, baselineReadFileCalls
+        } = input;
+        if (modifyFs) modifyFs(fs);
+
+        // Create system
+        const sys = new fakes.System(fs, { executingFilePath: "/lib/tsc" }) as TscCompileSystem;
+        const writtenFiles = sys.writtenFiles = createMap<true>();
+        const originalWriteFile = sys.writeFile;
+        sys.writeFile = (fileName, content, writeByteOrderMark) => {
+            assert.isFalse(writtenFiles.has(fileName));
+            writtenFiles.set(fileName, true);
+            return originalWriteFile.call(sys, fileName, content, writeByteOrderMark);
+        };
+        const actualReadFileMap: MapLike<number> = {};
+        const originalReadFile = sys.readFile;
+        sys.readFile = path => {
+            // Dont record libs
+            if (path.startsWith("/src/")) {
+                actualReadFileMap[path] = (getProperty(actualReadFileMap, path) || 0) + 1;
+            }
+            return originalReadFile.call(sys, path);
+        };
+
+        sys.write(`${sys.getExecutingFilePath()} ${commandLineArgs.join(" ")}\n`);
+        sys.exit = exitCode => sys.exitCode = exitCode;
+        executeCommandLine(sys, commandLineArgs);
+        sys.write(`exitCode:: ${sys.exitCode}\n`);
+        if (baselineReadFileCalls) {
+            sys.write(`readFiles:: ${JSON.stringify(actualReadFileMap, /*replacer*/ undefined, " ")} `);
+        }
+        if (baselineSourceMap) generateSourceMapBaselineFiles(fs, mapDefinedIterator(writtenFiles.keys(), f => f.endsWith(".map") ? f : undefined));
+
+        // Baseline the errors
+        fs.writeFileSync(`/lib/${buildKind || BuildKind.Initial}Output.txt`, sys.output.join(""));
+        fs.makeReadonly();
+
+        sys.baseLine = () => {
+            const patch = fs.diff(baseFs, { includeChangedFileWithSameContent: true });
+            // eslint-disable-next-line no-null/no-null
+            Harness.Baseline.runBaseline(`${isBuild(commandLineArgs) ? "tsbuild" : "tsc"}/${scenario}/${buildKind || BuildKind.Initial}/${subScenario.split(" ").join("-")}.js`, patch ? vfs.formatPatch(patch) : null);
+        };
+        return sys;
+    }
+
+    export function verifyTscBaseline(sys: () => TscCompileSystem) {
+        it(`Generates files matching the baseline`, () => {
+            sys().baseLine();
+        });
+    }
+
+    export function verifyTsc(input: TscCompile) {
+        describe(input.scenario, () => {
+            describe(input.subScenario, () => {
+                let sys: TscCompileSystem;
+                before(() => {
+                    sys = tscCompile({
+                        ...input,
+                        fs: () => getFsWithTime(input.fs()).fs.makeReadonly()
+                    });
+                });
+                after(() => {
+                    sys = undefined!;
+                });
+                verifyTscBaseline(() => sys);
+            });
+        });
+    }
+}

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
-                        })
                     ],
                 }
             ]);

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 ", () => {

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);

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(),
+                ]
+            });
+        });
+    });
+}

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
+            });
+        });
+    });
+}

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 {
@@ -1957,6 +1967,7 @@ declare namespace ts {
         getReturnTypeOfSignature(signature: Signature): Type;
         getNullableType(type: Type, flags: TypeFlags): Type;
         getNonNullableType(type: Type): Type;
+        getTypeArguments(type: TypeReference): readonly Type[];
         /** Note that the resulting nodes cannot be checked. */
         typeToTypeNode(type: Type, enclosingDeclaration?: Node, flags?: NodeBuilderFlags): TypeNode | undefined;
         /** Note that the resulting nodes cannot be checked. */
@@ -2098,21 +2109,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 +2369,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[];
@@ -2360,7 +2389,9 @@ declare namespace ts {
      */
     export interface TypeReference extends ObjectType {
         target: GenericType;
-        typeArguments?: readonly Type[];
+        node?: TypeReferenceNode | ArrayTypeNode | TupleTypeNode;
+    }
+    export interface DeferredTypeReference extends TypeReference {
     }
     export interface GenericType extends InterfaceType, TypeReference {
     }
@@ -2539,6 +2570,7 @@ declare namespace ts {
         emitDeclarationOnly?: boolean;
         declarationDir?: string;
         disableSizeLimit?: boolean;
+        disableSourceOfProjectReferenceRedirect?: boolean;
         downlevelIteration?: boolean;
         emitBOM?: boolean;
         emitDecoratorMetadata?: boolean;
@@ -3845,7 +3877,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 +8533,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 +8613,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.

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 {
@@ -1957,6 +1967,7 @@ declare namespace ts {
         getReturnTypeOfSignature(signature: Signature): Type;
         getNullableType(type: Type, flags: TypeFlags): Type;
         getNonNullableType(type: Type): Type;
+        getTypeArguments(type: TypeReference): readonly Type[];
         /** Note that the resulting nodes cannot be checked. */
         typeToTypeNode(type: Type, enclosingDeclaration?: Node, flags?: NodeBuilderFlags): TypeNode | undefined;
         /** Note that the resulting nodes cannot be checked. */
@@ -2098,21 +2109,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 +2369,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[];
@@ -2360,7 +2389,9 @@ declare namespace ts {
      */
     export interface TypeReference extends ObjectType {
         target: GenericType;
-        typeArguments?: readonly Type[];
+        node?: TypeReferenceNode | ArrayTypeNode | TupleTypeNode;
+    }
+    export interface DeferredTypeReference extends TypeReference {
     }
     export interface GenericType extends InterfaceType, TypeReference {
     }
@@ -2539,6 +2570,7 @@ declare namespace ts {
         emitDeclarationOnly?: boolean;
         declarationDir?: string;
         disableSizeLimit?: boolean;
+        disableSourceOfProjectReferenceRedirect?: boolean;
         downlevelIteration?: boolean;
         emitBOM?: boolean;
         emitDecoratorMetadata?: boolean;
@@ -3845,7 +3877,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;

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'.
     

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'.
     

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.
+    }
+    

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);
+}

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))
+}
+

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
+}
+

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.
+    }
+    

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))
+}
+

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
+}
+

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;

tests/baselines/reference/asyncAliasReturnType_es5.types

@@ -1,7 +1,7 @@
 === tests/cases/conformance/async/es5/asyncAliasReturnType_es5.ts ===
 type PromiseAlias<T> = Promise<T>;
->PromiseAlias : Promise<T>
+>PromiseAlias : PromiseAlias<T>
 
 async function f(): PromiseAlias<void> {
->f : () => Promise<void>
+>f : () => PromiseAlias<void>
 }

tests/baselines/reference/asyncAliasReturnType_es6.types

@@ -1,7 +1,7 @@
 === tests/cases/conformance/async/es6/asyncAliasReturnType_es6.ts ===
 type PromiseAlias<T> = Promise<T>;
->PromiseAlias : Promise<T>
+>PromiseAlias : PromiseAlias<T>
 
 async function f(): PromiseAlias<void> {
->f : () => Promise<void>
+>f : () => PromiseAlias<void>
 }

tests/baselines/reference/asyncAwait_es2017.types

@@ -1,6 +1,6 @@
 === tests/cases/conformance/async/es2017/asyncAwait_es2017.ts ===
 type MyPromise<T> = Promise<T>;
->MyPromise : Promise<T>
+>MyPromise : MyPromise<T>
 
 declare var MyPromise: typeof Promise;
 >MyPromise : PromiseConstructor
@@ -10,7 +10,7 @@ declare var p: Promise<number>;
 >p : Promise<number>
 
 declare var mp: MyPromise<number>;
->mp : Promise<number>
+>mp : MyPromise<number>
 
 async function f0() { }
 >f0 : () => Promise<void>
@@ -19,7 +19,7 @@ async function f1(): Promise<void> { }
 >f1 : () => Promise<void>
 
 async function f3(): MyPromise<void> { }
->f3 : () => Promise<void>
+>f3 : () => MyPromise<void>
 
 let f4 = async function() { }
 >f4 : () => Promise<void>
@@ -30,8 +30,8 @@ let f5 = async function(): Promise<void> { }
 >async function(): Promise<void> { } : () => Promise<void>
 
 let f6 = async function(): MyPromise<void> { }
->f6 : () => Promise<void>
->async function(): MyPromise<void> { } : () => Promise<void>
+>f6 : () => MyPromise<void>
+>async function(): MyPromise<void> { } : () => MyPromise<void>
 
 let f7 = async () => { };
 >f7 : () => Promise<void>
@@ -42,8 +42,8 @@ let f8 = async (): Promise<void> => { };
 >async (): Promise<void> => { } : () => Promise<void>
 
 let f9 = async (): MyPromise<void> => { };
->f9 : () => Promise<void>
->async (): MyPromise<void> => { } : () => Promise<void>
+>f9 : () => MyPromise<void>
+>async (): MyPromise<void> => { } : () => MyPromise<void>
 
 let f10 = async () => p;
 >f10 : () => Promise<number>
@@ -53,21 +53,21 @@ let f10 = async () => p;
 let f11 = async () => mp;
 >f11 : () => Promise<number>
 >async () => mp : () => Promise<number>
->mp : Promise<number>
+>mp : MyPromise<number>
 
 let f12 = async (): Promise<number> => mp;
 >f12 : () => Promise<number>
 >async (): Promise<number> => mp : () => Promise<number>
->mp : Promise<number>
+>mp : MyPromise<number>
 
 let f13 = async (): MyPromise<number> => p;
->f13 : () => Promise<number>
->async (): MyPromise<number> => p : () => Promise<number>
+>f13 : () => MyPromise<number>
+>async (): MyPromise<number> => p : () => MyPromise<number>
 >p : Promise<number>
 
 let o = {
->o : { m1(): Promise<void>; m2(): Promise<void>; m3(): Promise<void>; }
->{	async m1() { },	async m2(): Promise<void> { },	async m3(): MyPromise<void> { }} : { m1(): Promise<void>; m2(): Promise<void>; m3(): Promise<void>; }
+>o : { m1(): Promise<void>; m2(): Promise<void>; m3(): MyPromise<void>; }
+>{	async m1() { },	async m2(): Promise<void> { },	async m3(): MyPromise<void> { }} : { m1(): Promise<void>; m2(): Promise<void>; m3(): MyPromise<void>; }
 
 	async m1() { },
 >m1 : () => Promise<void>
@@ -76,7 +76,7 @@ let o = {
 >m2 : () => Promise<void>
 
 	async m3(): MyPromise<void> { }
->m3 : () => Promise<void>
+>m3 : () => MyPromise<void>
 
 };
 
@@ -90,7 +90,7 @@ class C {
 >m2 : () => Promise<void>
 
 	async m3(): MyPromise<void> { }
->m3 : () => Promise<void>
+>m3 : () => MyPromise<void>
 
 	static async m4() { }
 >m4 : () => Promise<void>
@@ -99,7 +99,7 @@ class C {
 >m5 : () => Promise<void>
 
 	static async m6(): MyPromise<void> { }
->m6 : () => Promise<void>
+>m6 : () => MyPromise<void>
 }
 
 module M {

tests/baselines/reference/asyncAwait_es5.types

@@ -1,6 +1,6 @@
 === tests/cases/conformance/async/es5/asyncAwait_es5.ts ===
 type MyPromise<T> = Promise<T>;
->MyPromise : Promise<T>
+>MyPromise : MyPromise<T>
 
 declare var MyPromise: typeof Promise;
 >MyPromise : PromiseConstructor
@@ -10,7 +10,7 @@ declare var p: Promise<number>;
 >p : Promise<number>
 
 declare var mp: MyPromise<number>;
->mp : Promise<number>
+>mp : MyPromise<number>
 
 async function f0() { }
 >f0 : () => Promise<void>
@@ -19,7 +19,7 @@ async function f1(): Promise<void> { }
 >f1 : () => Promise<void>
 
 async function f3(): MyPromise<void> { }
->f3 : () => Promise<void>
+>f3 : () => MyPromise<void>
 
 let f4 = async function() { }
 >f4 : () => Promise<void>
@@ -30,8 +30,8 @@ let f5 = async function(): Promise<void> { }
 >async function(): Promise<void> { } : () => Promise<void>
 
 let f6 = async function(): MyPromise<void> { }
->f6 : () => Promise<void>
->async function(): MyPromise<void> { } : () => Promise<void>
+>f6 : () => MyPromise<void>
+>async function(): MyPromise<void> { } : () => MyPromise<void>
 
 let f7 = async () => { };
 >f7 : () => Promise<void>
@@ -42,8 +42,8 @@ let f8 = async (): Promise<void> => { };
 >async (): Promise<void> => { } : () => Promise<void>
 
 let f9 = async (): MyPromise<void> => { };
->f9 : () => Promise<void>
->async (): MyPromise<void> => { } : () => Promise<void>
+>f9 : () => MyPromise<void>
+>async (): MyPromise<void> => { } : () => MyPromise<void>
 
 let f10 = async () => p;
 >f10 : () => Promise<number>
@@ -53,21 +53,21 @@ let f10 = async () => p;
 let f11 = async () => mp;
 >f11 : () => Promise<number>
 >async () => mp : () => Promise<number>
->mp : Promise<number>
+>mp : MyPromise<number>
 
 let f12 = async (): Promise<number> => mp;
 >f12 : () => Promise<number>
 >async (): Promise<number> => mp : () => Promise<number>
->mp : Promise<number>
+>mp : MyPromise<number>
 
 let f13 = async (): MyPromise<number> => p;
->f13 : () => Promise<number>
->async (): MyPromise<number> => p : () => Promise<number>
+>f13 : () => MyPromise<number>
+>async (): MyPromise<number> => p : () => MyPromise<number>
 >p : Promise<number>
 
 let o = {
->o : { m1(): Promise<void>; m2(): Promise<void>; m3(): Promise<void>; }
->{	async m1() { },	async m2(): Promise<void> { },	async m3(): MyPromise<void> { }} : { m1(): Promise<void>; m2(): Promise<void>; m3(): Promise<void>; }
+>o : { m1(): Promise<void>; m2(): Promise<void>; m3(): MyPromise<void>; }
+>{	async m1() { },	async m2(): Promise<void> { },	async m3(): MyPromise<void> { }} : { m1(): Promise<void>; m2(): Promise<void>; m3(): MyPromise<void>; }
 
 	async m1() { },
 >m1 : () => Promise<void>
@@ -76,7 +76,7 @@ let o = {
 >m2 : () => Promise<void>
 
 	async m3(): MyPromise<void> { }
->m3 : () => Promise<void>
+>m3 : () => MyPromise<void>
 
 };
 
@@ -90,7 +90,7 @@ class C {
 >m2 : () => Promise<void>
 
 	async m3(): MyPromise<void> { }
->m3 : () => Promise<void>
+>m3 : () => MyPromise<void>
 
 	static async m4() { }
 >m4 : () => Promise<void>
@@ -99,7 +99,7 @@ class C {
 >m5 : () => Promise<void>
 
 	static async m6(): MyPromise<void> { }
->m6 : () => Promise<void>
+>m6 : () => MyPromise<void>
 }
 
 module M {

tests/baselines/reference/asyncAwait_es6.types

@@ -1,6 +1,6 @@
 === tests/cases/conformance/async/es6/asyncAwait_es6.ts ===
 type MyPromise<T> = Promise<T>;
->MyPromise : Promise<T>
+>MyPromise : MyPromise<T>
 
 declare var MyPromise: typeof Promise;
 >MyPromise : PromiseConstructor
@@ -10,7 +10,7 @@ declare var p: Promise<number>;
 >p : Promise<number>
 
 declare var mp: MyPromise<number>;
->mp : Promise<number>
+>mp : MyPromise<number>
 
 async function f0() { }
 >f0 : () => Promise<void>
@@ -19,7 +19,7 @@ async function f1(): Promise<void> { }
 >f1 : () => Promise<void>
 
 async function f3(): MyPromise<void> { }
->f3 : () => Promise<void>
+>f3 : () => MyPromise<void>
 
 let f4 = async function() { }
 >f4 : () => Promise<void>
@@ -30,8 +30,8 @@ let f5 = async function(): Promise<void> { }
 >async function(): Promise<void> { } : () => Promise<void>
 
 let f6 = async function(): MyPromise<void> { }
->f6 : () => Promise<void>
->async function(): MyPromise<void> { } : () => Promise<void>
+>f6 : () => MyPromise<void>
+>async function(): MyPromise<void> { } : () => MyPromise<void>
 
 let f7 = async () => { };
 >f7 : () => Promise<void>
@@ -42,8 +42,8 @@ let f8 = async (): Promise<void> => { };
 >async (): Promise<void> => { } : () => Promise<void>
 
 let f9 = async (): MyPromise<void> => { };
->f9 : () => Promise<void>
->async (): MyPromise<void> => { } : () => Promise<void>
+>f9 : () => MyPromise<void>
+>async (): MyPromise<void> => { } : () => MyPromise<void>
 
 let f10 = async () => p;
 >f10 : () => Promise<number>
@@ -53,21 +53,21 @@ let f10 = async () => p;
 let f11 = async () => mp;
 >f11 : () => Promise<number>
 >async () => mp : () => Promise<number>
->mp : Promise<number>
+>mp : MyPromise<number>
 
 let f12 = async (): Promise<number> => mp;
 >f12 : () => Promise<number>
 >async (): Promise<number> => mp : () => Promise<number>
->mp : Promise<number>
+>mp : MyPromise<number>
 
 let f13 = async (): MyPromise<number> => p;
->f13 : () => Promise<number>
->async (): MyPromise<number> => p : () => Promise<number>
+>f13 : () => MyPromise<number>
+>async (): MyPromise<number> => p : () => MyPromise<number>
 >p : Promise<number>
 
 let o = {
->o : { m1(): Promise<void>; m2(): Promise<void>; m3(): Promise<void>; }
->{	async m1() { },	async m2(): Promise<void> { },	async m3(): MyPromise<void> { }} : { m1(): Promise<void>; m2(): Promise<void>; m3(): Promise<void>; }
+>o : { m1(): Promise<void>; m2(): Promise<void>; m3(): MyPromise<void>; }
+>{	async m1() { },	async m2(): Promise<void> { },	async m3(): MyPromise<void> { }} : { m1(): Promise<void>; m2(): Promise<void>; m3(): MyPromise<void>; }
 
 	async m1() { },
 >m1 : () => Promise<void>
@@ -76,7 +76,7 @@ let o = {
 >m2 : () => Promise<void>
 
 	async m3(): MyPromise<void> { }
->m3 : () => Promise<void>
+>m3 : () => MyPromise<void>
 
 };
 
@@ -90,7 +90,7 @@ class C {
 >m2 : () => Promise<void>
 
 	async m3(): MyPromise<void> { }
->m3 : () => Promise<void>
+>m3 : () => MyPromise<void>
 
 	static async m4() { }
 >m4 : () => Promise<void>
@@ -99,7 +99,7 @@ class C {
 >m5 : () => Promise<void>
 
 	static async m6(): MyPromise<void> { }
->m6 : () => Promise<void>
+>m6 : () => MyPromise<void>
 }
 
 module M {

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>

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'.
     }
     

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);

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[]
 

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]

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

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;
         }

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
             }
         }

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.

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>;

tests/baselines/reference/checkJsxChildrenProperty3.types

@@ -31,11 +31,11 @@ class FetchUser extends React.Component<IFetchUserProps, any> {
 
             ? this.props.children(this.state.result)
 >this.props.children(this.state.result) : JSX.Element
->this.props.children : ((user: IUser) => JSX.Element) | (((user: IUser) => JSX.Element) & string) | (((user: IUser) => JSX.Element) & number) | (((user: IUser) => JSX.Element) & false) | (((user: IUser) => JSX.Element) & true) | (((user: IUser) => JSX.Element) & React.ReactElement<any>) | (((user: IUser) => JSX.Element) & (string | number | boolean | any[] | React.ReactElement<any>)[])
+>this.props.children : ((user: IUser) => JSX.Element) | (((user: IUser) => JSX.Element) & string) | (((user: IUser) => JSX.Element) & number) | (((user: IUser) => JSX.Element) & false) | (((user: IUser) => JSX.Element) & true) | (((user: IUser) => JSX.Element) & React.ReactElement<any>) | (((user: IUser) => JSX.Element) & (string | number | boolean | React.ReactElement<any> | any[])[])
 >this.props : IFetchUserProps & { children?: React.ReactNode; }
 >this : this
 >props : IFetchUserProps & { children?: React.ReactNode; }
->children : ((user: IUser) => JSX.Element) | (((user: IUser) => JSX.Element) & string) | (((user: IUser) => JSX.Element) & number) | (((user: IUser) => JSX.Element) & false) | (((user: IUser) => JSX.Element) & true) | (((user: IUser) => JSX.Element) & React.ReactElement<any>) | (((user: IUser) => JSX.Element) & (string | number | boolean | any[] | React.ReactElement<any>)[])
+>children : ((user: IUser) => JSX.Element) | (((user: IUser) => JSX.Element) & string) | (((user: IUser) => JSX.Element) & number) | (((user: IUser) => JSX.Element) & false) | (((user: IUser) => JSX.Element) & true) | (((user: IUser) => JSX.Element) & React.ReactElement<any>) | (((user: IUser) => JSX.Element) & (string | number | boolean | React.ReactElement<any> | any[])[])
 >this.state.result : any
 >this.state : any
 >this : this

tests/baselines/reference/checkJsxChildrenProperty4.errors.txt

@@ -1,8 +1,8 @@
 tests/cases/conformance/jsx/file.tsx(24,28): error TS2551: Property 'NAme' does not exist on type 'IUser'. Did you mean 'Name'?
-tests/cases/conformance/jsx/file.tsx(36,15): error TS2322: Type '(user: IUser) => Element' is not assignable to type 'string | number | boolean | any[] | ReactElement<any>'.
-  Type '(user: IUser) => Element' is missing the following properties from type 'ReactElement<any>': type, props
-tests/cases/conformance/jsx/file.tsx(39,15): error TS2322: Type '(user: IUser) => Element' is not assignable to type 'string | number | boolean | any[] | ReactElement<any>'.
-  Type '(user: IUser) => Element' is missing the following properties from type 'ReactElement<any>': type, props
+tests/cases/conformance/jsx/file.tsx(36,15): error TS2322: Type '(user: IUser) => Element' is not assignable to type 'string | number | boolean | ReactElement<any> | any[]'.
+  Type '(user: IUser) => Element' is missing the following properties from type 'any[]': push, pop, concat, join, and 15 more.
+tests/cases/conformance/jsx/file.tsx(39,15): error TS2322: Type '(user: IUser) => Element' is not assignable to type 'string | number | boolean | ReactElement<any> | any[]'.
+  Type '(user: IUser) => Element' is missing the following properties from type 'any[]': push, pop, concat, join, and 15 more.
 
 
 ==== tests/cases/conformance/jsx/file.tsx (3 errors) ====
@@ -50,8 +50,8 @@ tests/cases/conformance/jsx/file.tsx(39,15): error TS2322: Type '(user: IUser) =
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                 ) }
     ~~~~~~~~~~~~~
-!!! error TS2322: Type '(user: IUser) => Element' is not assignable to type 'string | number | boolean | any[] | ReactElement<any>'.
-!!! error TS2322:   Type '(user: IUser) => Element' is missing the following properties from type 'ReactElement<any>': type, props
+!!! error TS2322: Type '(user: IUser) => Element' is not assignable to type 'string | number | boolean | ReactElement<any> | any[]'.
+!!! error TS2322:   Type '(user: IUser) => Element' is missing the following properties from type 'any[]': push, pop, concat, join, and 15 more.
 !!! related TS6212 tests/cases/conformance/jsx/file.tsx:36:15: Did you mean to call this expression?
                 { user => (
                   ~~~~~~~~~
@@ -59,8 +59,8 @@ tests/cases/conformance/jsx/file.tsx(39,15): error TS2322: Type '(user: IUser) =
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                 ) }
     ~~~~~~~~~~~~~
-!!! error TS2322: Type '(user: IUser) => Element' is not assignable to type 'string | number | boolean | any[] | ReactElement<any>'.
-!!! error TS2322:   Type '(user: IUser) => Element' is missing the following properties from type 'ReactElement<any>': type, props
+!!! error TS2322: Type '(user: IUser) => Element' is not assignable to type 'string | number | boolean | ReactElement<any> | any[]'.
+!!! error TS2322:   Type '(user: IUser) => Element' is missing the following properties from type 'any[]': push, pop, concat, join, and 15 more.
 !!! related TS6212 tests/cases/conformance/jsx/file.tsx:39:15: Did you mean to call this expression?
             </FetchUser>
         );

tests/baselines/reference/checkJsxChildrenProperty4.types

@@ -31,11 +31,11 @@ class FetchUser extends React.Component<IFetchUserProps, any> {
 
             ? this.props.children(this.state.result)
 >this.props.children(this.state.result) : JSX.Element
->this.props.children : ((user: IUser) => JSX.Element) | (((user: IUser) => JSX.Element) & string) | (((user: IUser) => JSX.Element) & number) | (((user: IUser) => JSX.Element) & false) | (((user: IUser) => JSX.Element) & true) | (((user: IUser) => JSX.Element) & React.ReactElement<any>) | (((user: IUser) => JSX.Element) & (string | number | boolean | any[] | React.ReactElement<any>)[])
+>this.props.children : ((user: IUser) => JSX.Element) | (((user: IUser) => JSX.Element) & string) | (((user: IUser) => JSX.Element) & number) | (((user: IUser) => JSX.Element) & false) | (((user: IUser) => JSX.Element) & true) | (((user: IUser) => JSX.Element) & React.ReactElement<any>) | (((user: IUser) => JSX.Element) & (string | number | boolean | React.ReactElement<any> | any[])[])
 >this.props : IFetchUserProps & { children?: React.ReactNode; }
 >this : this
 >props : IFetchUserProps & { children?: React.ReactNode; }
->children : ((user: IUser) => JSX.Element) | (((user: IUser) => JSX.Element) & string) | (((user: IUser) => JSX.Element) & number) | (((user: IUser) => JSX.Element) & false) | (((user: IUser) => JSX.Element) & true) | (((user: IUser) => JSX.Element) & React.ReactElement<any>) | (((user: IUser) => JSX.Element) & (string | number | boolean | any[] | React.ReactElement<any>)[])
+>children : ((user: IUser) => JSX.Element) | (((user: IUser) => JSX.Element) & string) | (((user: IUser) => JSX.Element) & number) | (((user: IUser) => JSX.Element) & false) | (((user: IUser) => JSX.Element) & true) | (((user: IUser) => JSX.Element) & React.ReactElement<any>) | (((user: IUser) => JSX.Element) & (string | number | boolean | React.ReactElement<any> | any[])[])
 >this.state.result : any
 >this.state : any
 >this : this

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>;

tests/baselines/reference/complicatedIndexesOfIntersectionsAreInferencable.types

@@ -12,10 +12,10 @@ interface FormikConfig<Values> {
 }
 
 declare function Func<Values = object, ExtraProps = {}>(
->Func : <Values = object, ExtraProps = {}>(x: string extends "validate" | "initialValues" | keyof ExtraProps ? Readonly<FormikConfig<Values> & ExtraProps> : Pick<Readonly<FormikConfig<Values> & ExtraProps>, "validate" | "initialValues" | Exclude<keyof ExtraProps, "validateOnChange">> & Partial<Pick<Readonly<FormikConfig<Values> & ExtraProps>, "validateOnChange" | Extract<keyof ExtraProps, "validateOnChange">>>) => void
+>Func : <Values = object, ExtraProps = {}>(x: string extends keyof ExtraProps | "validate" | "initialValues" ? Readonly<FormikConfig<Values> & ExtraProps> : Pick<Readonly<FormikConfig<Values> & ExtraProps>, Exclude<keyof ExtraProps, "validateOnChange"> | "validate" | "initialValues"> & Partial<Pick<Readonly<FormikConfig<Values> & ExtraProps>, "validateOnChange" | Extract<keyof ExtraProps, "validateOnChange">>>) => void
 
     x: (string extends "validate" | "initialValues" | keyof ExtraProps
->x : string extends "validate" | "initialValues" | keyof ExtraProps ? Readonly<FormikConfig<Values> & ExtraProps> : Pick<Readonly<FormikConfig<Values> & ExtraProps>, "validate" | "initialValues" | Exclude<keyof ExtraProps, "validateOnChange">> & Partial<Pick<Readonly<FormikConfig<Values> & ExtraProps>, "validateOnChange" | Extract<keyof ExtraProps, "validateOnChange">>>
+>x : string extends keyof ExtraProps | "validate" | "initialValues" ? Readonly<FormikConfig<Values> & ExtraProps> : Pick<Readonly<FormikConfig<Values> & ExtraProps>, Exclude<keyof ExtraProps, "validateOnChange"> | "validate" | "initialValues"> & Partial<Pick<Readonly<FormikConfig<Values> & ExtraProps>, "validateOnChange" | Extract<keyof ExtraProps, "validateOnChange">>>
 
         ? Readonly<FormikConfig<Values> & ExtraProps>
         : Pick<Readonly<FormikConfig<Values> & ExtraProps>, "validate" | "initialValues" | Exclude<keyof ExtraProps, "validateOnChange">>
@@ -24,7 +24,7 @@ declare function Func<Values = object, ExtraProps = {}>(
 
 Func({
 >Func({    initialValues: {        foo: ""    },    validate: props => {        props.foo;    }}) : void
->Func : <Values = object, ExtraProps = {}>(x: string extends "validate" | "initialValues" | keyof ExtraProps ? Readonly<FormikConfig<Values> & ExtraProps> : Pick<Readonly<FormikConfig<Values> & ExtraProps>, "validate" | "initialValues" | Exclude<keyof ExtraProps, "validateOnChange">> & Partial<Pick<Readonly<FormikConfig<Values> & ExtraProps>, "validateOnChange" | Extract<keyof ExtraProps, "validateOnChange">>>) => void
+>Func : <Values = object, ExtraProps = {}>(x: string extends keyof ExtraProps | "validate" | "initialValues" ? Readonly<FormikConfig<Values> & ExtraProps> : Pick<Readonly<FormikConfig<Values> & ExtraProps>, Exclude<keyof ExtraProps, "validateOnChange"> | "validate" | "initialValues"> & Partial<Pick<Readonly<FormikConfig<Values> & ExtraProps>, "validateOnChange" | Extract<keyof ExtraProps, "validateOnChange">>>) => void
 >{    initialValues: {        foo: ""    },    validate: props => {        props.foo;    }} : { initialValues: { foo: string; }; validate: (props: { foo: string; }) => void; }
 
     initialValues: {

tests/baselines/reference/conditionalTypes1.types

@@ -494,7 +494,7 @@ function f21<T extends number | string>(x: T, y: ZeroOf<T>) {
 }
 
 type T35<T extends { a: string, b: number }> = T[];
->T35 : T[]
+>T35 : T35<T>
 >a : string
 >b : number
 

tests/baselines/reference/constraintOfRecursivelyMappedTypeWithConditionalIsResolvable.types

@@ -6,7 +6,7 @@ interface Map<K, V> {
 }
 
 export type ImmutableTypes = IImmutableMap<any>;
->ImmutableTypes : IImmutableMap<any>
+>ImmutableTypes : ImmutableTypes
 
 export type ImmutableModel<T> = { [K in keyof T]: T[K] extends ImmutableTypes ? T[K] : never };
 >ImmutableModel : ImmutableModel<T>
@@ -19,7 +19,7 @@ export interface IImmutableMap<T extends ImmutableModel<T>> extends Map<string,
 }
 
 export type ImmutableTypes2 = IImmutableMap2<any>;
->ImmutableTypes2 : IImmutableMap2<any>
+>ImmutableTypes2 : ImmutableTypes2
 
 type isImmutableType<T> = [T] extends [ImmutableTypes2] ? T : never;
 >isImmutableType : isImmutableType<T>

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;
         }

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
             }
     

tests/baselines/reference/contextualTypingOfOptionalMembers.types

@@ -124,17 +124,17 @@ app2({
 
 
 type ActionsArray<State> = ((state: State) => State)[];
->ActionsArray : ((state: State) => State)[]
+>ActionsArray : ActionsArray<State>
 >state : State
 
 declare function app3<State, Actions extends ActionsArray<State>>(obj: Options<State, Actions>): void;
->app3 : <State, Actions extends ((state: State) => State)[]>(obj: Options<State, Actions>) => void
+>app3 : <State, Actions extends ActionsArray<State>>(obj: Options<State, Actions>) => void
 >obj : Options<State, Actions>
 
 app3({
 >app3({    state: 100,    actions: [        s => s // Should be typed number => number    ],    view: (s, a) => undefined as any,}) : void
->app3 : <State, Actions extends ((state: State) => State)[]>(obj: Options<State, Actions>) => void
->{    state: 100,    actions: [        s => s // Should be typed number => number    ],    view: (s, a) => undefined as any,} : { state: number; actions: ((s: number) => number)[]; view: (s: number, a: ((state: number) => number)[]) => any; }
+>app3 : <State, Actions extends ActionsArray<State>>(obj: Options<State, Actions>) => void
+>{    state: 100,    actions: [        s => s // Should be typed number => number    ],    view: (s, a) => undefined as any,} : { state: number; actions: ((s: number) => number)[]; view: (s: number, a: ActionsArray<number>) => any; }
 
     state: 100,
 >state : number
@@ -151,10 +151,10 @@ app3({
 
     ],
     view: (s, a) => undefined as any,
->view : (s: number, a: ((state: number) => number)[]) => any
->(s, a) => undefined as any : (s: number, a: ((state: number) => number)[]) => any
+>view : (s: number, a: ActionsArray<number>) => any
+>(s, a) => undefined as any : (s: number, a: ActionsArray<number>) => any
 >s : number
->a : ((state: number) => number)[]
+>a : ActionsArray<number>
 >undefined as any : any
 >undefined : undefined
 

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'.
     

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 {

tests/baselines/reference/declarationEmitDestructuringParameterProperties.types

@@ -10,7 +10,7 @@ class C1 {
 }
 
 type TupleType1 =[string, number, boolean];
->TupleType1 : [string, number, boolean]
+>TupleType1 : TupleType1
 
 class C2 {
 >C2 : C2

tests/baselines/reference/declarationEmitReexportedSymlinkReference3.errors.txt

@@ -1,60 +0,0 @@
-tests/cases/compiler/monorepo/pkg3/src/keys.ts(3,14): error TS2742: The inferred type of 'ADMIN' cannot be named without a reference to '../../pkg2/node_modules/@raymondfeng/pkg1/dist'. This is likely not portable. A type annotation is necessary.
-
-
-==== tests/cases/compiler/monorepo/pkg3/tsconfig.json (0 errors) ====
-    {
-        "compilerOptions": {
-          "outDir": "dist",
-          "rootDir": "src",
-          "target": "es5",
-          "module": "commonjs",
-          "strict": true,
-          "esModuleInterop": true,
-          "declaration": true
-        }
-    }
-    
-==== tests/cases/compiler/monorepo/pkg1/dist/index.d.ts (0 errors) ====
-    export * from './types';
-==== tests/cases/compiler/monorepo/pkg1/dist/types.d.ts (0 errors) ====
-    export declare type A = {
-        id: string;
-    };
-    export declare type B = {
-        id: number;
-    };
-    export declare type IdType = A | B;
-    export declare class MetadataAccessor<T, D extends IdType = IdType> {
-        readonly key: string;
-        private constructor();
-        toString(): string;
-        static create<T, D extends IdType = IdType>(key: string): MetadataAccessor<T, D>;
-    }
-==== tests/cases/compiler/monorepo/pkg1/package.json (0 errors) ====
-    {
-        "name": "@raymondfeng/pkg1",
-        "version": "1.0.0",
-        "description": "",
-        "main": "dist/index.js",
-        "typings": "dist/index.d.ts"
-    }
-==== tests/cases/compiler/monorepo/pkg2/dist/index.d.ts (0 errors) ====
-    export * from './types';
-==== tests/cases/compiler/monorepo/pkg2/dist/types.d.ts (0 errors) ====
-    export {MetadataAccessor} from '@raymondfeng/pkg1';
-==== tests/cases/compiler/monorepo/pkg2/package.json (0 errors) ====
-    {
-        "name": "@raymondfeng/pkg2",
-        "version": "1.0.0",
-        "description": "",
-        "main": "dist/index.js",
-        "typings": "dist/index.d.ts"
-    }
-==== tests/cases/compiler/monorepo/pkg3/src/index.ts (0 errors) ====
-    export * from './keys';
-==== tests/cases/compiler/monorepo/pkg3/src/keys.ts (1 errors) ====
-    import {MetadataAccessor} from "@raymondfeng/pkg2";
-    
-    export const ADMIN = MetadataAccessor.create<boolean>('1');
-                 ~~~~~
-!!! error TS2742: The inferred type of 'ADMIN' cannot be named without a reference to '../../pkg2/node_modules/@raymondfeng/pkg1/dist'. This is likely not portable. A type annotation is necessary.

tests/baselines/reference/declarationEmitReexportedSymlinkReference3.js

@@ -57,5 +57,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __export(require("./keys"));
 
 
+//// [keys.d.ts]
+import { MetadataAccessor } from "@raymondfeng/pkg2";
+export declare const ADMIN: MetadataAccessor<boolean, import("../../pkg1/dist").IdType>;
 //// [index.d.ts]
 export * from './keys';