Merge branch 'main' into templateLiteralTypeInferToNonString

Author: rbuckton

src/compiler/checker.ts

@@ -2743,6 +2743,10 @@
         "category": "Error",
         "code": 2636
     },
+    "Variance annotations are only supported in type aliases for object, function, constructor, and mapped types.": {
+        "category": "Error",
+        "code": 2637
+    },
 
     "Cannot augment module '{0}' with value exports because it resolves to a non-module entity.": {
         "category": "Error",

src/compiler/diagnosticMessages.json

@@ -1163,6 +1163,9 @@ namespace ts {
         }
 
         function transformTopLevelDeclaration(input: LateVisibilityPaintedStatement) {
+            if (lateMarkedStatements) {
+                while (orderedRemoveItem(lateMarkedStatements, input));
+            }
             if (shouldStripInternal(input)) return;
             switch (input.kind) {
                 case SyntaxKind.ImportEqualsDeclaration: {

src/compiler/transformers/declarations.ts

@@ -5915,6 +5915,13 @@ namespace ts {
         nonFixingMapper: TypeMapper;                  // Mapper that doesn't fix inferences
         returnMapper?: TypeMapper;                    // Type mapper for inferences from return types (if any)
         inferredTypeParameters?: readonly TypeParameter[]; // Inferred type parameters for function result
+        intraExpressionInferenceSites?: IntraExpressionInferenceSite[];
+    }
+
+    /* @internal */
+    export interface IntraExpressionInferenceSite {
+        node: Expression | MethodDeclaration;
+        type: Type;
     }
 
     /* @internal */

src/compiler/types.ts

@@ -649,7 +649,7 @@ namespace ts {
         return false;
     }
 
-    export type ExecuteCommandLineCallbacks = (program: Program | EmitAndSemanticDiagnosticsBuilderProgram | ParsedCommandLine) => void;
+    export type ExecuteCommandLineCallbacks = (program: Program | BuilderProgram | ParsedCommandLine) => void;
     export function executeCommandLine(
         system: System,
         cb: ExecuteCommandLineCallbacks,

src/executeCommandLine/executeCommandLine.ts

@@ -583,7 +583,6 @@ namespace ts.server {
                 fileName: entry.file,
                 textSpan: this.decodeSpan(entry),
                 isWriteAccess: entry.isWriteAccess,
-                isDefinition: false
             }));
         }
 

src/harness/client.ts

@@ -511,18 +511,19 @@ ${indentText}${text}`;
             buildInfo.version = ts.version;
             return ts.getBuildInfoText(buildInfo);
         };
+        return patchHostForBuildInfoWrite(sys, version);
+    }
+
+    export function patchHostForBuildInfoWrite<T extends ts.System>(sys: T, version: string) {
         const originalWrite = sys.write;
         sys.write = msg => originalWrite.call(sys, msg.replace(ts.version, version));
-
-        if (sys.writeFile) {
-            const originalWriteFile = sys.writeFile;
-            sys.writeFile = (fileName: string, content: string, writeByteOrderMark: boolean) => {
-                if (!ts.isBuildInfoFile(fileName)) return originalWriteFile.call(sys, fileName, content, writeByteOrderMark);
-                const buildInfo = ts.getBuildInfo(content);
-                buildInfo.version = version;
-                originalWriteFile.call(sys, fileName, ts.getBuildInfoText(buildInfo), writeByteOrderMark);
-            };
-        }
+        const originalWriteFile = sys.writeFile;
+        sys.writeFile = (fileName: string, content: string, writeByteOrderMark: boolean) => {
+            if (!ts.isBuildInfoFile(fileName)) return originalWriteFile.call(sys, fileName, content, writeByteOrderMark);
+            const buildInfo = ts.getBuildInfo(content);
+            buildInfo.version = version;
+            originalWriteFile.call(sys, fileName, ts.getBuildInfoText(buildInfo), writeByteOrderMark);
+        };
         return sys;
     }
 

src/harness/fakesHosts.ts

@@ -115,31 +115,39 @@ namespace Harness {
                 // let type = this.checker.getTypeAtLocation(node);
                 let type = ts.isExpressionWithTypeArgumentsInClassExtendsClause(node.parent) ? this.checker.getTypeAtLocation(node.parent) : undefined;
                 if (!type || type.flags & ts.TypeFlags.Any) type = this.checker.getTypeAtLocation(node);
-                const typeString =
-                    // Distinguish `errorType`s from `any`s; but only if the file has no errors.
-                    // Additionally,
-                    // * the LHS of a qualified name
-                    // * a binding pattern name
-                    // * labels
-                    // * the "global" in "declare global"
-                    // * the "target" in "new.target"
-                    // * names in import statements
-                    // * type-only names in export statements
-                    // * and intrinsic jsx tag names
-                    // return `error`s via `getTypeAtLocation`
-                    // But this is generally expected, so we don't call those out, either
-                    (!this.hadErrorBaseline &&
-                        type.flags & ts.TypeFlags.Any &&
-                        !ts.isBindingElement(node.parent) &&
-                        !ts.isPropertyAccessOrQualifiedName(node.parent) &&
-                        !ts.isLabelName(node) &&
-                        !(ts.isModuleDeclaration(node.parent) && ts.isGlobalScopeAugmentation(node.parent)) &&
-                        !ts.isMetaProperty(node.parent) &&
-                        !this.isImportStatementName(node) &&
-                        !this.isExportStatementName(node) &&
-                        !this.isIntrinsicJsxTag(node)) ?
-                        (type as ts.IntrinsicType).intrinsicName :
-                        this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.AllowUniqueESSymbolType);
+                // Distinguish `errorType`s from `any`s; but only if the file has no errors.
+                // Additionally,
+                // * the LHS of a qualified name
+                // * a binding pattern name
+                // * labels
+                // * the "global" in "declare global"
+                // * the "target" in "new.target"
+                // * names in import statements
+                // * type-only names in export statements
+                // * and intrinsic jsx tag names
+                // return `error`s via `getTypeAtLocation`
+                // But this is generally expected, so we don't call those out, either
+                let typeString: string;
+                if (!this.hadErrorBaseline &&
+                    type.flags & ts.TypeFlags.Any &&
+                    !ts.isBindingElement(node.parent) &&
+                    !ts.isPropertyAccessOrQualifiedName(node.parent) &&
+                    !ts.isLabelName(node) &&
+                    !(ts.isModuleDeclaration(node.parent) && ts.isGlobalScopeAugmentation(node.parent)) &&
+                    !ts.isMetaProperty(node.parent) &&
+                    !this.isImportStatementName(node) &&
+                    !this.isExportStatementName(node) &&
+                    !this.isIntrinsicJsxTag(node)) {
+                    typeString = (type as ts.IntrinsicType).intrinsicName;
+                }
+                else {
+                    typeString = this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.AllowUniqueESSymbolType);
+                    if (ts.isIdentifier(node) && ts.isTypeAliasDeclaration(node.parent) && node.parent.name === node && typeString === ts.idText(node)) {
+                        // for a complex type alias `type T = ...`, showing "T : T" isn't very helpful for type tests. When the type produced is the same as
+                        // the name of the type alias, recreate the type string without reusing the alias name
+                        typeString = this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.AllowUniqueESSymbolType | ts.TypeFormatFlags.InTypeAlias);
+                    }
+                }
                 return {
                     line: lineAndCharacter.line,
                     syntaxKind: node.kind,

src/harness/typeWriter.ts

@@ -809,7 +809,11 @@ namespace vfs {
             const baseBuffer = base._getBuffer(baseNode);
 
             // no difference if both buffers are the same reference
-            if (changedBuffer === baseBuffer) return false;
+            if (changedBuffer === baseBuffer) {
+                if (!options.includeChangedFileWithSameContent || changedNode.mtimeMs === baseNode.mtimeMs) return false;
+                container[basename] = new SameFileWithModifiedTime(changedBuffer);
+                return true;
+            }
 
             // no difference if both buffers are identical
             if (Buffer.compare(changedBuffer, baseBuffer) === 0) {
@@ -1391,6 +1395,12 @@ namespace vfs {
         }
     }
 
+    export class SameFileWithModifiedTime extends File {
+        constructor(data: Buffer | string, metaAndEncoding?: { encoding?: string, meta?: Record<string, any> }) {
+            super(data, metaAndEncoding);
+        }
+    }
+
     /** Extended options for a hard link in a `FileSet` */
     export class Link {
         public readonly path: string;
@@ -1579,6 +1589,9 @@ namespace vfs {
             else if (entry instanceof Directory) {
                 text += formatPatchWorker(file, entry.files);
             }
+            else if (entry instanceof SameFileWithModifiedTime) {
+                text += `//// [${file}] file changed its modified time\r\n`;
+            }
             else if (entry instanceof SameFileContentFile) {
                 text += `//// [${file}] file written with same contents\r\n`;
             }