diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 8a7853dfaa5..cd918ea4dce 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -4406,7 +4406,7 @@ namespace ts { type = getWidenedTypeForVariableLikeDeclaration(declaration, /*reportErrors*/ true); } else { - Debug.fail("Unhandled declaration kind! " + (ts as any).SyntaxKind[declaration.kind]); + Debug.fail("Unhandled declaration kind! " + Debug.showSyntaxKind(declaration)); } if (!popTypeResolution()) { @@ -20726,7 +20726,7 @@ namespace ts { case SyntaxKind.ImportSpecifier: // https://github.com/Microsoft/TypeScript/pull/7591 return DeclarationSpaces.ExportValue; default: - Debug.fail((ts as any).SyntaxKind[d.kind]); + Debug.fail(Debug.showSyntaxKind(d)); } } } diff --git a/src/compiler/core.ts b/src/compiler/core.ts index fe8e63676d7..8479cf94180 100644 --- a/src/compiler/core.ts +++ b/src/compiler/core.ts @@ -1466,7 +1466,7 @@ namespace ts { if (value !== undefined && test(value)) return value; if (value && typeof (value as any).kind === "number") { - Debug.fail(`Invalid cast. The supplied ${(ts as any).SyntaxKind[(value as any).kind]} did not pass the test '${Debug.getFunctionName(test)}'.`); + Debug.fail(`Invalid cast. The supplied ${Debug.showSyntaxKind(value as any as Node)} did not pass the test '${Debug.getFunctionName(test)}'.`); } else { Debug.fail(`Invalid cast. The supplied value did not pass the test '${Debug.getFunctionName(test)}'.`); @@ -2925,6 +2925,25 @@ namespace ts { return match ? match[1] : ""; } } + + export function showSymbol(symbol: Symbol): string { + return `{ flags: ${showFlags(symbol.flags, (ts as any).SymbolFlags)}; declarations: ${map(symbol.declarations, showSyntaxKind)} }`; + } + + function showFlags(flags: number, flagsEnum: { [flag: number]: string }): string { + const out = []; + for (let pow = 0; pow <= 30; pow++) { + const n = 1 << pow; + if (flags & n) { + out.push(flagsEnum[n]); + } + } + return out.join("|"); + } + + export function showSyntaxKind(node: Node): string { + return (ts as any).SyntaxKind[node.kind]; + } } /** Remove an item from an array, moving everything to its right one space left. */ diff --git a/src/compiler/types.ts b/src/compiler/types.ts index c363861e62d..6d9953b6669 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -4118,16 +4118,6 @@ namespace ts { [option: string]: string[] | boolean | undefined; } - export interface DiscoverTypingsInfo { - fileNames: string[]; // The file names that belong to the same project. - projectRootPath: string; // The path to the project root directory - safeListPath: string; // The path used to retrieve the safe list - packageNameToTypingLocation: Map; // The map of package names to their cached typing locations - typeAcquisition: TypeAcquisition; // Used to customize the type acquisition process - compilerOptions: CompilerOptions; // Used as a source for typing inference - unresolvedImports: ReadonlyArray; // List of unresolved module ids from imports - } - export enum ModuleKind { None = 0, CommonJS = 1, diff --git a/src/harness/unittests/tsserverProjectSystem.ts b/src/harness/unittests/tsserverProjectSystem.ts index 33b268ccb9c..08b04eda223 100644 --- a/src/harness/unittests/tsserverProjectSystem.ts +++ b/src/harness/unittests/tsserverProjectSystem.ts @@ -63,7 +63,7 @@ namespace ts.projectSystem { readonly globalTypingsCacheLocation: string, throttleLimit: number, installTypingHost: server.ServerHost, - readonly typesRegistry = createMap(), + readonly typesRegistry = createMap>(), log?: TI.Log) { super(installTypingHost, globalTypingsCacheLocation, safeList.path, customTypesMap.path, throttleLimit, log); } @@ -126,6 +126,25 @@ namespace ts.projectSystem { return JSON.stringify({ dependencies }); } + export function createTypesRegistry(...list: string[]): Map> { + const versionMap = { + "latest": "1.3.0", + "ts2.0": "1.0.0", + "ts2.1": "1.0.0", + "ts2.2": "1.2.0", + "ts2.3": "1.3.0", + "ts2.4": "1.3.0", + "ts2.5": "1.3.0", + "ts2.6": "1.3.0", + "ts2.7": "1.3.0" + }; + const map = createMap>(); + for (const l of list) { + map.set(l, versionMap); + } + return map; + } + export function toExternalFile(fileName: string): protocol.ExternalFile { return { fileName }; } @@ -6682,12 +6701,18 @@ namespace ts.projectSystem { }, }) }; + const typingsCachePackageLockJson: FileOrFolder = { + path: `${typingsCache}/package-lock.json`, + content: JSON.stringify({ + dependencies: { + }, + }) + }; - const files = [file, packageJsonInCurrentDirectory, packageJsonOfPkgcurrentdirectory, indexOfPkgcurrentdirectory, typingsCachePackageJson]; + const files = [file, packageJsonInCurrentDirectory, packageJsonOfPkgcurrentdirectory, indexOfPkgcurrentdirectory, typingsCachePackageJson, typingsCachePackageLockJson]; const host = createServerHost(files, { currentDirectory }); - const typesRegistry = createMap(); - typesRegistry.set("pkgcurrentdirectory", void 0); + const typesRegistry = createTypesRegistry("pkgcurrentdirectory"); const typingsInstaller = new TestTypingsInstaller(typingsCache, /*throttleLimit*/ 5, host, typesRegistry); const projectService = createProjectService(host, { typingsInstaller }); diff --git a/src/harness/unittests/typingsInstaller.ts b/src/harness/unittests/typingsInstaller.ts index a84520095a4..b5265c5e5f2 100644 --- a/src/harness/unittests/typingsInstaller.ts +++ b/src/harness/unittests/typingsInstaller.ts @@ -1,6 +1,7 @@ /// /// /// +/// namespace ts.projectSystem { import TI = server.typingsInstaller; @@ -10,15 +11,7 @@ namespace ts.projectSystem { interface InstallerParams { globalTypingsCacheLocation?: string; throttleLimit?: number; - typesRegistry?: Map; - } - - function createTypesRegistry(...list: string[]): Map { - const map = createMap(); - for (const l of list) { - map.set(l, undefined); - } - return map; + typesRegistry?: Map>; } class Installer extends TestTypingsInstaller { @@ -50,7 +43,7 @@ namespace ts.projectSystem { const logs: string[] = []; return { log(message) { - logs.push(message); + logs.push(message); }, finish() { return logs; @@ -1053,6 +1046,142 @@ namespace ts.projectSystem { const version2 = proj.getCachedUnresolvedImportsPerFile_TestOnly().getVersion(); assert.notEqual(version1, version2, "set of unresolved imports should change"); }); + + it("expired cache entry (inferred project, should install typings)", () => { + const file1 = { + path: "/a/b/app.js", + content: "" + }; + const packageJson = { + path: "/a/b/package.json", + content: JSON.stringify({ + name: "test", + dependencies: { + jquery: "^3.1.0" + } + }) + }; + const jquery = { + path: "/a/data/node_modules/@types/jquery/index.d.ts", + content: "declare const $: { x: number }" + }; + const cacheConfig = { + path: "/a/data/package.json", + content: JSON.stringify({ + dependencies: { + "types-registry": "^0.1.317" + }, + devDependencies: { + "@types/jquery": "^1.0.0" + } + }) + }; + const cacheLockConfig = { + path: "/a/data/package-lock.json", + content: JSON.stringify({ + dependencies: { + "@types/jquery": { + version: "1.0.0" + } + } + }) + }; + const host = createServerHost([file1, packageJson, jquery, cacheConfig, cacheLockConfig]); + const installer = new (class extends Installer { + constructor() { + super(host, { typesRegistry: createTypesRegistry("jquery") }); + } + installWorker(_requestId: number, _args: string[], _cwd: string, cb: TI.RequestCompletedAction) { + const installedTypings = ["@types/jquery"]; + const typingFiles = [jquery]; + executeCommand(this, host, installedTypings, typingFiles, cb); + } + })(); + + const projectService = createProjectService(host, { useSingleInferredProject: true, typingsInstaller: installer }); + projectService.openClientFile(file1.path); + + checkNumberOfProjects(projectService, { inferredProjects: 1 }); + const p = projectService.inferredProjects[0]; + checkProjectActualFiles(p, [file1.path]); + + installer.installAll(/*expectedCount*/ 1); + + checkNumberOfProjects(projectService, { inferredProjects: 1 }); + checkProjectActualFiles(p, [file1.path, jquery.path]); + }); + + it("non-expired cache entry (inferred project, should not install typings)", () => { + const file1 = { + path: "/a/b/app.js", + content: "" + }; + const packageJson = { + path: "/a/b/package.json", + content: JSON.stringify({ + name: "test", + dependencies: { + jquery: "^3.1.0" + } + }) + }; + const timestamps = { + path: "/a/data/timestamps.json", + content: JSON.stringify({ + entries: { + "@types/jquery": Date.now() + } + }) + }; + const cacheConfig = { + path: "/a/data/package.json", + content: JSON.stringify({ + dependencies: { + "types-registry": "^0.1.317" + }, + devDependencies: { + "@types/jquery": "^1.3.0" + } + }) + }; + const cacheLockConfig = { + path: "/a/data/package-lock.json", + content: JSON.stringify({ + dependencies: { + "@types/jquery": { + version: "1.3.0" + } + } + }) + }; + const jquery = { + path: "/a/data/node_modules/@types/jquery/index.d.ts", + content: "declare const $: { x: number }" + }; + const host = createServerHost([file1, packageJson, timestamps, cacheConfig, cacheLockConfig, jquery]); + const installer = new (class extends Installer { + constructor() { + super(host, { typesRegistry: createTypesRegistry("jquery") }); + } + installWorker(_requestId: number, _args: string[], _cwd: string, cb: TI.RequestCompletedAction) { + const installedTypings: string[] = []; + const typingFiles: FileOrFolder[] = []; + executeCommand(this, host, installedTypings, typingFiles, cb); + } + })(); + + const projectService = createProjectService(host, { useSingleInferredProject: true, typingsInstaller: installer }); + projectService.openClientFile(file1.path); + + checkNumberOfProjects(projectService, { inferredProjects: 1 }); + const p = projectService.inferredProjects[0]; + checkProjectActualFiles(p, [file1.path]); + + installer.installAll(/*expectedCount*/ 0); + + checkNumberOfProjects(projectService, { inferredProjects: 1 }); + checkProjectActualFiles(p, [file1.path]); + }); }); describe("Validate package name:", () => { @@ -1132,7 +1261,7 @@ namespace ts.projectSystem { const host = createServerHost([app, jquery, chroma]); const logger = trackingLogger(); - const result = JsTyping.discoverTypings(host, logger.log, [app.path, jquery.path, chroma.path], getDirectoryPath(app.path), safeList, emptyMap, { enable: true }, emptyArray); + const result = JsTyping.discoverTypings(host, logger.log, [app.path, jquery.path, chroma.path], getDirectoryPath(app.path), safeList, emptyMap, { enable: true }, emptyArray, emptyMap); const finish = logger.finish(); assert.deepEqual(finish, [ 'Inferred typings from file names: ["jquery","chroma-js"]', @@ -1148,11 +1277,11 @@ namespace ts.projectSystem { content: "" }; const host = createServerHost([f]); - const cache = createMap(); + const cache = createMap(); for (const name of JsTyping.nodeCoreModuleList) { const logger = trackingLogger(); - const result = JsTyping.discoverTypings(host, logger.log, [f.path], getDirectoryPath(f.path), emptySafeList, cache, { enable: true }, [name, "somename"]); + const result = JsTyping.discoverTypings(host, logger.log, [f.path], getDirectoryPath(f.path), emptySafeList, cache, { enable: true }, [name, "somename"], emptyMap); assert.deepEqual(logger.finish(), [ 'Inferred typings from unresolved imports: ["node","somename"]', 'Result: {"cachedTypingPaths":[],"newTypingNames":["node","somename"],"filesToWatch":["/a/b/bower_components","/a/b/node_modules"]}', @@ -1171,9 +1300,10 @@ namespace ts.projectSystem { content: "" }; const host = createServerHost([f, node]); - const cache = createMapFromTemplate({ node: node.path }); + const cache = createMapFromTemplate({ node: { typingLocation: node.path, version: Semver.parse("1.3.0") } }); + const registry = createTypesRegistry("node"); const logger = trackingLogger(); - const result = JsTyping.discoverTypings(host, logger.log, [f.path], getDirectoryPath(f.path), emptySafeList, cache, { enable: true }, ["fs", "bar"]); + const result = JsTyping.discoverTypings(host, logger.log, [f.path], getDirectoryPath(f.path), emptySafeList, cache, { enable: true }, ["fs", "bar"], registry); assert.deepEqual(logger.finish(), [ 'Inferred typings from unresolved imports: ["node","bar"]', 'Result: {"cachedTypingPaths":["/a/b/node.d.ts"],"newTypingNames":["bar"],"filesToWatch":["/a/b/bower_components","/a/b/node_modules"]}', @@ -1196,9 +1326,9 @@ namespace ts.projectSystem { content: JSON.stringify({ name: "b" }), }; const host = createServerHost([app, a, b]); - const cache = createMap(); + const cache = createMap(); const logger = trackingLogger(); - const result = JsTyping.discoverTypings(host, logger.log, [app.path], getDirectoryPath(app.path), emptySafeList, cache, { enable: true }, /*unresolvedImports*/ []); + const result = JsTyping.discoverTypings(host, logger.log, [app.path], getDirectoryPath(app.path), emptySafeList, cache, { enable: true }, /*unresolvedImports*/ [], emptyMap); assert.deepEqual(logger.finish(), [ 'Searching for typing names in /node_modules; all files: ["/node_modules/a/package.json"]', ' Found package names: ["a"]', @@ -1211,6 +1341,94 @@ namespace ts.projectSystem { filesToWatch: ["/bower_components", "/node_modules"], }); }); + + it("should install expired typings", () => { + const app = { + path: "/a/app.js", + content: "" + }; + const cachePath = "/a/cache/"; + const commander = { + path: cachePath + "node_modules/@types/commander/index.d.ts", + content: "export let x: number" + }; + const node = { + path: cachePath + "node_modules/@types/node/index.d.ts", + content: "export let y: number" + }; + const host = createServerHost([app]); + const cache = createMapFromTemplate({ + node: { typingLocation: node.path, version: Semver.parse("1.3.0") }, + commander: { typingLocation: commander.path, version: Semver.parse("1.0.0") } + }); + const registry = createTypesRegistry("node", "commander"); + const logger = trackingLogger(); + const result = JsTyping.discoverTypings(host, logger.log, [app.path], getDirectoryPath(app.path), emptySafeList, cache, { enable: true }, ["http", "commander"], registry); + assert.deepEqual(logger.finish(), [ + 'Inferred typings from unresolved imports: ["node","commander"]', + 'Result: {"cachedTypingPaths":["/a/cache/node_modules/@types/node/index.d.ts"],"newTypingNames":["commander"],"filesToWatch":["/a/bower_components","/a/node_modules"]}', + ]); + assert.deepEqual(result.cachedTypingPaths, [node.path]); + assert.deepEqual(result.newTypingNames, ["commander"]); + }); + + it("should install expired typings with prerelease version of tsserver", () => { + const app = { + path: "/a/app.js", + content: "" + }; + const cachePath = "/a/cache/"; + const node = { + path: cachePath + "node_modules/@types/node/index.d.ts", + content: "export let y: number" + }; + const host = createServerHost([app]); + const cache = createMapFromTemplate({ + node: { typingLocation: node.path, version: Semver.parse("1.0.0") } + }); + const registry = createTypesRegistry("node"); + registry.delete(`ts${ts.versionMajorMinor}`); + const logger = trackingLogger(); + const result = JsTyping.discoverTypings(host, logger.log, [app.path], getDirectoryPath(app.path), emptySafeList, cache, { enable: true }, ["http"], registry); + assert.deepEqual(logger.finish(), [ + 'Inferred typings from unresolved imports: ["node"]', + 'Result: {"cachedTypingPaths":[],"newTypingNames":["node"],"filesToWatch":["/a/bower_components","/a/node_modules"]}', + ]); + assert.deepEqual(result.cachedTypingPaths, []); + assert.deepEqual(result.newTypingNames, ["node"]); + }); + + + it("prerelease typings are properly handled", () => { + const app = { + path: "/a/app.js", + content: "" + }; + const cachePath = "/a/cache/"; + const commander = { + path: cachePath + "node_modules/@types/commander/index.d.ts", + content: "export let x: number" + }; + const node = { + path: cachePath + "node_modules/@types/node/index.d.ts", + content: "export let y: number" + }; + const host = createServerHost([app]); + const cache = createMapFromTemplate({ + node: { typingLocation: node.path, version: Semver.parse("1.3.0-next.0") }, + commander: { typingLocation: commander.path, version: Semver.parse("1.3.0-next.0") } + }); + const registry = createTypesRegistry("node", "commander"); + registry.get("node")[`ts${ts.versionMajorMinor}`] = "1.3.0-next.1"; + const logger = trackingLogger(); + const result = JsTyping.discoverTypings(host, logger.log, [app.path], getDirectoryPath(app.path), emptySafeList, cache, { enable: true }, ["http", "commander"], registry); + assert.deepEqual(logger.finish(), [ + 'Inferred typings from unresolved imports: ["node","commander"]', + 'Result: {"cachedTypingPaths":[],"newTypingNames":["node","commander"],"filesToWatch":["/a/bower_components","/a/node_modules"]}', + ]); + assert.deepEqual(result.cachedTypingPaths, []); + assert.deepEqual(result.newTypingNames, ["node", "commander"]); + }); }); describe("telemetry events", () => { @@ -1273,12 +1491,22 @@ namespace ts.projectSystem { path: "/a/package.json", content: JSON.stringify({ dependencies: { commander: "1.0.0" } }) }; + const packageLockFile = { + path: "/a/cache/package-lock.json", + content: JSON.stringify({ + dependencies: { + "@types/commander": { + version: "1.0.0" + } + } + }) + }; const cachePath = "/a/cache/"; const commander = { path: cachePath + "node_modules/@types/commander/index.d.ts", content: "export let x: number" }; - const host = createServerHost([f1, packageFile]); + const host = createServerHost([f1, packageFile, packageLockFile]); let beginEvent: server.BeginInstallTypes; let endEvent: server.EndInstallTypes; const installer = new (class extends Installer { diff --git a/src/harness/virtualFileSystemWithWatch.ts b/src/harness/virtualFileSystemWithWatch.ts index 8545e193ae4..93fdc6cdbc6 100644 --- a/src/harness/virtualFileSystemWithWatch.ts +++ b/src/harness/virtualFileSystemWithWatch.ts @@ -405,9 +405,11 @@ interface Array {}` ensureFileOrFolder(fileOrDirectory: FileOrFolder, ignoreWatchInvokedWithTriggerAsFileCreate?: boolean) { if (isString(fileOrDirectory.content)) { const file = this.toFile(fileOrDirectory); - Debug.assert(!this.fs.get(file.path)); - const baseFolder = this.ensureFolder(getDirectoryPath(file.fullPath)); - this.addFileOrFolderInFolder(baseFolder, file, ignoreWatchInvokedWithTriggerAsFileCreate); + // file may already exist when updating existing type declaration file + if (!this.fs.get(file.path)) { + const baseFolder = this.ensureFolder(getDirectoryPath(file.fullPath)); + this.addFileOrFolderInFolder(baseFolder, file, ignoreWatchInvokedWithTriggerAsFileCreate); + } } else if (isString(fileOrDirectory.symLink)) { const symLink = this.toSymLink(fileOrDirectory); diff --git a/src/lib/es5.d.ts b/src/lib/es5.d.ts index 707f749e365..0f773e78786 100644 --- a/src/lib/es5.d.ts +++ b/src/lib/es5.d.ts @@ -1338,6 +1338,31 @@ type Record = { [P in K]: T; }; +/** + * Exclude from T those types that are assignable to U + */ +type Exclude = T extends U ? never : T; + +/** + * Extract from T those types that are assignable to U + */ +type Extract = T extends U ? T : never; + +/** + * Exclude null and undefined from T + */ +type NonNullable = T extends null | undefined ? never : T; + +/** + * Obtain the return type of a function type + */ +type ReturnType any> = T extends (...args: any[]) => infer R ? R : any; + +/** + * Obtain the return type of a constructor function type + */ +type InstanceType any> = T extends new (...args: any[]) => infer R ? R : any; + /** * Marker for contextual 'this' type */ diff --git a/src/server/server.ts b/src/server/server.ts index 722193829f9..7f545ff3875 100644 --- a/src/server/server.ts +++ b/src/server/server.ts @@ -253,7 +253,7 @@ namespace ts.server { private requestMap = createMap(); // Maps operation ID to newest requestQueue entry with that ID /** We will lazily request the types registry on the first call to `isKnownTypesPackageName` and store it in `typesRegistryCache`. */ private requestedRegistry: boolean; - private typesRegistryCache: Map | undefined; + private typesRegistryCache: Map> | undefined; // This number is essentially arbitrary. Processing more than one typings request // at a time makes sense, but having too many in the pipe results in a hang diff --git a/src/server/types.ts b/src/server/types.ts index 021bf4c28d7..617a3be419a 100644 --- a/src/server/types.ts +++ b/src/server/types.ts @@ -75,7 +75,7 @@ declare namespace ts.server { /* @internal */ export interface TypesRegistryResponse extends TypingInstallerResponse { readonly kind: EventTypesRegistry; - readonly typesRegistry: MapLike; + readonly typesRegistry: MapLike>; } export interface PackageInstalledResponse extends ProjectResponse { diff --git a/src/server/typingsInstaller/nodeTypingsInstaller.ts b/src/server/typingsInstaller/nodeTypingsInstaller.ts index 36f5adab400..e51ec68561c 100644 --- a/src/server/typingsInstaller/nodeTypingsInstaller.ts +++ b/src/server/typingsInstaller/nodeTypingsInstaller.ts @@ -41,15 +41,15 @@ namespace ts.server.typingsInstaller { } interface TypesRegistryFile { - entries: MapLike; + entries: MapLike>; } - function loadTypesRegistryFile(typesRegistryFilePath: string, host: InstallTypingHost, log: Log): Map { + function loadTypesRegistryFile(typesRegistryFilePath: string, host: InstallTypingHost, log: Log): Map> { if (!host.fileExists(typesRegistryFilePath)) { if (log.isEnabled()) { log.writeLine(`Types registry file '${typesRegistryFilePath}' does not exist`); } - return createMap(); + return createMap>(); } try { const content = JSON.parse(host.readFile(typesRegistryFilePath)); @@ -59,7 +59,7 @@ namespace ts.server.typingsInstaller { if (log.isEnabled()) { log.writeLine(`Error when loading types registry file '${typesRegistryFilePath}': ${(e).message}, ${(e).stack}`); } - return createMap(); + return createMap>(); } } @@ -77,7 +77,7 @@ namespace ts.server.typingsInstaller { export class NodeTypingsInstaller extends TypingsInstaller { private readonly nodeExecSync: ExecSync; private readonly npmPath: string; - readonly typesRegistry: Map; + readonly typesRegistry: Map>; private delayedInitializationError: InitializationFailedResponse | undefined; @@ -141,7 +141,7 @@ namespace ts.server.typingsInstaller { this.closeProject(req); break; case "typesRegistry": { - const typesRegistry: { [key: string]: void } = {}; + const typesRegistry: { [key: string]: MapLike } = {}; this.typesRegistry.forEach((value, key) => { typesRegistry[key] = value; }); diff --git a/src/server/typingsInstaller/typingsInstaller.ts b/src/server/typingsInstaller/typingsInstaller.ts index 283770d1dc8..465f281006e 100644 --- a/src/server/typingsInstaller/typingsInstaller.ts +++ b/src/server/typingsInstaller/typingsInstaller.ts @@ -1,6 +1,7 @@ /// /// /// +/// /// /// @@ -9,6 +10,10 @@ namespace ts.server.typingsInstaller { devDependencies: MapLike; } + interface NpmLock { + dependencies: { [packageName: string]: { version: string } }; + } + export interface Log { isEnabled(): boolean; writeLine(text: string): void; @@ -42,7 +47,7 @@ namespace ts.server.typingsInstaller { } export abstract class TypingsInstaller { - private readonly packageNameToTypingLocation: Map = createMap(); + private readonly packageNameToTypingLocation: Map = createMap(); private readonly missingTypingsSet: Map = createMap(); private readonly knownCachesSet: Map = createMap(); private readonly projectWatchers: Map = createMap(); @@ -52,7 +57,7 @@ namespace ts.server.typingsInstaller { private installRunCount = 1; private inFlightRequestCount = 0; - abstract readonly typesRegistry: Map; + abstract readonly typesRegistry: Map>; constructor( protected readonly installTypingHost: InstallTypingHost, @@ -117,7 +122,8 @@ namespace ts.server.typingsInstaller { this.safeList, this.packageNameToTypingLocation, req.typeAcquisition, - req.unresolvedImports); + req.unresolvedImports, + this.typesRegistry); if (this.log.isEnabled()) { this.log.writeLine(`Finished typings discovery: ${JSON.stringify(discoverTypingsResult)}`); @@ -156,23 +162,30 @@ namespace ts.server.typingsInstaller { if (this.log.isEnabled()) { this.log.writeLine(`Processing cache location '${cacheLocation}'`); } - if (this.knownCachesSet.get(cacheLocation)) { + if (this.knownCachesSet.has(cacheLocation)) { if (this.log.isEnabled()) { this.log.writeLine(`Cache location was already processed...`); } return; } const packageJson = combinePaths(cacheLocation, "package.json"); + const packageLockJson = combinePaths(cacheLocation, "package-lock.json"); if (this.log.isEnabled()) { this.log.writeLine(`Trying to find '${packageJson}'...`); } - if (this.installTypingHost.fileExists(packageJson)) { + if (this.installTypingHost.fileExists(packageJson) && this.installTypingHost.fileExists(packageLockJson)) { const npmConfig = JSON.parse(this.installTypingHost.readFile(packageJson)); + const npmLock = JSON.parse(this.installTypingHost.readFile(packageLockJson)); if (this.log.isEnabled()) { this.log.writeLine(`Loaded content of '${packageJson}': ${JSON.stringify(npmConfig)}`); + this.log.writeLine(`Loaded content of '${packageLockJson}'`); } - if (npmConfig.devDependencies) { + if (npmConfig.devDependencies && npmLock.dependencies) { for (const key in npmConfig.devDependencies) { + if (!hasProperty(npmLock.dependencies, key)) { + // if package in package.json but not package-lock.json, skip adding to cache so it is reinstalled on next use + continue; + } // key is @types/ const packageName = getBaseFileName(key); if (!packageName) { @@ -184,10 +197,11 @@ namespace ts.server.typingsInstaller { continue; } const existingTypingFile = this.packageNameToTypingLocation.get(packageName); - if (existingTypingFile === typingFile) { - continue; - } if (existingTypingFile) { + if (existingTypingFile.typingLocation === typingFile) { + continue; + } + if (this.log.isEnabled()) { this.log.writeLine(`New typing for package ${packageName} from '${typingFile}' conflicts with existing typing file '${existingTypingFile}'`); } @@ -195,7 +209,11 @@ namespace ts.server.typingsInstaller { if (this.log.isEnabled()) { this.log.writeLine(`Adding entry into typings cache: '${packageName}' => '${typingFile}'`); } - this.packageNameToTypingLocation.set(packageName, typingFile); + const info = getProperty(npmLock.dependencies, key); + const version = info && info.version; + const semver = Semver.parse(version); + const newTyping: JsTyping.CachedTyping = { typingLocation: typingFile, version: semver }; + this.packageNameToTypingLocation.set(packageName, newTyping); } } } @@ -211,10 +229,6 @@ namespace ts.server.typingsInstaller { if (this.log.isEnabled()) this.log.writeLine(`'${typing}' is in missingTypingsSet - skipping...`); return false; } - if (this.packageNameToTypingLocation.get(typing)) { - if (this.log.isEnabled()) this.log.writeLine(`'${typing}' already has a typing - skipping...`); - return false; - } const validationResult = JsTyping.validatePackageName(typing); if (validationResult !== JsTyping.PackageNameValidationResult.Ok) { // add typing name to missing set so we won't process it again @@ -226,6 +240,10 @@ namespace ts.server.typingsInstaller { if (this.log.isEnabled()) this.log.writeLine(`Entry for package '${typing}' does not exist in local types registry - skipping...`); return false; } + if (this.packageNameToTypingLocation.get(typing) && JsTyping.isTypingUpToDate(this.packageNameToTypingLocation.get(typing), this.typesRegistry.get(typing))) { + if (this.log.isEnabled()) this.log.writeLine(`'${typing}' already has an up-to-date typing - skipping...`); + return false; + } return true; }); } @@ -294,9 +312,12 @@ namespace ts.server.typingsInstaller { this.missingTypingsSet.set(packageName, true); continue; } - if (!this.packageNameToTypingLocation.has(packageName)) { - this.packageNameToTypingLocation.set(packageName, typingFile); - } + + // packageName is guaranteed to exist in typesRegistry by filterTypings + const distTags = this.typesRegistry.get(packageName); + const newVersion = Semver.parse(distTags[`ts${ts.versionMajorMinor}`] || distTags[latestDistTag]); + const newTyping: JsTyping.CachedTyping = { typingLocation: typingFile, version: newVersion }; + this.packageNameToTypingLocation.set(packageName, newTyping); installedTypingFiles.push(typingFile); } if (this.log.isEnabled()) { @@ -390,4 +411,6 @@ namespace ts.server.typingsInstaller { export function typingsName(packageName: string): string { return `@types/${packageName}@ts${versionMajorMinor}`; } + + const latestDistTag = "latest"; } \ No newline at end of file diff --git a/src/services/completions.ts b/src/services/completions.ts index 2add52cc3dd..c6d5f015279 100644 --- a/src/services/completions.ts +++ b/src/services/completions.ts @@ -712,7 +712,7 @@ namespace ts.Completions { function getFirstSymbolInChain(symbol: Symbol, enclosingDeclaration: Node, checker: TypeChecker): Symbol | undefined { const chain = checker.getAccessibleSymbolChain(symbol, enclosingDeclaration, /*meaning*/ SymbolFlags.All, /*useOnlyExternalAliasing*/ false); if (chain) return first(chain); - return isModuleSymbol(symbol.parent) ? symbol : symbol.parent && getFirstSymbolInChain(symbol.parent, enclosingDeclaration, checker); + return symbol.parent && (isModuleSymbol(symbol.parent) ? symbol : getFirstSymbolInChain(symbol.parent, enclosingDeclaration, checker)); } function isModuleSymbol(symbol: Symbol): boolean { diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts index 8b9937394f1..acc3e6ac4cb 100644 --- a/src/services/findAllReferences.ts +++ b/src/services/findAllReferences.ts @@ -416,10 +416,16 @@ namespace ts.FindAllReferences.Core { } // If the symbol is declared as part of a declaration like `{ type: "a" } | { type: "b" }`, use the property on the union type to get more references. - return firstDefined(symbol.declarations, decl => - isTypeLiteralNode(decl.parent) && isUnionTypeNode(decl.parent.parent) + return firstDefined(symbol.declarations, decl => { + if (!decl.parent) { + // Assertions for GH#21814. We should be handling SourceFile symbols in `getReferencedSymbolsForModule` instead of getting here. + Debug.assert(decl.kind === SyntaxKind.SourceFile); + Debug.fail(`Unexpected symbol at ${Debug.showSyntaxKind(node)}: ${Debug.showSymbol(symbol)}`); + } + return isTypeLiteralNode(decl.parent) && isUnionTypeNode(decl.parent.parent) ? checker.getPropertyOfType(checker.getTypeFromTypeNode(decl.parent.parent), symbol.name) - : undefined) || symbol; + : undefined; + }) || symbol; } /** @@ -914,7 +920,8 @@ namespace ts.FindAllReferences.Core { // At `export { x } from "foo"`, also search for the imported symbol `"foo".x`. if (search.comingFrom !== ImportExport.Export && exportDeclaration.moduleSpecifier && !propertyName) { - searchForImportedSymbol(state.checker.getExportSpecifierLocalTargetSymbol(exportSpecifier), state); + const imported = state.checker.getExportSpecifierLocalTargetSymbol(exportSpecifier); + if (imported) searchForImportedSymbol(imported, state); } function addRef() { @@ -923,7 +930,7 @@ namespace ts.FindAllReferences.Core { } function getLocalSymbolForExportSpecifier(referenceLocation: Identifier, referenceSymbol: Symbol, exportSpecifier: ExportSpecifier, checker: TypeChecker): Symbol { - return isExportSpecifierAlias(referenceLocation, exportSpecifier) ? checker.getExportSpecifierLocalTargetSymbol(exportSpecifier) : referenceSymbol; + return isExportSpecifierAlias(referenceLocation, exportSpecifier) && checker.getExportSpecifierLocalTargetSymbol(exportSpecifier) || referenceSymbol; } function isExportSpecifierAlias(referenceLocation: Identifier, exportSpecifier: ExportSpecifier): boolean { diff --git a/src/services/importTracker.ts b/src/services/importTracker.ts index 91544e209cb..d3e57b124de 100644 --- a/src/services/importTracker.ts +++ b/src/services/importTracker.ts @@ -517,29 +517,12 @@ namespace ts.FindAllReferences { const sym = useLhsSymbol ? checker.getSymbolAtLocation(cast(node.left, isPropertyAccessExpression).name) : symbol; // Better detection for GH#20803 if (sym && !(checker.getMergedSymbol(sym.parent).flags & SymbolFlags.Module)) { - Debug.fail(`Special property assignment kind does not have a module as its parent. Assignment is ${showSymbol(sym)}, parent is ${showSymbol(sym.parent)}`); + Debug.fail(`Special property assignment kind does not have a module as its parent. Assignment is ${Debug.showSymbol(sym)}, parent is ${Debug.showSymbol(sym.parent)}`); } return sym && exportInfo(sym, kind); } } - function showSymbol(s: Symbol): string { - const decls = s.declarations.map(d => (ts as any).SyntaxKind[d.kind]).join(","); - const flags = showFlags(s.flags, (ts as any).SymbolFlags); - return `{ declarations: ${decls}, flags: ${flags} }`; - } - - function showFlags(f: number, flags: any) { - const out = []; - for (let pow = 0; pow <= 30; pow++) { - const n = 1 << pow; - if (f & n) { - out.push(flags[n]); - } - } - return out.join("|"); - } - function getImport(): ImportedSymbol | undefined { const isImport = isNodeImport(node); if (!isImport) return undefined; @@ -577,17 +560,17 @@ namespace ts.FindAllReferences { function getExportEqualsLocalSymbol(importedSymbol: Symbol, checker: TypeChecker): Symbol { if (importedSymbol.flags & SymbolFlags.Alias) { - return checker.getImmediateAliasedSymbol(importedSymbol); + return Debug.assertDefined(checker.getImmediateAliasedSymbol(importedSymbol)); } const decl = importedSymbol.valueDeclaration; if (isExportAssignment(decl)) { // `export = class {}` - return decl.expression.symbol; + return Debug.assertDefined(decl.expression.symbol); } else if (isBinaryExpression(decl)) { // `module.exports = class {}` - return decl.right.symbol; + return Debug.assertDefined(decl.right.symbol); } - Debug.fail(); + return Debug.fail(); } // If a reference is a class expression, the exported node would be its parent. @@ -623,7 +606,9 @@ namespace ts.FindAllReferences { } export function getExportInfo(exportSymbol: Symbol, exportKind: ExportKind, checker: TypeChecker): ExportInfo | undefined { - const exportingModuleSymbol = checker.getMergedSymbol(exportSymbol.parent); // Need to get merged symbol in case there's an augmentation. + const moduleSymbol = exportSymbol.parent; + if (!moduleSymbol) return undefined; // This can happen if an `export` is not at the top-level (which is a compile error). + const exportingModuleSymbol = checker.getMergedSymbol(moduleSymbol); // Need to get merged symbol in case there's an augmentation. // `export` may appear in a namespace. In that case, just rely on global search. return isExternalModuleSymbol(exportingModuleSymbol) ? { exportingModuleSymbol, exportKind } : undefined; } diff --git a/src/services/jsTyping.ts b/src/services/jsTyping.ts index 1c2f87fa428..bd6c2e5cb9f 100644 --- a/src/services/jsTyping.ts +++ b/src/services/jsTyping.ts @@ -4,6 +4,7 @@ /// /// /// +/// /* @internal */ namespace ts.JsTyping { @@ -26,6 +27,17 @@ namespace ts.JsTyping { typings?: string; } + export interface CachedTyping { + typingLocation: string; + version: Semver; + } + + /* @internal */ + export function isTypingUpToDate(cachedTyping: JsTyping.CachedTyping, availableTypingVersions: MapLike) { + const availableVersion = Semver.parse(getProperty(availableTypingVersions, `ts${ts.versionMajorMinor}`) || getProperty(availableTypingVersions, "latest")); + return !availableVersion.greaterThan(cachedTyping.version); + } + /* @internal */ export const nodeCoreModuleList: ReadonlyArray = [ "buffer", "querystring", "events", "http", "cluster", @@ -60,7 +72,7 @@ namespace ts.JsTyping { * @param fileNames are the file names that belong to the same project * @param projectRootPath is the path to the project root directory * @param safeListPath is the path used to retrieve the safe list - * @param packageNameToTypingLocation is the map of package names to their cached typing locations + * @param packageNameToTypingLocation is the map of package names to their cached typing locations and installed versions * @param typeAcquisition is used to customize the typing acquisition process * @param compilerOptions are used as a source for typing inference */ @@ -70,9 +82,10 @@ namespace ts.JsTyping { fileNames: string[], projectRootPath: Path, safeList: SafeList, - packageNameToTypingLocation: ReadonlyMap, + packageNameToTypingLocation: ReadonlyMap, typeAcquisition: TypeAcquisition, - unresolvedImports: ReadonlyArray): + unresolvedImports: ReadonlyArray, + typesRegistry: ReadonlyMap>): { cachedTypingPaths: string[], newTypingNames: string[], filesToWatch: string[] } { if (!typeAcquisition || !typeAcquisition.enable) { @@ -122,9 +135,9 @@ namespace ts.JsTyping { addInferredTypings(module, "Inferred typings from unresolved imports"); } // Add the cached typing locations for inferred typings that are already installed - packageNameToTypingLocation.forEach((typingLocation, name) => { - if (inferredTypings.has(name) && inferredTypings.get(name) === undefined) { - inferredTypings.set(name, typingLocation); + packageNameToTypingLocation.forEach((typing, name) => { + if (inferredTypings.has(name) && inferredTypings.get(name) === undefined && isTypingUpToDate(typing, typesRegistry.get(name))) { + inferredTypings.set(name, typing.typingLocation); } }); diff --git a/src/services/refactors/convertToEs6Module.ts b/src/services/refactors/convertToEs6Module.ts index 5a7f2e90718..65f9f58ccc4 100644 --- a/src/services/refactors/convertToEs6Module.ts +++ b/src/services/refactors/convertToEs6Module.ts @@ -33,8 +33,8 @@ namespace ts.refactor { return isExportsOrModuleExportsOrAlias(sourceFile, node as PropertyAccessExpression) || isExportsOrModuleExportsOrAlias(sourceFile, (node as PropertyAccessExpression).expression); case SyntaxKind.VariableDeclarationList: - const decl = (node as VariableDeclarationList).declarations[0]; - return isExportsOrModuleExportsOrAlias(sourceFile, decl.initializer); + const decl = firstOrUndefined((node as VariableDeclarationList).declarations); + return !!decl && isExportsOrModuleExportsOrAlias(sourceFile, decl.initializer); case SyntaxKind.VariableDeclaration: return isExportsOrModuleExportsOrAlias(sourceFile, (node as VariableDeclaration).initializer); default: diff --git a/src/services/refactors/extractSymbol.ts b/src/services/refactors/extractSymbol.ts index 74a944077ec..20895d7992a 100644 --- a/src/services/refactors/extractSymbol.ts +++ b/src/services/refactors/extractSymbol.ts @@ -968,7 +968,7 @@ namespace ts.refactor.extractSymbol { } if (isReadonlyArray(range.range)) { - changeTracker.replaceNodesWithNodes(context.file, range.range, newNodes); + changeTracker.replaceNodeRangeWithNodes(context.file, first(range.range), last(range.range), newNodes); } else { changeTracker.replaceNodeWithNodes(context.file, range.range, newNodes); diff --git a/src/services/semver.ts b/src/services/semver.ts new file mode 100644 index 00000000000..1c58da8c8f7 --- /dev/null +++ b/src/services/semver.ts @@ -0,0 +1,61 @@ +/* @internal */ +namespace ts { + function stringToInt(str: string): number { + const n = parseInt(str, 10); + if (isNaN(n)) { + throw new Error(`Error in parseInt(${JSON.stringify(str)})`); + } + return n; + } + + const isPrereleaseRegex = /^(.*)-next.\d+/; + const prereleaseSemverRegex = /^(\d+)\.(\d+)\.0-next.(\d+)$/; + const semverRegex = /^(\d+)\.(\d+)\.(\d+)$/; + + export class Semver { + static parse(semver: string): Semver { + const isPrerelease = isPrereleaseRegex.test(semver); + const result = Semver.tryParse(semver, isPrerelease); + if (!result) { + throw new Error(`Unexpected semver: ${semver} (isPrerelease: ${isPrerelease})`); + } + return result; + } + + static fromRaw({ major, minor, patch, isPrerelease }: Semver): Semver { + return new Semver(major, minor, patch, isPrerelease); + } + + // This must parse the output of `versionString`. + private static tryParse(semver: string, isPrerelease: boolean): Semver | undefined { + // Per the semver spec : + // "A normal version number MUST take the form X.Y.Z where X, Y, and Z are non-negative integers, and MUST NOT contain leading zeroes." + const rgx = isPrerelease ? prereleaseSemverRegex : semverRegex; + const match = rgx.exec(semver); + return match ? new Semver(stringToInt(match[1]), stringToInt(match[2]), stringToInt(match[3]), isPrerelease) : undefined; + } + + private constructor( + readonly major: number, readonly minor: number, readonly patch: number, + /** + * If true, this is `major.minor.0-next.patch`. + * If false, this is `major.minor.patch`. + */ + readonly isPrerelease: boolean) { } + + get versionString(): string { + return this.isPrerelease ? `${this.major}.${this.minor}.0-next.${this.patch}` : `${this.major}.${this.minor}.${this.patch}`; + } + + equals(sem: Semver): boolean { + return this.major === sem.major && this.minor === sem.minor && this.patch === sem.patch && this.isPrerelease === sem.isPrerelease; + } + + greaterThan(sem: Semver): boolean { + return this.major > sem.major || this.major === sem.major + && (this.minor > sem.minor || this.minor === sem.minor + && (!this.isPrerelease && sem.isPrerelease || this.isPrerelease === sem.isPrerelease + && this.patch > sem.patch)); + } + } +} \ No newline at end of file diff --git a/src/services/shims.ts b/src/services/shims.ts index 30a836a113f..11e397f526a 100644 --- a/src/services/shims.ts +++ b/src/services/shims.ts @@ -24,6 +24,17 @@ let debugObjectHost: { CollectGarbage(): void } = (function (this: any) { return /* @internal */ namespace ts { + interface DiscoverTypingsInfo { + fileNames: string[]; // The file names that belong to the same project. + projectRootPath: string; // The path to the project root directory + safeListPath: string; // The path used to retrieve the safe list + packageNameToTypingLocation: Map; // The map of package names to their cached typing locations and installed versions + typeAcquisition: TypeAcquisition; // Used to customize the type acquisition process + compilerOptions: CompilerOptions; // Used as a source for typing inference + unresolvedImports: ReadonlyArray; // List of unresolved module ids from imports + typesRegistry: ReadonlyMap>; // The map of available typings in npm to maps of TS versions to their latest supported versions + } + export interface ScriptSnapshotShim { /** Gets a portion of the script snapshot specified by [start, end). */ getText(start: number, end: number): string; @@ -1159,7 +1170,8 @@ namespace ts { this.safeList, info.packageNameToTypingLocation, info.typeAcquisition, - info.unresolvedImports); + info.unresolvedImports, + info.typesRegistry); }); } } diff --git a/src/services/textChanges.ts b/src/services/textChanges.ts index 743bd956d41..d093aef3d1a 100644 --- a/src/services/textChanges.ts +++ b/src/services/textChanges.ts @@ -28,9 +28,11 @@ namespace ts.textChanges { } export interface ConfigurableStart { + /** True to use getStart() (NB, not getFullStart()) without adjustment. */ useNonAdjustedStartPosition?: boolean; } export interface ConfigurableEnd { + /** True to use getEnd() without adjustment. */ useNonAdjustedEndPosition?: boolean; } @@ -132,7 +134,7 @@ namespace ts.textChanges { export function getAdjustedStartPosition(sourceFile: SourceFile, node: Node, options: ConfigurableStart, position: Position) { if (options.useNonAdjustedStartPosition) { - return node.getFullStart(); + return node.getStart(); } const fullStart = node.getFullStart(); const start = node.getStart(sourceFile); @@ -280,51 +282,46 @@ namespace ts.textChanges { return this; } - public replaceRange(sourceFile: SourceFile, range: TextRange, newNode: Node, options: InsertNodeOptions = {}) { + public replaceRange(sourceFile: SourceFile, range: TextRange, newNode: Node, options: ChangeNodeOptions = {}) { this.changes.push({ kind: ChangeKind.ReplaceWithSingleNode, sourceFile, range, options, node: newNode }); return this; } public replaceNode(sourceFile: SourceFile, oldNode: Node, newNode: Node, options: ChangeNodeOptions = {}) { - const startPosition = getAdjustedStartPosition(sourceFile, oldNode, options, Position.Start); - const endPosition = getAdjustedEndPosition(sourceFile, oldNode, options); - return this.replaceWithSingle(sourceFile, startPosition, endPosition, newNode, options); + const pos = getAdjustedStartPosition(sourceFile, oldNode, options, Position.Start); + const end = getAdjustedEndPosition(sourceFile, oldNode, options); + return this.replaceRange(sourceFile, { pos, end }, newNode, options); } public replaceNodeRange(sourceFile: SourceFile, startNode: Node, endNode: Node, newNode: Node, options: ChangeNodeOptions = {}) { - const startPosition = getAdjustedStartPosition(sourceFile, startNode, options, Position.Start); - const endPosition = getAdjustedEndPosition(sourceFile, endNode, options); - return this.replaceWithSingle(sourceFile, startPosition, endPosition, newNode, options); + const pos = getAdjustedStartPosition(sourceFile, startNode, options, Position.Start); + const end = getAdjustedEndPosition(sourceFile, endNode, options); + return this.replaceRange(sourceFile, { pos, end }, newNode, options); } - private replaceWithSingle(sourceFile: SourceFile, startPosition: number, endPosition: number, newNode: Node, options: ChangeNodeOptions): this { - this.changes.push({ - kind: ChangeKind.ReplaceWithSingleNode, - sourceFile, - options, - node: newNode, - range: { pos: startPosition, end: endPosition } - }); + private getDefaultChangeMultipleNodesOptions(): ChangeMultipleNodesOptions { + return { + nodeSeparator: this.newLineCharacter, + useNonAdjustedStartPosition: true, + useNonAdjustedEndPosition: true, + }; + } + + public replaceRangeWithNodes(sourceFile: SourceFile, range: TextRange, newNodes: ReadonlyArray, options: ChangeMultipleNodesOptions = this.getDefaultChangeMultipleNodesOptions()) { + this.changes.push({ kind: ChangeKind.ReplaceWithMultipleNodes, sourceFile, range, options, nodes: newNodes }); return this; } - private replaceWithMultiple(sourceFile: SourceFile, startPosition: number, endPosition: number, newNodes: ReadonlyArray, options: ChangeMultipleNodesOptions): this { - this.changes.push({ - kind: ChangeKind.ReplaceWithMultipleNodes, - sourceFile, - options, - nodes: newNodes, - range: { pos: startPosition, end: endPosition } - }); - return this; + public replaceNodeWithNodes(sourceFile: SourceFile, oldNode: Node, newNodes: ReadonlyArray, options: ChangeMultipleNodesOptions = this.getDefaultChangeMultipleNodesOptions()) { + const pos = getAdjustedStartPosition(sourceFile, oldNode, options, Position.Start); + const end = getAdjustedEndPosition(sourceFile, oldNode, options); + return this.replaceRangeWithNodes(sourceFile, { pos, end }, newNodes, options); } - public replaceNodeWithNodes(sourceFile: SourceFile, oldNode: Node, newNodes: ReadonlyArray): void { - this.replaceWithMultiple(sourceFile, oldNode.getStart(sourceFile), oldNode.getEnd(), newNodes, { nodeSeparator: this.newLineCharacter }); - } - - public replaceNodesWithNodes(sourceFile: SourceFile, oldNodes: ReadonlyArray, newNodes: ReadonlyArray): void { - this.replaceWithMultiple(sourceFile, first(oldNodes).getStart(sourceFile), last(oldNodes).getEnd(), newNodes, { nodeSeparator: this.newLineCharacter }); + public replaceNodeRangeWithNodes(sourceFile: SourceFile, startNode: Node, endNode: Node, newNodes: ReadonlyArray, options: ChangeMultipleNodesOptions = this.getDefaultChangeMultipleNodesOptions()) { + const pos = getAdjustedStartPosition(sourceFile, startNode, options, Position.Start); + const end = getAdjustedEndPosition(sourceFile, endNode, options); + return this.replaceRangeWithNodes(sourceFile, { pos, end }, newNodes, options); } private insertNodeAt(sourceFile: SourceFile, pos: number, newNode: Node, options: InsertNodeOptions = {}) { @@ -341,18 +338,18 @@ namespace ts.textChanges { } public insertNodeBefore(sourceFile: SourceFile, before: Node, newNode: Node, blankLineBetween = false) { - const startPosition = getAdjustedStartPosition(sourceFile, before, {}, Position.Start); - return this.replaceWithSingle(sourceFile, startPosition, startPosition, newNode, this.getOptionsForInsertNodeBefore(before, blankLineBetween)); + const pos = getAdjustedStartPosition(sourceFile, before, {}, Position.Start); + return this.replaceRange(sourceFile, { pos, end: pos }, newNode, this.getOptionsForInsertNodeBefore(before, blankLineBetween)); } public insertModifierBefore(sourceFile: SourceFile, modifier: SyntaxKind, before: Node): void { const pos = before.getStart(sourceFile); - this.replaceWithSingle(sourceFile, pos, pos, createToken(modifier), { suffix: " " }); + this.replaceRange(sourceFile, { pos, end: pos }, createToken(modifier), { suffix: " " }); } public changeIdentifierToPropertyAccess(sourceFile: SourceFile, prefix: string, node: Identifier): void { - const startPosition = getAdjustedStartPosition(sourceFile, node, {}, Position.Start); - this.replaceWithSingle(sourceFile, startPosition, startPosition, createPropertyAccess(createIdentifier(prefix), ""), {}); + const pos = getAdjustedStartPosition(sourceFile, node, {}, Position.Start); + this.replaceRange(sourceFile, { pos, end: pos }, createPropertyAccess(createIdentifier(prefix), ""), {}); } private getOptionsForInsertNodeBefore(before: Node, doubleNewlines: boolean): ChangeNodeOptions { @@ -390,8 +387,8 @@ namespace ts.textChanges { } public insertNodeAtEndOfScope(sourceFile: SourceFile, scope: Node, newNode: Node): void { - const startPosition = getAdjustedStartPosition(sourceFile, scope.getLastToken(), {}, Position.Start); - this.replaceWithSingle(sourceFile, startPosition, startPosition, newNode, { + const pos = getAdjustedStartPosition(sourceFile, scope.getLastToken(), {}, Position.Start); + this.replaceRange(sourceFile, { pos, end: pos }, newNode, { prefix: isLineBreak(sourceFile.text.charCodeAt(scope.getLastToken().pos)) ? this.newLineCharacter : this.newLineCharacter + this.newLineCharacter, suffix: this.newLineCharacter }); @@ -433,7 +430,7 @@ namespace ts.textChanges { } } const endPosition = getAdjustedEndPosition(sourceFile, after, {}); - return this.replaceWithSingle(sourceFile, endPosition, endPosition, newNode, this.getInsertNodeAfterOptions(after)); + return this.replaceRange(sourceFile, { pos: endPosition, end: endPosition }, newNode, this.getInsertNodeAfterOptions(after)); } private getInsertNodeAfterOptions(node: Node): InsertNodeOptions { diff --git a/src/services/tsconfig.json b/src/services/tsconfig.json index 13a7a30d845..ef0d68b2041 100644 --- a/src/services/tsconfig.json +++ b/src/services/tsconfig.json @@ -66,6 +66,7 @@ "services.ts", "transform.ts", "transpile.ts", + "semver.ts", "shims.ts", "signatureHelp.ts", "symbolDisplay.ts", diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts index efb8633652f..15373167e39 100644 --- a/tests/baselines/reference/api/tsserverlibrary.d.ts +++ b/tests/baselines/reference/api/tsserverlibrary.d.ts @@ -2374,15 +2374,6 @@ declare namespace ts { exclude?: string[]; [option: string]: string[] | boolean | undefined; } - interface DiscoverTypingsInfo { - fileNames: string[]; - projectRootPath: string; - safeListPath: string; - packageNameToTypingLocation: Map; - typeAcquisition: TypeAcquisition; - compilerOptions: CompilerOptions; - unresolvedImports: ReadonlyArray; - } enum ModuleKind { None = 0, CommonJS = 1, diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts index 51b6ffa53b0..4593f659f50 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -2374,15 +2374,6 @@ declare namespace ts { exclude?: string[]; [option: string]: string[] | boolean | undefined; } - interface DiscoverTypingsInfo { - fileNames: string[]; - projectRootPath: string; - safeListPath: string; - packageNameToTypingLocation: Map; - typeAcquisition: TypeAcquisition; - compilerOptions: CompilerOptions; - unresolvedImports: ReadonlyArray; - } enum ModuleKind { None = 0, CommonJS = 1, diff --git a/tests/baselines/reference/conditionalTypes1.errors.txt b/tests/baselines/reference/conditionalTypes1.errors.txt index 574e6c45ee2..b79ec721e97 100644 --- a/tests/baselines/reference/conditionalTypes1.errors.txt +++ b/tests/baselines/reference/conditionalTypes1.errors.txt @@ -1,22 +1,22 @@ -tests/cases/conformance/types/conditional/conditionalTypes1.ts(16,5): error TS2322: Type 'T' is not assignable to type 'Diff'. -tests/cases/conformance/types/conditional/conditionalTypes1.ts(21,5): error TS2322: Type 'T' is not assignable to type 'Diff'. - Type 'string | undefined' is not assignable to type 'Diff'. - Type 'undefined' is not assignable to type 'Diff'. -tests/cases/conformance/types/conditional/conditionalTypes1.ts(22,9): error TS2322: Type 'T' is not assignable to type 'string'. +tests/cases/conformance/types/conditional/conditionalTypes1.ts(12,5): error TS2322: Type 'T' is not assignable to type 'NonNullable'. +tests/cases/conformance/types/conditional/conditionalTypes1.ts(17,5): error TS2322: Type 'T' is not assignable to type 'NonNullable'. + Type 'string | undefined' is not assignable to type 'NonNullable'. + Type 'undefined' is not assignable to type 'NonNullable'. +tests/cases/conformance/types/conditional/conditionalTypes1.ts(18,9): error TS2322: Type 'T' is not assignable to type 'string'. Type 'string | undefined' is not assignable to type 'string'. Type 'undefined' is not assignable to type 'string'. -tests/cases/conformance/types/conditional/conditionalTypes1.ts(28,5): error TS2322: Type 'Partial[keyof T]' is not assignable to type 'Diff[keyof T], null | undefined>'. - Type 'T[keyof T] | undefined' is not assignable to type 'Diff[keyof T], null | undefined>'. - Type 'undefined' is not assignable to type 'Diff[keyof T], null | undefined>'. -tests/cases/conformance/types/conditional/conditionalTypes1.ts(33,5): error TS2322: Type 'T["x"]' is not assignable to type 'Diff'. - Type 'string | undefined' is not assignable to type 'Diff'. - Type 'undefined' is not assignable to type 'Diff'. -tests/cases/conformance/types/conditional/conditionalTypes1.ts(34,9): error TS2322: Type 'T["x"]' is not assignable to type 'string'. +tests/cases/conformance/types/conditional/conditionalTypes1.ts(24,5): error TS2322: Type 'Partial[keyof T]' is not assignable to type 'NonNullable[keyof T]>'. + Type 'T[keyof T] | undefined' is not assignable to type 'NonNullable[keyof T]>'. + Type 'undefined' is not assignable to type 'NonNullable[keyof T]>'. +tests/cases/conformance/types/conditional/conditionalTypes1.ts(29,5): error TS2322: Type 'T["x"]' is not assignable to type 'NonNullable'. + Type 'string | undefined' is not assignable to type 'NonNullable'. + Type 'undefined' is not assignable to type 'NonNullable'. +tests/cases/conformance/types/conditional/conditionalTypes1.ts(30,9): error TS2322: Type 'T["x"]' is not assignable to type 'string'. Type 'string | undefined' is not assignable to type 'string'. Type 'undefined' is not assignable to type 'string'. -tests/cases/conformance/types/conditional/conditionalTypes1.ts(107,5): error TS2322: Type 'Pick' is not assignable to type 'T'. -tests/cases/conformance/types/conditional/conditionalTypes1.ts(108,5): error TS2322: Type 'Pick' is not assignable to type 'T'. -tests/cases/conformance/types/conditional/conditionalTypes1.ts(110,5): error TS2322: Type 'Pick' is not assignable to type 'Pick'. +tests/cases/conformance/types/conditional/conditionalTypes1.ts(103,5): error TS2322: Type 'Pick' is not assignable to type 'T'. +tests/cases/conformance/types/conditional/conditionalTypes1.ts(104,5): error TS2322: Type 'Pick' is not assignable to type 'T'. +tests/cases/conformance/types/conditional/conditionalTypes1.ts(106,5): error TS2322: Type 'Pick' is not assignable to type 'Pick'. Type '{ [K in keyof T]: T[K] extends Function ? K : never; }[keyof T]' is not assignable to type '{ [K in keyof T]: T[K] extends Function ? never : K; }[keyof T]'. Type 'T[keyof T] extends Function ? keyof T : never' is not assignable to type '{ [K in keyof T]: T[K] extends Function ? never : K; }[keyof T]'. Type 'keyof T' is not assignable to type '{ [K in keyof T]: T[K] extends Function ? never : K; }[keyof T]'. @@ -25,7 +25,7 @@ tests/cases/conformance/types/conditional/conditionalTypes1.ts(110,5): error TS2 Type '{ [K in keyof T]: T[K] extends Function ? K : never; }[keyof T]' is not assignable to type 'T[keyof T] extends Function ? never : keyof T'. Type 'T[keyof T] extends Function ? keyof T : never' is not assignable to type 'T[keyof T] extends Function ? never : keyof T'. Type 'keyof T' is not assignable to type 'never'. -tests/cases/conformance/types/conditional/conditionalTypes1.ts(112,5): error TS2322: Type 'Pick' is not assignable to type 'Pick'. +tests/cases/conformance/types/conditional/conditionalTypes1.ts(108,5): error TS2322: Type 'Pick' is not assignable to type 'Pick'. Type '{ [K in keyof T]: T[K] extends Function ? never : K; }[keyof T]' is not assignable to type '{ [K in keyof T]: T[K] extends Function ? K : never; }[keyof T]'. Type 'T[keyof T] extends Function ? never : keyof T' is not assignable to type '{ [K in keyof T]: T[K] extends Function ? K : never; }[keyof T]'. Type 'keyof T' is not assignable to type '{ [K in keyof T]: T[K] extends Function ? K : never; }[keyof T]'. @@ -34,51 +34,47 @@ tests/cases/conformance/types/conditional/conditionalTypes1.ts(112,5): error TS2 Type '{ [K in keyof T]: T[K] extends Function ? never : K; }[keyof T]' is not assignable to type 'T[keyof T] extends Function ? keyof T : never'. Type 'T[keyof T] extends Function ? never : keyof T' is not assignable to type 'T[keyof T] extends Function ? keyof T : never'. Type 'keyof T' is not assignable to type 'never'. -tests/cases/conformance/types/conditional/conditionalTypes1.ts(118,5): error TS2322: Type 'keyof T' is not assignable to type '{ [K in keyof T]: T[K] extends Function ? K : never; }[keyof T]'. +tests/cases/conformance/types/conditional/conditionalTypes1.ts(114,5): error TS2322: Type 'keyof T' is not assignable to type '{ [K in keyof T]: T[K] extends Function ? K : never; }[keyof T]'. Type 'keyof T' is not assignable to type 'T[keyof T] extends Function ? keyof T : never'. -tests/cases/conformance/types/conditional/conditionalTypes1.ts(119,5): error TS2322: Type '{ [K in keyof T]: T[K] extends Function ? never : K; }[keyof T]' is not assignable to type '{ [K in keyof T]: T[K] extends Function ? K : never; }[keyof T]'. +tests/cases/conformance/types/conditional/conditionalTypes1.ts(115,5): error TS2322: Type '{ [K in keyof T]: T[K] extends Function ? never : K; }[keyof T]' is not assignable to type '{ [K in keyof T]: T[K] extends Function ? K : never; }[keyof T]'. Type 'T[keyof T] extends Function ? never : keyof T' is not assignable to type '{ [K in keyof T]: T[K] extends Function ? K : never; }[keyof T]'. Type 'keyof T' is not assignable to type '{ [K in keyof T]: T[K] extends Function ? K : never; }[keyof T]'. Type 'T[keyof T] extends Function ? never : keyof T' is not assignable to type 'T[keyof T] extends Function ? keyof T : never'. Type '{ [K in keyof T]: T[K] extends Function ? never : K; }[keyof T]' is not assignable to type 'T[keyof T] extends Function ? keyof T : never'. Type 'T[keyof T] extends Function ? never : keyof T' is not assignable to type 'T[keyof T] extends Function ? keyof T : never'. Type 'keyof T' is not assignable to type 'never'. -tests/cases/conformance/types/conditional/conditionalTypes1.ts(120,5): error TS2322: Type 'keyof T' is not assignable to type '{ [K in keyof T]: T[K] extends Function ? never : K; }[keyof T]'. +tests/cases/conformance/types/conditional/conditionalTypes1.ts(116,5): error TS2322: Type 'keyof T' is not assignable to type '{ [K in keyof T]: T[K] extends Function ? never : K; }[keyof T]'. Type 'keyof T' is not assignable to type 'T[keyof T] extends Function ? never : keyof T'. -tests/cases/conformance/types/conditional/conditionalTypes1.ts(121,5): error TS2322: Type '{ [K in keyof T]: T[K] extends Function ? K : never; }[keyof T]' is not assignable to type '{ [K in keyof T]: T[K] extends Function ? never : K; }[keyof T]'. +tests/cases/conformance/types/conditional/conditionalTypes1.ts(117,5): error TS2322: Type '{ [K in keyof T]: T[K] extends Function ? K : never; }[keyof T]' is not assignable to type '{ [K in keyof T]: T[K] extends Function ? never : K; }[keyof T]'. Type 'T[keyof T] extends Function ? keyof T : never' is not assignable to type '{ [K in keyof T]: T[K] extends Function ? never : K; }[keyof T]'. Type 'keyof T' is not assignable to type '{ [K in keyof T]: T[K] extends Function ? never : K; }[keyof T]'. Type 'T[keyof T] extends Function ? keyof T : never' is not assignable to type 'T[keyof T] extends Function ? never : keyof T'. Type '{ [K in keyof T]: T[K] extends Function ? K : never; }[keyof T]' is not assignable to type 'T[keyof T] extends Function ? never : keyof T'. Type 'T[keyof T] extends Function ? keyof T : never' is not assignable to type 'T[keyof T] extends Function ? never : keyof T'. Type 'keyof T' is not assignable to type 'never'. -tests/cases/conformance/types/conditional/conditionalTypes1.ts(138,10): error TS2540: Cannot assign to 'id' because it is a constant or a read-only property. -tests/cases/conformance/types/conditional/conditionalTypes1.ts(139,5): error TS2542: Index signature in type 'DeepReadonlyArray' only permits reading. -tests/cases/conformance/types/conditional/conditionalTypes1.ts(140,22): error TS2540: Cannot assign to 'id' because it is a constant or a read-only property. -tests/cases/conformance/types/conditional/conditionalTypes1.ts(141,10): error TS2339: Property 'updatePart' does not exist on type 'DeepReadonlyObject'. -tests/cases/conformance/types/conditional/conditionalTypes1.ts(163,5): error TS2322: Type 'ZeroOf' is not assignable to type 'T'. +tests/cases/conformance/types/conditional/conditionalTypes1.ts(134,10): error TS2540: Cannot assign to 'id' because it is a constant or a read-only property. +tests/cases/conformance/types/conditional/conditionalTypes1.ts(135,5): error TS2542: Index signature in type 'DeepReadonlyArray' only permits reading. +tests/cases/conformance/types/conditional/conditionalTypes1.ts(136,22): error TS2540: Cannot assign to 'id' because it is a constant or a read-only property. +tests/cases/conformance/types/conditional/conditionalTypes1.ts(137,10): error TS2339: Property 'updatePart' does not exist on type 'DeepReadonlyObject'. +tests/cases/conformance/types/conditional/conditionalTypes1.ts(159,5): error TS2322: Type 'ZeroOf' is not assignable to type 'T'. Type '0 | (T extends string ? "" : false)' is not assignable to type 'T'. Type '0' is not assignable to type 'T'. Type '"" | 0' is not assignable to type 'T'. Type '""' is not assignable to type 'T'. -tests/cases/conformance/types/conditional/conditionalTypes1.ts(164,5): error TS2322: Type 'T' is not assignable to type 'ZeroOf'. +tests/cases/conformance/types/conditional/conditionalTypes1.ts(160,5): error TS2322: Type 'T' is not assignable to type 'ZeroOf'. Type 'string | number' is not assignable to type 'ZeroOf'. Type 'string' is not assignable to type 'ZeroOf'. -tests/cases/conformance/types/conditional/conditionalTypes1.ts(254,9): error TS2403: Subsequent variable declarations must have the same type. Variable 'z' must be of type 'T1', but here has type 'Foo'. -tests/cases/conformance/types/conditional/conditionalTypes1.ts(279,43): error TS2322: Type 'T95' is not assignable to type 'T94'. +tests/cases/conformance/types/conditional/conditionalTypes1.ts(250,9): error TS2403: Subsequent variable declarations must have the same type. Variable 'z' must be of type 'T1', but here has type 'Foo'. +tests/cases/conformance/types/conditional/conditionalTypes1.ts(275,43): error TS2322: Type 'T95' is not assignable to type 'T94'. Type 'boolean' is not assignable to type 'true'. ==== tests/cases/conformance/types/conditional/conditionalTypes1.ts (22 errors) ==== - type Diff = T extends U ? never : T; - type Filter = T extends U ? T : never; - type NonNullable = Diff; + type T00 = Exclude<"a" | "b" | "c" | "d", "a" | "c" | "f">; // "b" | "d" + type T01 = Extract<"a" | "b" | "c" | "d", "a" | "c" | "f">; // "a" | "c" - type T00 = Diff<"a" | "b" | "c" | "d", "a" | "c" | "f">; // "b" | "d" - type T01 = Filter<"a" | "b" | "c" | "d", "a" | "c" | "f">; // "a" | "c" - - type T02 = Diff void), Function>; // string | number - type T03 = Filter void), Function>; // () => void + type T02 = Exclude void), Function>; // string | number + type T03 = Extract void), Function>; // () => void type T04 = NonNullable; // string | number type T05 = NonNullable<(() => string) | string[] | null | undefined>; // (() => string) | string[] @@ -87,16 +83,16 @@ tests/cases/conformance/types/conditional/conditionalTypes1.ts(279,43): error TS x = y; y = x; // Error ~ -!!! error TS2322: Type 'T' is not assignable to type 'Diff'. +!!! error TS2322: Type 'T' is not assignable to type 'NonNullable'. } function f2(x: T, y: NonNullable) { x = y; y = x; // Error ~ -!!! error TS2322: Type 'T' is not assignable to type 'Diff'. -!!! error TS2322: Type 'string | undefined' is not assignable to type 'Diff'. -!!! error TS2322: Type 'undefined' is not assignable to type 'Diff'. +!!! error TS2322: Type 'T' is not assignable to type 'NonNullable'. +!!! error TS2322: Type 'string | undefined' is not assignable to type 'NonNullable'. +!!! error TS2322: Type 'undefined' is not assignable to type 'NonNullable'. let s1: string = x; // Error ~~ !!! error TS2322: Type 'T' is not assignable to type 'string'. @@ -109,18 +105,18 @@ tests/cases/conformance/types/conditional/conditionalTypes1.ts(279,43): error TS x = y; y = x; // Error ~ -!!! error TS2322: Type 'Partial[keyof T]' is not assignable to type 'Diff[keyof T], null | undefined>'. -!!! error TS2322: Type 'T[keyof T] | undefined' is not assignable to type 'Diff[keyof T], null | undefined>'. -!!! error TS2322: Type 'undefined' is not assignable to type 'Diff[keyof T], null | undefined>'. +!!! error TS2322: Type 'Partial[keyof T]' is not assignable to type 'NonNullable[keyof T]>'. +!!! error TS2322: Type 'T[keyof T] | undefined' is not assignable to type 'NonNullable[keyof T]>'. +!!! error TS2322: Type 'undefined' is not assignable to type 'NonNullable[keyof T]>'. } function f4(x: T["x"], y: NonNullable) { x = y; y = x; // Error ~ -!!! error TS2322: Type 'T["x"]' is not assignable to type 'Diff'. -!!! error TS2322: Type 'string | undefined' is not assignable to type 'Diff'. -!!! error TS2322: Type 'undefined' is not assignable to type 'Diff'. +!!! error TS2322: Type 'T["x"]' is not assignable to type 'NonNullable'. +!!! error TS2322: Type 'string | undefined' is not assignable to type 'NonNullable'. +!!! error TS2322: Type 'undefined' is not assignable to type 'NonNullable'. let s1: string = x; // Error ~~ !!! error TS2322: Type 'T["x"]' is not assignable to type 'string'. @@ -131,23 +127,23 @@ tests/cases/conformance/types/conditional/conditionalTypes1.ts(279,43): error TS type Options = { k: "a", a: number } | { k: "b", b: string } | { k: "c", c: boolean }; - type T10 = Diff; // { k: "c", c: boolean } - type T11 = Filter; // { k: "a", a: number } | { k: "b", b: string } + type T10 = Exclude; // { k: "c", c: boolean } + type T11 = Extract; // { k: "a", a: number } | { k: "b", b: string } - type T12 = Diff; // { k: "c", c: boolean } - type T13 = Filter; // { k: "a", a: number } | { k: "b", b: string } + type T12 = Exclude; // { k: "c", c: boolean } + type T13 = Extract; // { k: "a", a: number } | { k: "b", b: string } - type T14 = Diff; // Options - type T15 = Filter; // never + type T14 = Exclude; // Options + type T15 = Extract; // never - declare function f5(p: K): Filter; + declare function f5(p: K): Extract; let x0 = f5("a"); // { k: "a", a: number } - type OptionsOfKind = Filter; + type OptionsOfKind = Extract; type T16 = OptionsOfKind<"a" | "b">; // { k: "a", a: number } | { k: "b", b: string } - type Select = Filter; + type Select = Extract; type T17 = Select; // // { k: "a", a: number } | { k: "b", b: string } diff --git a/tests/baselines/reference/conditionalTypes1.js b/tests/baselines/reference/conditionalTypes1.js index 6aa9065f12e..fe617d777ca 100644 --- a/tests/baselines/reference/conditionalTypes1.js +++ b/tests/baselines/reference/conditionalTypes1.js @@ -1,13 +1,9 @@ //// [conditionalTypes1.ts] -type Diff = T extends U ? never : T; -type Filter = T extends U ? T : never; -type NonNullable = Diff; +type T00 = Exclude<"a" | "b" | "c" | "d", "a" | "c" | "f">; // "b" | "d" +type T01 = Extract<"a" | "b" | "c" | "d", "a" | "c" | "f">; // "a" | "c" -type T00 = Diff<"a" | "b" | "c" | "d", "a" | "c" | "f">; // "b" | "d" -type T01 = Filter<"a" | "b" | "c" | "d", "a" | "c" | "f">; // "a" | "c" - -type T02 = Diff void), Function>; // string | number -type T03 = Filter void), Function>; // () => void +type T02 = Exclude void), Function>; // string | number +type T03 = Extract void), Function>; // () => void type T04 = NonNullable; // string | number type T05 = NonNullable<(() => string) | string[] | null | undefined>; // (() => string) | string[] @@ -38,23 +34,23 @@ function f4(x: T["x"], y: NonNullable; // { k: "c", c: boolean } -type T11 = Filter; // { k: "a", a: number } | { k: "b", b: string } +type T10 = Exclude; // { k: "c", c: boolean } +type T11 = Extract; // { k: "a", a: number } | { k: "b", b: string } -type T12 = Diff; // { k: "c", c: boolean } -type T13 = Filter; // { k: "a", a: number } | { k: "b", b: string } +type T12 = Exclude; // { k: "c", c: boolean } +type T13 = Extract; // { k: "a", a: number } | { k: "b", b: string } -type T14 = Diff; // Options -type T15 = Filter; // never +type T14 = Exclude; // Options +type T15 = Extract; // never -declare function f5(p: K): Filter; +declare function f5(p: K): Extract; let x0 = f5("a"); // { k: "a", a: number } -type OptionsOfKind = Filter; +type OptionsOfKind = Extract; type T16 = OptionsOfKind<"a" | "b">; // { k: "a", a: number } | { k: "b", b: string } -type Select = Filter; +type Select = Extract; type T17 = Select; // // { k: "a", a: number } | { k: "b", b: string } @@ -368,13 +364,10 @@ var f45 = function (value) { return value; }; // Error //// [conditionalTypes1.d.ts] -declare type Diff = T extends U ? never : T; -declare type Filter = T extends U ? T : never; -declare type NonNullable = Diff; -declare type T00 = Diff<"a" | "b" | "c" | "d", "a" | "c" | "f">; -declare type T01 = Filter<"a" | "b" | "c" | "d", "a" | "c" | "f">; -declare type T02 = Diff void), Function>; -declare type T03 = Filter void), Function>; +declare type T00 = Exclude<"a" | "b" | "c" | "d", "a" | "c" | "f">; +declare type T01 = Extract<"a" | "b" | "c" | "d", "a" | "c" | "f">; +declare type T02 = Exclude void), Function>; +declare type T03 = Extract void), Function>; declare type T04 = NonNullable; declare type T05 = NonNullable<(() => string) | string[] | null | undefined>; declare function f1(x: T, y: NonNullable): void; @@ -393,40 +386,40 @@ declare type Options = { k: "c"; c: boolean; }; -declare type T10 = Diff; -declare type T11 = Filter; -declare type T12 = Diff; -declare type T13 = Filter; -declare type T14 = Diff; -declare type T15 = Filter; -declare function f5(p: K): Filter(p: K): Extract; declare let x0: { k: "a"; a: number; }; -declare type OptionsOfKind = Filter = Extract; declare type T16 = OptionsOfKind<"a" | "b">; -declare type Select = Filter = Extract; declare type T17 = Select; diff --git a/tests/baselines/reference/conditionalTypes1.symbols b/tests/baselines/reference/conditionalTypes1.symbols index ebcddec7f69..ef5dc0d58f8 100644 --- a/tests/baselines/reference/conditionalTypes1.symbols +++ b/tests/baselines/reference/conditionalTypes1.symbols @@ -1,1083 +1,1061 @@ === tests/cases/conformance/types/conditional/conditionalTypes1.ts === -type Diff = T extends U ? never : T; ->Diff : Symbol(Diff, Decl(conditionalTypes1.ts, 0, 0)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 0, 10)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 0, 12)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 0, 10)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 0, 12)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 0, 10)) +type T00 = Exclude<"a" | "b" | "c" | "d", "a" | "c" | "f">; // "b" | "d" +>T00 : Symbol(T00, Decl(conditionalTypes1.ts, 0, 0)) +>Exclude : Symbol(Exclude, Decl(lib.d.ts, --, --)) -type Filter = T extends U ? T : never; ->Filter : Symbol(Filter, Decl(conditionalTypes1.ts, 0, 42)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 1, 12)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 1, 14)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 1, 12)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 1, 14)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 1, 12)) +type T01 = Extract<"a" | "b" | "c" | "d", "a" | "c" | "f">; // "a" | "c" +>T01 : Symbol(T01, Decl(conditionalTypes1.ts, 0, 59)) +>Extract : Symbol(Extract, Decl(lib.d.ts, --, --)) -type NonNullable = Diff; ->NonNullable : Symbol(NonNullable, Decl(conditionalTypes1.ts, 1, 44)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 2, 17)) ->Diff : Symbol(Diff, Decl(conditionalTypes1.ts, 0, 0)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 2, 17)) - -type T00 = Diff<"a" | "b" | "c" | "d", "a" | "c" | "f">; // "b" | "d" ->T00 : Symbol(T00, Decl(conditionalTypes1.ts, 2, 48)) ->Diff : Symbol(Diff, Decl(conditionalTypes1.ts, 0, 0)) - -type T01 = Filter<"a" | "b" | "c" | "d", "a" | "c" | "f">; // "a" | "c" ->T01 : Symbol(T01, Decl(conditionalTypes1.ts, 4, 56)) ->Filter : Symbol(Filter, Decl(conditionalTypes1.ts, 0, 42)) - -type T02 = Diff void), Function>; // string | number ->T02 : Symbol(T02, Decl(conditionalTypes1.ts, 5, 58)) ->Diff : Symbol(Diff, Decl(conditionalTypes1.ts, 0, 0)) +type T02 = Exclude void), Function>; // string | number +>T02 : Symbol(T02, Decl(conditionalTypes1.ts, 1, 59)) +>Exclude : Symbol(Exclude, Decl(lib.d.ts, --, --)) >Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) -type T03 = Filter void), Function>; // () => void ->T03 : Symbol(T03, Decl(conditionalTypes1.ts, 7, 58)) ->Filter : Symbol(Filter, Decl(conditionalTypes1.ts, 0, 42)) +type T03 = Extract void), Function>; // () => void +>T03 : Symbol(T03, Decl(conditionalTypes1.ts, 3, 61)) +>Extract : Symbol(Extract, Decl(lib.d.ts, --, --)) >Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) type T04 = NonNullable; // string | number ->T04 : Symbol(T04, Decl(conditionalTypes1.ts, 8, 60)) ->NonNullable : Symbol(NonNullable, Decl(conditionalTypes1.ts, 1, 44)) +>T04 : Symbol(T04, Decl(conditionalTypes1.ts, 4, 61)) +>NonNullable : Symbol(NonNullable, Decl(lib.d.ts, --, --)) type T05 = NonNullable<(() => string) | string[] | null | undefined>; // (() => string) | string[] ->T05 : Symbol(T05, Decl(conditionalTypes1.ts, 10, 52)) ->NonNullable : Symbol(NonNullable, Decl(conditionalTypes1.ts, 1, 44)) +>T05 : Symbol(T05, Decl(conditionalTypes1.ts, 6, 52)) +>NonNullable : Symbol(NonNullable, Decl(lib.d.ts, --, --)) function f1(x: T, y: NonNullable) { ->f1 : Symbol(f1, Decl(conditionalTypes1.ts, 11, 69)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 13, 12)) ->x : Symbol(x, Decl(conditionalTypes1.ts, 13, 15)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 13, 12)) ->y : Symbol(y, Decl(conditionalTypes1.ts, 13, 20)) ->NonNullable : Symbol(NonNullable, Decl(conditionalTypes1.ts, 1, 44)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 13, 12)) +>f1 : Symbol(f1, Decl(conditionalTypes1.ts, 7, 69)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 9, 12)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 9, 15)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 9, 12)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 9, 20)) +>NonNullable : Symbol(NonNullable, Decl(lib.d.ts, --, --)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 9, 12)) x = y; ->x : Symbol(x, Decl(conditionalTypes1.ts, 13, 15)) ->y : Symbol(y, Decl(conditionalTypes1.ts, 13, 20)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 9, 15)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 9, 20)) y = x; // Error ->y : Symbol(y, Decl(conditionalTypes1.ts, 13, 20)) ->x : Symbol(x, Decl(conditionalTypes1.ts, 13, 15)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 9, 20)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 9, 15)) } function f2(x: T, y: NonNullable) { ->f2 : Symbol(f2, Decl(conditionalTypes1.ts, 16, 1)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 18, 12)) ->x : Symbol(x, Decl(conditionalTypes1.ts, 18, 42)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 18, 12)) ->y : Symbol(y, Decl(conditionalTypes1.ts, 18, 47)) ->NonNullable : Symbol(NonNullable, Decl(conditionalTypes1.ts, 1, 44)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 18, 12)) +>f2 : Symbol(f2, Decl(conditionalTypes1.ts, 12, 1)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 14, 12)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 14, 42)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 14, 12)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 14, 47)) +>NonNullable : Symbol(NonNullable, Decl(lib.d.ts, --, --)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 14, 12)) x = y; ->x : Symbol(x, Decl(conditionalTypes1.ts, 18, 42)) ->y : Symbol(y, Decl(conditionalTypes1.ts, 18, 47)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 14, 42)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 14, 47)) y = x; // Error ->y : Symbol(y, Decl(conditionalTypes1.ts, 18, 47)) ->x : Symbol(x, Decl(conditionalTypes1.ts, 18, 42)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 14, 47)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 14, 42)) let s1: string = x; // Error ->s1 : Symbol(s1, Decl(conditionalTypes1.ts, 21, 7)) ->x : Symbol(x, Decl(conditionalTypes1.ts, 18, 42)) +>s1 : Symbol(s1, Decl(conditionalTypes1.ts, 17, 7)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 14, 42)) let s2: string = y; ->s2 : Symbol(s2, Decl(conditionalTypes1.ts, 22, 7)) ->y : Symbol(y, Decl(conditionalTypes1.ts, 18, 47)) +>s2 : Symbol(s2, Decl(conditionalTypes1.ts, 18, 7)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 14, 47)) } function f3(x: Partial[keyof T], y: NonNullable[keyof T]>) { ->f3 : Symbol(f3, Decl(conditionalTypes1.ts, 23, 1)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 25, 12)) ->x : Symbol(x, Decl(conditionalTypes1.ts, 25, 15)) +>f3 : Symbol(f3, Decl(conditionalTypes1.ts, 19, 1)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 21, 12)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 21, 15)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 25, 12)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 25, 12)) ->y : Symbol(y, Decl(conditionalTypes1.ts, 25, 38)) ->NonNullable : Symbol(NonNullable, Decl(conditionalTypes1.ts, 1, 44)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 21, 12)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 21, 12)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 21, 38)) +>NonNullable : Symbol(NonNullable, Decl(lib.d.ts, --, --)) >Partial : Symbol(Partial, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 25, 12)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 25, 12)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 21, 12)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 21, 12)) x = y; ->x : Symbol(x, Decl(conditionalTypes1.ts, 25, 15)) ->y : Symbol(y, Decl(conditionalTypes1.ts, 25, 38)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 21, 15)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 21, 38)) y = x; // Error ->y : Symbol(y, Decl(conditionalTypes1.ts, 25, 38)) ->x : Symbol(x, Decl(conditionalTypes1.ts, 25, 15)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 21, 38)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 21, 15)) } function f4(x: T["x"], y: NonNullable) { ->f4 : Symbol(f4, Decl(conditionalTypes1.ts, 28, 1)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 30, 12)) ->x : Symbol(x, Decl(conditionalTypes1.ts, 30, 23)) ->x : Symbol(x, Decl(conditionalTypes1.ts, 30, 49)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 30, 12)) ->y : Symbol(y, Decl(conditionalTypes1.ts, 30, 59)) ->NonNullable : Symbol(NonNullable, Decl(conditionalTypes1.ts, 1, 44)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 30, 12)) +>f4 : Symbol(f4, Decl(conditionalTypes1.ts, 24, 1)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 26, 12)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 26, 23)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 26, 49)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 26, 12)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 26, 59)) +>NonNullable : Symbol(NonNullable, Decl(lib.d.ts, --, --)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 26, 12)) x = y; ->x : Symbol(x, Decl(conditionalTypes1.ts, 30, 49)) ->y : Symbol(y, Decl(conditionalTypes1.ts, 30, 59)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 26, 49)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 26, 59)) y = x; // Error ->y : Symbol(y, Decl(conditionalTypes1.ts, 30, 59)) ->x : Symbol(x, Decl(conditionalTypes1.ts, 30, 49)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 26, 59)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 26, 49)) let s1: string = x; // Error ->s1 : Symbol(s1, Decl(conditionalTypes1.ts, 33, 7)) ->x : Symbol(x, Decl(conditionalTypes1.ts, 30, 49)) +>s1 : Symbol(s1, Decl(conditionalTypes1.ts, 29, 7)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 26, 49)) let s2: string = y; ->s2 : Symbol(s2, Decl(conditionalTypes1.ts, 34, 7)) ->y : Symbol(y, Decl(conditionalTypes1.ts, 30, 59)) +>s2 : Symbol(s2, Decl(conditionalTypes1.ts, 30, 7)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 26, 59)) } type Options = { k: "a", a: number } | { k: "b", b: string } | { k: "c", c: boolean }; ->Options : Symbol(Options, Decl(conditionalTypes1.ts, 35, 1)) ->k : Symbol(k, Decl(conditionalTypes1.ts, 37, 16)) ->a : Symbol(a, Decl(conditionalTypes1.ts, 37, 24)) ->k : Symbol(k, Decl(conditionalTypes1.ts, 37, 40)) ->b : Symbol(b, Decl(conditionalTypes1.ts, 37, 48)) ->k : Symbol(k, Decl(conditionalTypes1.ts, 37, 64)) ->c : Symbol(c, Decl(conditionalTypes1.ts, 37, 72)) +>Options : Symbol(Options, Decl(conditionalTypes1.ts, 31, 1)) +>k : Symbol(k, Decl(conditionalTypes1.ts, 33, 16)) +>a : Symbol(a, Decl(conditionalTypes1.ts, 33, 24)) +>k : Symbol(k, Decl(conditionalTypes1.ts, 33, 40)) +>b : Symbol(b, Decl(conditionalTypes1.ts, 33, 48)) +>k : Symbol(k, Decl(conditionalTypes1.ts, 33, 64)) +>c : Symbol(c, Decl(conditionalTypes1.ts, 33, 72)) -type T10 = Diff; // { k: "c", c: boolean } ->T10 : Symbol(T10, Decl(conditionalTypes1.ts, 37, 86)) ->Diff : Symbol(Diff, Decl(conditionalTypes1.ts, 0, 0)) ->Options : Symbol(Options, Decl(conditionalTypes1.ts, 35, 1)) ->k : Symbol(k, Decl(conditionalTypes1.ts, 39, 26)) +type T10 = Exclude; // { k: "c", c: boolean } +>T10 : Symbol(T10, Decl(conditionalTypes1.ts, 33, 86)) +>Exclude : Symbol(Exclude, Decl(lib.d.ts, --, --)) +>Options : Symbol(Options, Decl(conditionalTypes1.ts, 31, 1)) +>k : Symbol(k, Decl(conditionalTypes1.ts, 35, 29)) -type T11 = Filter; // { k: "a", a: number } | { k: "b", b: string } ->T11 : Symbol(T11, Decl(conditionalTypes1.ts, 39, 43)) ->Filter : Symbol(Filter, Decl(conditionalTypes1.ts, 0, 42)) ->Options : Symbol(Options, Decl(conditionalTypes1.ts, 35, 1)) ->k : Symbol(k, Decl(conditionalTypes1.ts, 40, 28)) +type T11 = Extract; // { k: "a", a: number } | { k: "b", b: string } +>T11 : Symbol(T11, Decl(conditionalTypes1.ts, 35, 46)) +>Extract : Symbol(Extract, Decl(lib.d.ts, --, --)) +>Options : Symbol(Options, Decl(conditionalTypes1.ts, 31, 1)) +>k : Symbol(k, Decl(conditionalTypes1.ts, 36, 29)) -type T12 = Diff; // { k: "c", c: boolean } ->T12 : Symbol(T12, Decl(conditionalTypes1.ts, 40, 45)) ->Diff : Symbol(Diff, Decl(conditionalTypes1.ts, 0, 0)) ->Options : Symbol(Options, Decl(conditionalTypes1.ts, 35, 1)) ->k : Symbol(k, Decl(conditionalTypes1.ts, 42, 26)) ->k : Symbol(k, Decl(conditionalTypes1.ts, 42, 39)) +type T12 = Exclude; // { k: "c", c: boolean } +>T12 : Symbol(T12, Decl(conditionalTypes1.ts, 36, 46)) +>Exclude : Symbol(Exclude, Decl(lib.d.ts, --, --)) +>Options : Symbol(Options, Decl(conditionalTypes1.ts, 31, 1)) +>k : Symbol(k, Decl(conditionalTypes1.ts, 38, 29)) +>k : Symbol(k, Decl(conditionalTypes1.ts, 38, 42)) -type T13 = Filter; // { k: "a", a: number } | { k: "b", b: string } ->T13 : Symbol(T13, Decl(conditionalTypes1.ts, 42, 50)) ->Filter : Symbol(Filter, Decl(conditionalTypes1.ts, 0, 42)) ->Options : Symbol(Options, Decl(conditionalTypes1.ts, 35, 1)) ->k : Symbol(k, Decl(conditionalTypes1.ts, 43, 28)) ->k : Symbol(k, Decl(conditionalTypes1.ts, 43, 41)) +type T13 = Extract; // { k: "a", a: number } | { k: "b", b: string } +>T13 : Symbol(T13, Decl(conditionalTypes1.ts, 38, 53)) +>Extract : Symbol(Extract, Decl(lib.d.ts, --, --)) +>Options : Symbol(Options, Decl(conditionalTypes1.ts, 31, 1)) +>k : Symbol(k, Decl(conditionalTypes1.ts, 39, 29)) +>k : Symbol(k, Decl(conditionalTypes1.ts, 39, 42)) -type T14 = Diff; // Options ->T14 : Symbol(T14, Decl(conditionalTypes1.ts, 43, 52)) ->Diff : Symbol(Diff, Decl(conditionalTypes1.ts, 0, 0)) ->Options : Symbol(Options, Decl(conditionalTypes1.ts, 35, 1)) ->q : Symbol(q, Decl(conditionalTypes1.ts, 45, 26)) +type T14 = Exclude; // Options +>T14 : Symbol(T14, Decl(conditionalTypes1.ts, 39, 53)) +>Exclude : Symbol(Exclude, Decl(lib.d.ts, --, --)) +>Options : Symbol(Options, Decl(conditionalTypes1.ts, 31, 1)) +>q : Symbol(q, Decl(conditionalTypes1.ts, 41, 29)) -type T15 = Filter; // never ->T15 : Symbol(T15, Decl(conditionalTypes1.ts, 45, 37)) ->Filter : Symbol(Filter, Decl(conditionalTypes1.ts, 0, 42)) ->Options : Symbol(Options, Decl(conditionalTypes1.ts, 35, 1)) ->q : Symbol(q, Decl(conditionalTypes1.ts, 46, 28)) +type T15 = Extract; // never +>T15 : Symbol(T15, Decl(conditionalTypes1.ts, 41, 40)) +>Extract : Symbol(Extract, Decl(lib.d.ts, --, --)) +>Options : Symbol(Options, Decl(conditionalTypes1.ts, 31, 1)) +>q : Symbol(q, Decl(conditionalTypes1.ts, 42, 29)) -declare function f5(p: K): Filter; ->f5 : Symbol(f5, Decl(conditionalTypes1.ts, 46, 39)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 48, 20)) ->Options : Symbol(Options, Decl(conditionalTypes1.ts, 35, 1)) ->K : Symbol(K, Decl(conditionalTypes1.ts, 48, 38)) ->p : Symbol(p, Decl(conditionalTypes1.ts, 48, 57)) ->K : Symbol(K, Decl(conditionalTypes1.ts, 48, 38)) ->Filter : Symbol(Filter, Decl(conditionalTypes1.ts, 0, 42)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 48, 20)) ->k : Symbol(k, Decl(conditionalTypes1.ts, 48, 75)) ->K : Symbol(K, Decl(conditionalTypes1.ts, 48, 38)) +declare function f5(p: K): Extract; +>f5 : Symbol(f5, Decl(conditionalTypes1.ts, 42, 40)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 44, 20)) +>Options : Symbol(Options, Decl(conditionalTypes1.ts, 31, 1)) +>K : Symbol(K, Decl(conditionalTypes1.ts, 44, 38)) +>p : Symbol(p, Decl(conditionalTypes1.ts, 44, 57)) +>K : Symbol(K, Decl(conditionalTypes1.ts, 44, 38)) +>Extract : Symbol(Extract, Decl(lib.d.ts, --, --)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 44, 20)) +>k : Symbol(k, Decl(conditionalTypes1.ts, 44, 76)) +>K : Symbol(K, Decl(conditionalTypes1.ts, 44, 38)) let x0 = f5("a"); // { k: "a", a: number } ->x0 : Symbol(x0, Decl(conditionalTypes1.ts, 49, 3)) ->f5 : Symbol(f5, Decl(conditionalTypes1.ts, 46, 39)) +>x0 : Symbol(x0, Decl(conditionalTypes1.ts, 45, 3)) +>f5 : Symbol(f5, Decl(conditionalTypes1.ts, 42, 40)) -type OptionsOfKind = Filter; ->OptionsOfKind : Symbol(OptionsOfKind, Decl(conditionalTypes1.ts, 49, 17)) ->K : Symbol(K, Decl(conditionalTypes1.ts, 51, 19)) ->Options : Symbol(Options, Decl(conditionalTypes1.ts, 35, 1)) ->Filter : Symbol(Filter, Decl(conditionalTypes1.ts, 0, 42)) ->Options : Symbol(Options, Decl(conditionalTypes1.ts, 35, 1)) ->k : Symbol(k, Decl(conditionalTypes1.ts, 51, 62)) ->K : Symbol(K, Decl(conditionalTypes1.ts, 51, 19)) +type OptionsOfKind = Extract; +>OptionsOfKind : Symbol(OptionsOfKind, Decl(conditionalTypes1.ts, 45, 17)) +>K : Symbol(K, Decl(conditionalTypes1.ts, 47, 19)) +>Options : Symbol(Options, Decl(conditionalTypes1.ts, 31, 1)) +>Extract : Symbol(Extract, Decl(lib.d.ts, --, --)) +>Options : Symbol(Options, Decl(conditionalTypes1.ts, 31, 1)) +>k : Symbol(k, Decl(conditionalTypes1.ts, 47, 63)) +>K : Symbol(K, Decl(conditionalTypes1.ts, 47, 19)) type T16 = OptionsOfKind<"a" | "b">; // { k: "a", a: number } | { k: "b", b: string } ->T16 : Symbol(T16, Decl(conditionalTypes1.ts, 51, 71)) ->OptionsOfKind : Symbol(OptionsOfKind, Decl(conditionalTypes1.ts, 49, 17)) +>T16 : Symbol(T16, Decl(conditionalTypes1.ts, 47, 72)) +>OptionsOfKind : Symbol(OptionsOfKind, Decl(conditionalTypes1.ts, 45, 17)) -type Select = Filter; ->Select : Symbol(Select, Decl(conditionalTypes1.ts, 53, 36)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 55, 12)) ->K : Symbol(K, Decl(conditionalTypes1.ts, 55, 14)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 55, 12)) ->V : Symbol(V, Decl(conditionalTypes1.ts, 55, 33)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 55, 12)) ->K : Symbol(K, Decl(conditionalTypes1.ts, 55, 14)) ->Filter : Symbol(Filter, Decl(conditionalTypes1.ts, 0, 42)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 55, 12)) ->P : Symbol(P, Decl(conditionalTypes1.ts, 55, 65)) ->K : Symbol(K, Decl(conditionalTypes1.ts, 55, 14)) ->V : Symbol(V, Decl(conditionalTypes1.ts, 55, 33)) +type Select = Extract; +>Select : Symbol(Select, Decl(conditionalTypes1.ts, 49, 36)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 51, 12)) +>K : Symbol(K, Decl(conditionalTypes1.ts, 51, 14)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 51, 12)) +>V : Symbol(V, Decl(conditionalTypes1.ts, 51, 33)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 51, 12)) +>K : Symbol(K, Decl(conditionalTypes1.ts, 51, 14)) +>Extract : Symbol(Extract, Decl(lib.d.ts, --, --)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 51, 12)) +>P : Symbol(P, Decl(conditionalTypes1.ts, 51, 66)) +>K : Symbol(K, Decl(conditionalTypes1.ts, 51, 14)) +>V : Symbol(V, Decl(conditionalTypes1.ts, 51, 33)) type T17 = Select; // // { k: "a", a: number } | { k: "b", b: string } ->T17 : Symbol(T17, Decl(conditionalTypes1.ts, 55, 79)) ->Select : Symbol(Select, Decl(conditionalTypes1.ts, 53, 36)) ->Options : Symbol(Options, Decl(conditionalTypes1.ts, 35, 1)) +>T17 : Symbol(T17, Decl(conditionalTypes1.ts, 51, 80)) +>Select : Symbol(Select, Decl(conditionalTypes1.ts, 49, 36)) +>Options : Symbol(Options, Decl(conditionalTypes1.ts, 31, 1)) type TypeName = ->TypeName : Symbol(TypeName, Decl(conditionalTypes1.ts, 57, 43)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 59, 14)) +>TypeName : Symbol(TypeName, Decl(conditionalTypes1.ts, 53, 43)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 55, 14)) T extends string ? "string" : ->T : Symbol(T, Decl(conditionalTypes1.ts, 59, 14)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 55, 14)) T extends number ? "number" : ->T : Symbol(T, Decl(conditionalTypes1.ts, 59, 14)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 55, 14)) T extends boolean ? "boolean" : ->T : Symbol(T, Decl(conditionalTypes1.ts, 59, 14)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 55, 14)) T extends undefined ? "undefined" : ->T : Symbol(T, Decl(conditionalTypes1.ts, 59, 14)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 55, 14)) T extends Function ? "function" : ->T : Symbol(T, Decl(conditionalTypes1.ts, 59, 14)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 55, 14)) >Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) "object"; type T20 = TypeName void)>; // "string" | "function" ->T20 : Symbol(T20, Decl(conditionalTypes1.ts, 65, 13)) ->TypeName : Symbol(TypeName, Decl(conditionalTypes1.ts, 57, 43)) +>T20 : Symbol(T20, Decl(conditionalTypes1.ts, 61, 13)) +>TypeName : Symbol(TypeName, Decl(conditionalTypes1.ts, 53, 43)) type T21 = TypeName; // "string" | "number" | "boolean" | "undefined" | "function" | "object" ->T21 : Symbol(T21, Decl(conditionalTypes1.ts, 67, 43)) ->TypeName : Symbol(TypeName, Decl(conditionalTypes1.ts, 57, 43)) +>T21 : Symbol(T21, Decl(conditionalTypes1.ts, 63, 43)) +>TypeName : Symbol(TypeName, Decl(conditionalTypes1.ts, 53, 43)) type T22 = TypeName; // "string" | "number" | "boolean" | "undefined" | "function" | "object" ->T22 : Symbol(T22, Decl(conditionalTypes1.ts, 68, 25)) ->TypeName : Symbol(TypeName, Decl(conditionalTypes1.ts, 57, 43)) +>T22 : Symbol(T22, Decl(conditionalTypes1.ts, 64, 25)) +>TypeName : Symbol(TypeName, Decl(conditionalTypes1.ts, 53, 43)) type T23 = TypeName<{}>; // "object" ->T23 : Symbol(T23, Decl(conditionalTypes1.ts, 69, 27)) ->TypeName : Symbol(TypeName, Decl(conditionalTypes1.ts, 57, 43)) +>T23 : Symbol(T23, Decl(conditionalTypes1.ts, 65, 27)) +>TypeName : Symbol(TypeName, Decl(conditionalTypes1.ts, 53, 43)) type KnockoutObservable = { object: T }; ->KnockoutObservable : Symbol(KnockoutObservable, Decl(conditionalTypes1.ts, 70, 24)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 72, 24)) ->object : Symbol(object, Decl(conditionalTypes1.ts, 72, 30)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 72, 24)) +>KnockoutObservable : Symbol(KnockoutObservable, Decl(conditionalTypes1.ts, 66, 24)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 68, 24)) +>object : Symbol(object, Decl(conditionalTypes1.ts, 68, 30)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 68, 24)) type KnockoutObservableArray = { array: T }; ->KnockoutObservableArray : Symbol(KnockoutObservableArray, Decl(conditionalTypes1.ts, 72, 43)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 73, 29)) ->array : Symbol(array, Decl(conditionalTypes1.ts, 73, 35)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 73, 29)) +>KnockoutObservableArray : Symbol(KnockoutObservableArray, Decl(conditionalTypes1.ts, 68, 43)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 69, 29)) +>array : Symbol(array, Decl(conditionalTypes1.ts, 69, 35)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 69, 29)) type KnockedOut = T extends any[] ? KnockoutObservableArray : KnockoutObservable; ->KnockedOut : Symbol(KnockedOut, Decl(conditionalTypes1.ts, 73, 47)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 75, 16)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 75, 16)) ->KnockoutObservableArray : Symbol(KnockoutObservableArray, Decl(conditionalTypes1.ts, 72, 43)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 75, 16)) ->KnockoutObservable : Symbol(KnockoutObservable, Decl(conditionalTypes1.ts, 70, 24)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 75, 16)) +>KnockedOut : Symbol(KnockedOut, Decl(conditionalTypes1.ts, 69, 47)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 71, 16)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 71, 16)) +>KnockoutObservableArray : Symbol(KnockoutObservableArray, Decl(conditionalTypes1.ts, 68, 43)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 71, 16)) +>KnockoutObservable : Symbol(KnockoutObservable, Decl(conditionalTypes1.ts, 66, 24)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 71, 16)) type KnockedOutObj = { ->KnockedOutObj : Symbol(KnockedOutObj, Decl(conditionalTypes1.ts, 75, 98)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 77, 19)) +>KnockedOutObj : Symbol(KnockedOutObj, Decl(conditionalTypes1.ts, 71, 98)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 73, 19)) [P in keyof T]: KnockedOut; ->P : Symbol(P, Decl(conditionalTypes1.ts, 78, 5)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 77, 19)) ->KnockedOut : Symbol(KnockedOut, Decl(conditionalTypes1.ts, 73, 47)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 77, 19)) ->P : Symbol(P, Decl(conditionalTypes1.ts, 78, 5)) +>P : Symbol(P, Decl(conditionalTypes1.ts, 74, 5)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 73, 19)) +>KnockedOut : Symbol(KnockedOut, Decl(conditionalTypes1.ts, 69, 47)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 73, 19)) +>P : Symbol(P, Decl(conditionalTypes1.ts, 74, 5)) } interface Item { ->Item : Symbol(Item, Decl(conditionalTypes1.ts, 79, 1)) +>Item : Symbol(Item, Decl(conditionalTypes1.ts, 75, 1)) id: number; ->id : Symbol(Item.id, Decl(conditionalTypes1.ts, 81, 16)) +>id : Symbol(Item.id, Decl(conditionalTypes1.ts, 77, 16)) name: string; ->name : Symbol(Item.name, Decl(conditionalTypes1.ts, 82, 15)) +>name : Symbol(Item.name, Decl(conditionalTypes1.ts, 78, 15)) subitems: string[]; ->subitems : Symbol(Item.subitems, Decl(conditionalTypes1.ts, 83, 17)) +>subitems : Symbol(Item.subitems, Decl(conditionalTypes1.ts, 79, 17)) } type KOItem = KnockedOutObj; ->KOItem : Symbol(KOItem, Decl(conditionalTypes1.ts, 85, 1)) ->KnockedOutObj : Symbol(KnockedOutObj, Decl(conditionalTypes1.ts, 75, 98)) ->Item : Symbol(Item, Decl(conditionalTypes1.ts, 79, 1)) +>KOItem : Symbol(KOItem, Decl(conditionalTypes1.ts, 81, 1)) +>KnockedOutObj : Symbol(KnockedOutObj, Decl(conditionalTypes1.ts, 71, 98)) +>Item : Symbol(Item, Decl(conditionalTypes1.ts, 75, 1)) interface Part { ->Part : Symbol(Part, Decl(conditionalTypes1.ts, 87, 34)) +>Part : Symbol(Part, Decl(conditionalTypes1.ts, 83, 34)) id: number; ->id : Symbol(Part.id, Decl(conditionalTypes1.ts, 89, 16)) +>id : Symbol(Part.id, Decl(conditionalTypes1.ts, 85, 16)) name: string; ->name : Symbol(Part.name, Decl(conditionalTypes1.ts, 90, 15)) +>name : Symbol(Part.name, Decl(conditionalTypes1.ts, 86, 15)) subparts: Part[]; ->subparts : Symbol(Part.subparts, Decl(conditionalTypes1.ts, 91, 17)) ->Part : Symbol(Part, Decl(conditionalTypes1.ts, 87, 34)) +>subparts : Symbol(Part.subparts, Decl(conditionalTypes1.ts, 87, 17)) +>Part : Symbol(Part, Decl(conditionalTypes1.ts, 83, 34)) updatePart(newName: string): void; ->updatePart : Symbol(Part.updatePart, Decl(conditionalTypes1.ts, 92, 21)) ->newName : Symbol(newName, Decl(conditionalTypes1.ts, 93, 15)) +>updatePart : Symbol(Part.updatePart, Decl(conditionalTypes1.ts, 88, 21)) +>newName : Symbol(newName, Decl(conditionalTypes1.ts, 89, 15)) } type FunctionPropertyNames = { [K in keyof T]: T[K] extends Function ? K : never }[keyof T]; ->FunctionPropertyNames : Symbol(FunctionPropertyNames, Decl(conditionalTypes1.ts, 94, 1)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 96, 27)) ->K : Symbol(K, Decl(conditionalTypes1.ts, 96, 35)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 96, 27)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 96, 27)) ->K : Symbol(K, Decl(conditionalTypes1.ts, 96, 35)) +>FunctionPropertyNames : Symbol(FunctionPropertyNames, Decl(conditionalTypes1.ts, 90, 1)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 92, 27)) +>K : Symbol(K, Decl(conditionalTypes1.ts, 92, 35)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 92, 27)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 92, 27)) +>K : Symbol(K, Decl(conditionalTypes1.ts, 92, 35)) >Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->K : Symbol(K, Decl(conditionalTypes1.ts, 96, 35)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 96, 27)) +>K : Symbol(K, Decl(conditionalTypes1.ts, 92, 35)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 92, 27)) type FunctionProperties = Pick>; ->FunctionProperties : Symbol(FunctionProperties, Decl(conditionalTypes1.ts, 96, 95)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 97, 24)) +>FunctionProperties : Symbol(FunctionProperties, Decl(conditionalTypes1.ts, 92, 95)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 93, 24)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 97, 24)) ->FunctionPropertyNames : Symbol(FunctionPropertyNames, Decl(conditionalTypes1.ts, 94, 1)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 97, 24)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 93, 24)) +>FunctionPropertyNames : Symbol(FunctionPropertyNames, Decl(conditionalTypes1.ts, 90, 1)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 93, 24)) type NonFunctionPropertyNames = { [K in keyof T]: T[K] extends Function ? never : K }[keyof T]; ->NonFunctionPropertyNames : Symbol(NonFunctionPropertyNames, Decl(conditionalTypes1.ts, 97, 63)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 99, 30)) ->K : Symbol(K, Decl(conditionalTypes1.ts, 99, 38)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 99, 30)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 99, 30)) ->K : Symbol(K, Decl(conditionalTypes1.ts, 99, 38)) +>NonFunctionPropertyNames : Symbol(NonFunctionPropertyNames, Decl(conditionalTypes1.ts, 93, 63)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 95, 30)) +>K : Symbol(K, Decl(conditionalTypes1.ts, 95, 38)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 95, 30)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 95, 30)) +>K : Symbol(K, Decl(conditionalTypes1.ts, 95, 38)) >Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->K : Symbol(K, Decl(conditionalTypes1.ts, 99, 38)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 99, 30)) +>K : Symbol(K, Decl(conditionalTypes1.ts, 95, 38)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 95, 30)) type NonFunctionProperties = Pick>; ->NonFunctionProperties : Symbol(NonFunctionProperties, Decl(conditionalTypes1.ts, 99, 98)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 100, 27)) +>NonFunctionProperties : Symbol(NonFunctionProperties, Decl(conditionalTypes1.ts, 95, 98)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 96, 27)) >Pick : Symbol(Pick, Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 100, 27)) ->NonFunctionPropertyNames : Symbol(NonFunctionPropertyNames, Decl(conditionalTypes1.ts, 97, 63)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 100, 27)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 96, 27)) +>NonFunctionPropertyNames : Symbol(NonFunctionPropertyNames, Decl(conditionalTypes1.ts, 93, 63)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 96, 27)) type T30 = FunctionProperties; ->T30 : Symbol(T30, Decl(conditionalTypes1.ts, 100, 69)) ->FunctionProperties : Symbol(FunctionProperties, Decl(conditionalTypes1.ts, 96, 95)) ->Part : Symbol(Part, Decl(conditionalTypes1.ts, 87, 34)) +>T30 : Symbol(T30, Decl(conditionalTypes1.ts, 96, 69)) +>FunctionProperties : Symbol(FunctionProperties, Decl(conditionalTypes1.ts, 92, 95)) +>Part : Symbol(Part, Decl(conditionalTypes1.ts, 83, 34)) type T31 = NonFunctionProperties; ->T31 : Symbol(T31, Decl(conditionalTypes1.ts, 102, 36)) ->NonFunctionProperties : Symbol(NonFunctionProperties, Decl(conditionalTypes1.ts, 99, 98)) ->Part : Symbol(Part, Decl(conditionalTypes1.ts, 87, 34)) +>T31 : Symbol(T31, Decl(conditionalTypes1.ts, 98, 36)) +>NonFunctionProperties : Symbol(NonFunctionProperties, Decl(conditionalTypes1.ts, 95, 98)) +>Part : Symbol(Part, Decl(conditionalTypes1.ts, 83, 34)) function f7(x: T, y: FunctionProperties, z: NonFunctionProperties) { ->f7 : Symbol(f7, Decl(conditionalTypes1.ts, 103, 39)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 105, 12)) ->x : Symbol(x, Decl(conditionalTypes1.ts, 105, 15)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 105, 12)) ->y : Symbol(y, Decl(conditionalTypes1.ts, 105, 20)) ->FunctionProperties : Symbol(FunctionProperties, Decl(conditionalTypes1.ts, 96, 95)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 105, 12)) ->z : Symbol(z, Decl(conditionalTypes1.ts, 105, 46)) ->NonFunctionProperties : Symbol(NonFunctionProperties, Decl(conditionalTypes1.ts, 99, 98)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 105, 12)) +>f7 : Symbol(f7, Decl(conditionalTypes1.ts, 99, 39)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 101, 12)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 101, 15)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 101, 12)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 101, 20)) +>FunctionProperties : Symbol(FunctionProperties, Decl(conditionalTypes1.ts, 92, 95)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 101, 12)) +>z : Symbol(z, Decl(conditionalTypes1.ts, 101, 46)) +>NonFunctionProperties : Symbol(NonFunctionProperties, Decl(conditionalTypes1.ts, 95, 98)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 101, 12)) x = y; // Error ->x : Symbol(x, Decl(conditionalTypes1.ts, 105, 15)) ->y : Symbol(y, Decl(conditionalTypes1.ts, 105, 20)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 101, 15)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 101, 20)) x = z; // Error ->x : Symbol(x, Decl(conditionalTypes1.ts, 105, 15)) ->z : Symbol(z, Decl(conditionalTypes1.ts, 105, 46)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 101, 15)) +>z : Symbol(z, Decl(conditionalTypes1.ts, 101, 46)) y = x; ->y : Symbol(y, Decl(conditionalTypes1.ts, 105, 20)) ->x : Symbol(x, Decl(conditionalTypes1.ts, 105, 15)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 101, 20)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 101, 15)) y = z; // Error ->y : Symbol(y, Decl(conditionalTypes1.ts, 105, 20)) ->z : Symbol(z, Decl(conditionalTypes1.ts, 105, 46)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 101, 20)) +>z : Symbol(z, Decl(conditionalTypes1.ts, 101, 46)) z = x; ->z : Symbol(z, Decl(conditionalTypes1.ts, 105, 46)) ->x : Symbol(x, Decl(conditionalTypes1.ts, 105, 15)) +>z : Symbol(z, Decl(conditionalTypes1.ts, 101, 46)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 101, 15)) z = y; // Error ->z : Symbol(z, Decl(conditionalTypes1.ts, 105, 46)) ->y : Symbol(y, Decl(conditionalTypes1.ts, 105, 20)) +>z : Symbol(z, Decl(conditionalTypes1.ts, 101, 46)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 101, 20)) } function f8(x: keyof T, y: FunctionPropertyNames, z: NonFunctionPropertyNames) { ->f8 : Symbol(f8, Decl(conditionalTypes1.ts, 112, 1)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 114, 12)) ->x : Symbol(x, Decl(conditionalTypes1.ts, 114, 15)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 114, 12)) ->y : Symbol(y, Decl(conditionalTypes1.ts, 114, 26)) ->FunctionPropertyNames : Symbol(FunctionPropertyNames, Decl(conditionalTypes1.ts, 94, 1)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 114, 12)) ->z : Symbol(z, Decl(conditionalTypes1.ts, 114, 55)) ->NonFunctionPropertyNames : Symbol(NonFunctionPropertyNames, Decl(conditionalTypes1.ts, 97, 63)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 114, 12)) +>f8 : Symbol(f8, Decl(conditionalTypes1.ts, 108, 1)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 110, 12)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 110, 15)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 110, 12)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 110, 26)) +>FunctionPropertyNames : Symbol(FunctionPropertyNames, Decl(conditionalTypes1.ts, 90, 1)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 110, 12)) +>z : Symbol(z, Decl(conditionalTypes1.ts, 110, 55)) +>NonFunctionPropertyNames : Symbol(NonFunctionPropertyNames, Decl(conditionalTypes1.ts, 93, 63)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 110, 12)) x = y; ->x : Symbol(x, Decl(conditionalTypes1.ts, 114, 15)) ->y : Symbol(y, Decl(conditionalTypes1.ts, 114, 26)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 110, 15)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 110, 26)) x = z; ->x : Symbol(x, Decl(conditionalTypes1.ts, 114, 15)) ->z : Symbol(z, Decl(conditionalTypes1.ts, 114, 55)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 110, 15)) +>z : Symbol(z, Decl(conditionalTypes1.ts, 110, 55)) y = x; // Error ->y : Symbol(y, Decl(conditionalTypes1.ts, 114, 26)) ->x : Symbol(x, Decl(conditionalTypes1.ts, 114, 15)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 110, 26)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 110, 15)) y = z; // Error ->y : Symbol(y, Decl(conditionalTypes1.ts, 114, 26)) ->z : Symbol(z, Decl(conditionalTypes1.ts, 114, 55)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 110, 26)) +>z : Symbol(z, Decl(conditionalTypes1.ts, 110, 55)) z = x; // Error ->z : Symbol(z, Decl(conditionalTypes1.ts, 114, 55)) ->x : Symbol(x, Decl(conditionalTypes1.ts, 114, 15)) +>z : Symbol(z, Decl(conditionalTypes1.ts, 110, 55)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 110, 15)) z = y; // Error ->z : Symbol(z, Decl(conditionalTypes1.ts, 114, 55)) ->y : Symbol(y, Decl(conditionalTypes1.ts, 114, 26)) +>z : Symbol(z, Decl(conditionalTypes1.ts, 110, 55)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 110, 26)) } type DeepReadonly = ->DeepReadonly : Symbol(DeepReadonly, Decl(conditionalTypes1.ts, 121, 1)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 123, 18)) +>DeepReadonly : Symbol(DeepReadonly, Decl(conditionalTypes1.ts, 117, 1)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 119, 18)) T extends any[] ? DeepReadonlyArray : ->T : Symbol(T, Decl(conditionalTypes1.ts, 123, 18)) ->DeepReadonlyArray : Symbol(DeepReadonlyArray, Decl(conditionalTypes1.ts, 126, 6)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 123, 18)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 119, 18)) +>DeepReadonlyArray : Symbol(DeepReadonlyArray, Decl(conditionalTypes1.ts, 122, 6)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 119, 18)) T extends object ? DeepReadonlyObject : ->T : Symbol(T, Decl(conditionalTypes1.ts, 123, 18)) ->DeepReadonlyObject : Symbol(DeepReadonlyObject, Decl(conditionalTypes1.ts, 128, 72)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 123, 18)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 119, 18)) +>DeepReadonlyObject : Symbol(DeepReadonlyObject, Decl(conditionalTypes1.ts, 124, 72)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 119, 18)) T; ->T : Symbol(T, Decl(conditionalTypes1.ts, 123, 18)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 119, 18)) interface DeepReadonlyArray extends ReadonlyArray> {} ->DeepReadonlyArray : Symbol(DeepReadonlyArray, Decl(conditionalTypes1.ts, 126, 6)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 128, 28)) +>DeepReadonlyArray : Symbol(DeepReadonlyArray, Decl(conditionalTypes1.ts, 122, 6)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 124, 28)) >ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.d.ts, --, --)) ->DeepReadonly : Symbol(DeepReadonly, Decl(conditionalTypes1.ts, 121, 1)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 128, 28)) +>DeepReadonly : Symbol(DeepReadonly, Decl(conditionalTypes1.ts, 117, 1)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 124, 28)) type DeepReadonlyObject = { ->DeepReadonlyObject : Symbol(DeepReadonlyObject, Decl(conditionalTypes1.ts, 128, 72)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 130, 24)) +>DeepReadonlyObject : Symbol(DeepReadonlyObject, Decl(conditionalTypes1.ts, 124, 72)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 126, 24)) readonly [P in NonFunctionPropertyNames]: DeepReadonly; ->P : Symbol(P, Decl(conditionalTypes1.ts, 131, 14)) ->NonFunctionPropertyNames : Symbol(NonFunctionPropertyNames, Decl(conditionalTypes1.ts, 97, 63)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 130, 24)) ->DeepReadonly : Symbol(DeepReadonly, Decl(conditionalTypes1.ts, 121, 1)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 130, 24)) ->P : Symbol(P, Decl(conditionalTypes1.ts, 131, 14)) +>P : Symbol(P, Decl(conditionalTypes1.ts, 127, 14)) +>NonFunctionPropertyNames : Symbol(NonFunctionPropertyNames, Decl(conditionalTypes1.ts, 93, 63)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 126, 24)) +>DeepReadonly : Symbol(DeepReadonly, Decl(conditionalTypes1.ts, 117, 1)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 126, 24)) +>P : Symbol(P, Decl(conditionalTypes1.ts, 127, 14)) }; function f10(part: DeepReadonly) { ->f10 : Symbol(f10, Decl(conditionalTypes1.ts, 132, 2)) ->part : Symbol(part, Decl(conditionalTypes1.ts, 134, 13)) ->DeepReadonly : Symbol(DeepReadonly, Decl(conditionalTypes1.ts, 121, 1)) ->Part : Symbol(Part, Decl(conditionalTypes1.ts, 87, 34)) +>f10 : Symbol(f10, Decl(conditionalTypes1.ts, 128, 2)) +>part : Symbol(part, Decl(conditionalTypes1.ts, 130, 13)) +>DeepReadonly : Symbol(DeepReadonly, Decl(conditionalTypes1.ts, 117, 1)) +>Part : Symbol(Part, Decl(conditionalTypes1.ts, 83, 34)) let name: string = part.name; ->name : Symbol(name, Decl(conditionalTypes1.ts, 135, 7)) +>name : Symbol(name, Decl(conditionalTypes1.ts, 131, 7)) >part.name : Symbol(name) ->part : Symbol(part, Decl(conditionalTypes1.ts, 134, 13)) +>part : Symbol(part, Decl(conditionalTypes1.ts, 130, 13)) >name : Symbol(name) let id: number = part.subparts[0].id; ->id : Symbol(id, Decl(conditionalTypes1.ts, 136, 7)) +>id : Symbol(id, Decl(conditionalTypes1.ts, 132, 7)) >part.subparts[0].id : Symbol(id) >part.subparts : Symbol(subparts) ->part : Symbol(part, Decl(conditionalTypes1.ts, 134, 13)) +>part : Symbol(part, Decl(conditionalTypes1.ts, 130, 13)) >subparts : Symbol(subparts) >id : Symbol(id) part.id = part.id; // Error >part.id : Symbol(id) ->part : Symbol(part, Decl(conditionalTypes1.ts, 134, 13)) +>part : Symbol(part, Decl(conditionalTypes1.ts, 130, 13)) >id : Symbol(id) >part.id : Symbol(id) ->part : Symbol(part, Decl(conditionalTypes1.ts, 134, 13)) +>part : Symbol(part, Decl(conditionalTypes1.ts, 130, 13)) >id : Symbol(id) part.subparts[0] = part.subparts[0]; // Error >part.subparts : Symbol(subparts) ->part : Symbol(part, Decl(conditionalTypes1.ts, 134, 13)) +>part : Symbol(part, Decl(conditionalTypes1.ts, 130, 13)) >subparts : Symbol(subparts) >part.subparts : Symbol(subparts) ->part : Symbol(part, Decl(conditionalTypes1.ts, 134, 13)) +>part : Symbol(part, Decl(conditionalTypes1.ts, 130, 13)) >subparts : Symbol(subparts) part.subparts[0].id = part.subparts[0].id; // Error >part.subparts[0].id : Symbol(id) >part.subparts : Symbol(subparts) ->part : Symbol(part, Decl(conditionalTypes1.ts, 134, 13)) +>part : Symbol(part, Decl(conditionalTypes1.ts, 130, 13)) >subparts : Symbol(subparts) >id : Symbol(id) >part.subparts[0].id : Symbol(id) >part.subparts : Symbol(subparts) ->part : Symbol(part, Decl(conditionalTypes1.ts, 134, 13)) +>part : Symbol(part, Decl(conditionalTypes1.ts, 130, 13)) >subparts : Symbol(subparts) >id : Symbol(id) part.updatePart("hello"); // Error ->part : Symbol(part, Decl(conditionalTypes1.ts, 134, 13)) +>part : Symbol(part, Decl(conditionalTypes1.ts, 130, 13)) } type ZeroOf = T extends number ? 0 : T extends string ? "" : false; ->ZeroOf : Symbol(ZeroOf, Decl(conditionalTypes1.ts, 141, 1)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 143, 12)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 143, 12)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 143, 12)) +>ZeroOf : Symbol(ZeroOf, Decl(conditionalTypes1.ts, 137, 1)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 139, 12)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 139, 12)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 139, 12)) function zeroOf(value: T) { ->zeroOf : Symbol(zeroOf, Decl(conditionalTypes1.ts, 143, 104)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 145, 16)) ->value : Symbol(value, Decl(conditionalTypes1.ts, 145, 53)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 145, 16)) +>zeroOf : Symbol(zeroOf, Decl(conditionalTypes1.ts, 139, 104)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 141, 16)) +>value : Symbol(value, Decl(conditionalTypes1.ts, 141, 53)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 141, 16)) return >(typeof value === "number" ? 0 : typeof value === "string" ? "" : false); ->ZeroOf : Symbol(ZeroOf, Decl(conditionalTypes1.ts, 141, 1)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 145, 16)) ->value : Symbol(value, Decl(conditionalTypes1.ts, 145, 53)) ->value : Symbol(value, Decl(conditionalTypes1.ts, 145, 53)) +>ZeroOf : Symbol(ZeroOf, Decl(conditionalTypes1.ts, 137, 1)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 141, 16)) +>value : Symbol(value, Decl(conditionalTypes1.ts, 141, 53)) +>value : Symbol(value, Decl(conditionalTypes1.ts, 141, 53)) } function f20(n: number, b: boolean, x: number | boolean, y: T) { ->f20 : Symbol(f20, Decl(conditionalTypes1.ts, 147, 1)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 149, 13)) ->n : Symbol(n, Decl(conditionalTypes1.ts, 149, 31)) ->b : Symbol(b, Decl(conditionalTypes1.ts, 149, 41)) ->x : Symbol(x, Decl(conditionalTypes1.ts, 149, 53)) ->y : Symbol(y, Decl(conditionalTypes1.ts, 149, 74)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 149, 13)) +>f20 : Symbol(f20, Decl(conditionalTypes1.ts, 143, 1)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 145, 13)) +>n : Symbol(n, Decl(conditionalTypes1.ts, 145, 31)) +>b : Symbol(b, Decl(conditionalTypes1.ts, 145, 41)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 145, 53)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 145, 74)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 145, 13)) zeroOf(5); // 0 ->zeroOf : Symbol(zeroOf, Decl(conditionalTypes1.ts, 143, 104)) +>zeroOf : Symbol(zeroOf, Decl(conditionalTypes1.ts, 139, 104)) zeroOf("hello"); // "" ->zeroOf : Symbol(zeroOf, Decl(conditionalTypes1.ts, 143, 104)) +>zeroOf : Symbol(zeroOf, Decl(conditionalTypes1.ts, 139, 104)) zeroOf(true); // false ->zeroOf : Symbol(zeroOf, Decl(conditionalTypes1.ts, 143, 104)) +>zeroOf : Symbol(zeroOf, Decl(conditionalTypes1.ts, 139, 104)) zeroOf(n); // 0 ->zeroOf : Symbol(zeroOf, Decl(conditionalTypes1.ts, 143, 104)) ->n : Symbol(n, Decl(conditionalTypes1.ts, 149, 31)) +>zeroOf : Symbol(zeroOf, Decl(conditionalTypes1.ts, 139, 104)) +>n : Symbol(n, Decl(conditionalTypes1.ts, 145, 31)) zeroOf(b); // False ->zeroOf : Symbol(zeroOf, Decl(conditionalTypes1.ts, 143, 104)) ->b : Symbol(b, Decl(conditionalTypes1.ts, 149, 41)) +>zeroOf : Symbol(zeroOf, Decl(conditionalTypes1.ts, 139, 104)) +>b : Symbol(b, Decl(conditionalTypes1.ts, 145, 41)) zeroOf(x); // 0 | false ->zeroOf : Symbol(zeroOf, Decl(conditionalTypes1.ts, 143, 104)) ->x : Symbol(x, Decl(conditionalTypes1.ts, 149, 53)) +>zeroOf : Symbol(zeroOf, Decl(conditionalTypes1.ts, 139, 104)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 145, 53)) zeroOf(y); // ZeroOf ->zeroOf : Symbol(zeroOf, Decl(conditionalTypes1.ts, 143, 104)) ->y : Symbol(y, Decl(conditionalTypes1.ts, 149, 74)) +>zeroOf : Symbol(zeroOf, Decl(conditionalTypes1.ts, 139, 104)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 145, 74)) } function f21(x: T, y: ZeroOf) { ->f21 : Symbol(f21, Decl(conditionalTypes1.ts, 157, 1)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 159, 13)) ->x : Symbol(x, Decl(conditionalTypes1.ts, 159, 40)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 159, 13)) ->y : Symbol(y, Decl(conditionalTypes1.ts, 159, 45)) ->ZeroOf : Symbol(ZeroOf, Decl(conditionalTypes1.ts, 141, 1)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 159, 13)) +>f21 : Symbol(f21, Decl(conditionalTypes1.ts, 153, 1)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 155, 13)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 155, 40)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 155, 13)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 155, 45)) +>ZeroOf : Symbol(ZeroOf, Decl(conditionalTypes1.ts, 137, 1)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 155, 13)) let z1: number | string = y; ->z1 : Symbol(z1, Decl(conditionalTypes1.ts, 160, 7)) ->y : Symbol(y, Decl(conditionalTypes1.ts, 159, 45)) +>z1 : Symbol(z1, Decl(conditionalTypes1.ts, 156, 7)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 155, 45)) let z2: 0 | "" = y; ->z2 : Symbol(z2, Decl(conditionalTypes1.ts, 161, 7)) ->y : Symbol(y, Decl(conditionalTypes1.ts, 159, 45)) +>z2 : Symbol(z2, Decl(conditionalTypes1.ts, 157, 7)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 155, 45)) x = y; // Error ->x : Symbol(x, Decl(conditionalTypes1.ts, 159, 40)) ->y : Symbol(y, Decl(conditionalTypes1.ts, 159, 45)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 155, 40)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 155, 45)) y = x; // Error ->y : Symbol(y, Decl(conditionalTypes1.ts, 159, 45)) ->x : Symbol(x, Decl(conditionalTypes1.ts, 159, 40)) +>y : Symbol(y, Decl(conditionalTypes1.ts, 155, 45)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 155, 40)) } type Extends = T extends U ? true : false; ->Extends : Symbol(Extends, Decl(conditionalTypes1.ts, 164, 1)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 166, 13)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 166, 15)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 166, 13)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 166, 15)) +>Extends : Symbol(Extends, Decl(conditionalTypes1.ts, 160, 1)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 162, 13)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 162, 15)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 162, 13)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 162, 15)) type If = C extends true ? T : F; ->If : Symbol(If, Decl(conditionalTypes1.ts, 166, 48)) ->C : Symbol(C, Decl(conditionalTypes1.ts, 167, 8)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 167, 26)) ->F : Symbol(F, Decl(conditionalTypes1.ts, 167, 29)) ->C : Symbol(C, Decl(conditionalTypes1.ts, 167, 8)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 167, 26)) ->F : Symbol(F, Decl(conditionalTypes1.ts, 167, 29)) +>If : Symbol(If, Decl(conditionalTypes1.ts, 162, 48)) +>C : Symbol(C, Decl(conditionalTypes1.ts, 163, 8)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 163, 26)) +>F : Symbol(F, Decl(conditionalTypes1.ts, 163, 29)) +>C : Symbol(C, Decl(conditionalTypes1.ts, 163, 8)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 163, 26)) +>F : Symbol(F, Decl(conditionalTypes1.ts, 163, 29)) type Not = If; ->Not : Symbol(Not, Decl(conditionalTypes1.ts, 167, 58)) ->C : Symbol(C, Decl(conditionalTypes1.ts, 168, 9)) ->If : Symbol(If, Decl(conditionalTypes1.ts, 166, 48)) ->C : Symbol(C, Decl(conditionalTypes1.ts, 168, 9)) +>Not : Symbol(Not, Decl(conditionalTypes1.ts, 163, 58)) +>C : Symbol(C, Decl(conditionalTypes1.ts, 164, 9)) +>If : Symbol(If, Decl(conditionalTypes1.ts, 162, 48)) +>C : Symbol(C, Decl(conditionalTypes1.ts, 164, 9)) type And = If; ->And : Symbol(And, Decl(conditionalTypes1.ts, 168, 49)) ->A : Symbol(A, Decl(conditionalTypes1.ts, 169, 9)) ->B : Symbol(B, Decl(conditionalTypes1.ts, 169, 27)) ->If : Symbol(If, Decl(conditionalTypes1.ts, 166, 48)) ->A : Symbol(A, Decl(conditionalTypes1.ts, 169, 9)) ->B : Symbol(B, Decl(conditionalTypes1.ts, 169, 27)) +>And : Symbol(And, Decl(conditionalTypes1.ts, 164, 49)) +>A : Symbol(A, Decl(conditionalTypes1.ts, 165, 9)) +>B : Symbol(B, Decl(conditionalTypes1.ts, 165, 27)) +>If : Symbol(If, Decl(conditionalTypes1.ts, 162, 48)) +>A : Symbol(A, Decl(conditionalTypes1.ts, 165, 9)) +>B : Symbol(B, Decl(conditionalTypes1.ts, 165, 27)) type Or = If; ->Or : Symbol(Or, Decl(conditionalTypes1.ts, 169, 65)) ->A : Symbol(A, Decl(conditionalTypes1.ts, 170, 8)) ->B : Symbol(B, Decl(conditionalTypes1.ts, 170, 26)) ->If : Symbol(If, Decl(conditionalTypes1.ts, 166, 48)) ->A : Symbol(A, Decl(conditionalTypes1.ts, 170, 8)) ->B : Symbol(B, Decl(conditionalTypes1.ts, 170, 26)) +>Or : Symbol(Or, Decl(conditionalTypes1.ts, 165, 65)) +>A : Symbol(A, Decl(conditionalTypes1.ts, 166, 8)) +>B : Symbol(B, Decl(conditionalTypes1.ts, 166, 26)) +>If : Symbol(If, Decl(conditionalTypes1.ts, 162, 48)) +>A : Symbol(A, Decl(conditionalTypes1.ts, 166, 8)) +>B : Symbol(B, Decl(conditionalTypes1.ts, 166, 26)) type IsString = Extends; ->IsString : Symbol(IsString, Decl(conditionalTypes1.ts, 170, 63)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 172, 14)) ->Extends : Symbol(Extends, Decl(conditionalTypes1.ts, 164, 1)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 172, 14)) +>IsString : Symbol(IsString, Decl(conditionalTypes1.ts, 166, 63)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 168, 14)) +>Extends : Symbol(Extends, Decl(conditionalTypes1.ts, 160, 1)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 168, 14)) type Q1 = IsString; // false ->Q1 : Symbol(Q1, Decl(conditionalTypes1.ts, 172, 38)) ->IsString : Symbol(IsString, Decl(conditionalTypes1.ts, 170, 63)) +>Q1 : Symbol(Q1, Decl(conditionalTypes1.ts, 168, 38)) +>IsString : Symbol(IsString, Decl(conditionalTypes1.ts, 166, 63)) type Q2 = IsString<"abc">; // true ->Q2 : Symbol(Q2, Decl(conditionalTypes1.ts, 174, 27)) ->IsString : Symbol(IsString, Decl(conditionalTypes1.ts, 170, 63)) +>Q2 : Symbol(Q2, Decl(conditionalTypes1.ts, 170, 27)) +>IsString : Symbol(IsString, Decl(conditionalTypes1.ts, 166, 63)) type Q3 = IsString; // boolean ->Q3 : Symbol(Q3, Decl(conditionalTypes1.ts, 175, 26)) ->IsString : Symbol(IsString, Decl(conditionalTypes1.ts, 170, 63)) +>Q3 : Symbol(Q3, Decl(conditionalTypes1.ts, 171, 26)) +>IsString : Symbol(IsString, Decl(conditionalTypes1.ts, 166, 63)) type Q4 = IsString; // boolean ->Q4 : Symbol(Q4, Decl(conditionalTypes1.ts, 176, 24)) ->IsString : Symbol(IsString, Decl(conditionalTypes1.ts, 170, 63)) +>Q4 : Symbol(Q4, Decl(conditionalTypes1.ts, 172, 24)) +>IsString : Symbol(IsString, Decl(conditionalTypes1.ts, 166, 63)) type N1 = Not; // true ->N1 : Symbol(N1, Decl(conditionalTypes1.ts, 177, 26)) ->Not : Symbol(Not, Decl(conditionalTypes1.ts, 167, 58)) +>N1 : Symbol(N1, Decl(conditionalTypes1.ts, 173, 26)) +>Not : Symbol(Not, Decl(conditionalTypes1.ts, 163, 58)) type N2 = Not; // false ->N2 : Symbol(N2, Decl(conditionalTypes1.ts, 179, 21)) ->Not : Symbol(Not, Decl(conditionalTypes1.ts, 167, 58)) +>N2 : Symbol(N2, Decl(conditionalTypes1.ts, 175, 21)) +>Not : Symbol(Not, Decl(conditionalTypes1.ts, 163, 58)) type N3 = Not; // boolean ->N3 : Symbol(N3, Decl(conditionalTypes1.ts, 180, 20)) ->Not : Symbol(Not, Decl(conditionalTypes1.ts, 167, 58)) +>N3 : Symbol(N3, Decl(conditionalTypes1.ts, 176, 20)) +>Not : Symbol(Not, Decl(conditionalTypes1.ts, 163, 58)) type A1 = And; // false ->A1 : Symbol(A1, Decl(conditionalTypes1.ts, 181, 23)) ->And : Symbol(And, Decl(conditionalTypes1.ts, 168, 49)) +>A1 : Symbol(A1, Decl(conditionalTypes1.ts, 177, 23)) +>And : Symbol(And, Decl(conditionalTypes1.ts, 164, 49)) type A2 = And; // false ->A2 : Symbol(A2, Decl(conditionalTypes1.ts, 183, 28)) ->And : Symbol(And, Decl(conditionalTypes1.ts, 168, 49)) +>A2 : Symbol(A2, Decl(conditionalTypes1.ts, 179, 28)) +>And : Symbol(And, Decl(conditionalTypes1.ts, 164, 49)) type A3 = And; // false ->A3 : Symbol(A3, Decl(conditionalTypes1.ts, 184, 27)) ->And : Symbol(And, Decl(conditionalTypes1.ts, 168, 49)) +>A3 : Symbol(A3, Decl(conditionalTypes1.ts, 180, 27)) +>And : Symbol(And, Decl(conditionalTypes1.ts, 164, 49)) type A4 = And; // true ->A4 : Symbol(A4, Decl(conditionalTypes1.ts, 185, 27)) ->And : Symbol(And, Decl(conditionalTypes1.ts, 168, 49)) +>A4 : Symbol(A4, Decl(conditionalTypes1.ts, 181, 27)) +>And : Symbol(And, Decl(conditionalTypes1.ts, 164, 49)) type A5 = And; // false ->A5 : Symbol(A5, Decl(conditionalTypes1.ts, 186, 26)) ->And : Symbol(And, Decl(conditionalTypes1.ts, 168, 49)) +>A5 : Symbol(A5, Decl(conditionalTypes1.ts, 182, 26)) +>And : Symbol(And, Decl(conditionalTypes1.ts, 164, 49)) type A6 = And; // false ->A6 : Symbol(A6, Decl(conditionalTypes1.ts, 187, 30)) ->And : Symbol(And, Decl(conditionalTypes1.ts, 168, 49)) +>A6 : Symbol(A6, Decl(conditionalTypes1.ts, 183, 30)) +>And : Symbol(And, Decl(conditionalTypes1.ts, 164, 49)) type A7 = And; // boolean ->A7 : Symbol(A7, Decl(conditionalTypes1.ts, 188, 30)) ->And : Symbol(And, Decl(conditionalTypes1.ts, 168, 49)) +>A7 : Symbol(A7, Decl(conditionalTypes1.ts, 184, 30)) +>And : Symbol(And, Decl(conditionalTypes1.ts, 164, 49)) type A8 = And; // boolean ->A8 : Symbol(A8, Decl(conditionalTypes1.ts, 189, 29)) ->And : Symbol(And, Decl(conditionalTypes1.ts, 168, 49)) +>A8 : Symbol(A8, Decl(conditionalTypes1.ts, 185, 29)) +>And : Symbol(And, Decl(conditionalTypes1.ts, 164, 49)) type A9 = And; // boolean ->A9 : Symbol(A9, Decl(conditionalTypes1.ts, 190, 29)) ->And : Symbol(And, Decl(conditionalTypes1.ts, 168, 49)) +>A9 : Symbol(A9, Decl(conditionalTypes1.ts, 186, 29)) +>And : Symbol(And, Decl(conditionalTypes1.ts, 164, 49)) type O1 = Or; // false ->O1 : Symbol(O1, Decl(conditionalTypes1.ts, 191, 32)) ->Or : Symbol(Or, Decl(conditionalTypes1.ts, 169, 65)) +>O1 : Symbol(O1, Decl(conditionalTypes1.ts, 187, 32)) +>Or : Symbol(Or, Decl(conditionalTypes1.ts, 165, 65)) type O2 = Or; // true ->O2 : Symbol(O2, Decl(conditionalTypes1.ts, 193, 27)) ->Or : Symbol(Or, Decl(conditionalTypes1.ts, 169, 65)) +>O2 : Symbol(O2, Decl(conditionalTypes1.ts, 189, 27)) +>Or : Symbol(Or, Decl(conditionalTypes1.ts, 165, 65)) type O3 = Or; // true ->O3 : Symbol(O3, Decl(conditionalTypes1.ts, 194, 26)) ->Or : Symbol(Or, Decl(conditionalTypes1.ts, 169, 65)) +>O3 : Symbol(O3, Decl(conditionalTypes1.ts, 190, 26)) +>Or : Symbol(Or, Decl(conditionalTypes1.ts, 165, 65)) type O4 = Or; // true ->O4 : Symbol(O4, Decl(conditionalTypes1.ts, 195, 26)) ->Or : Symbol(Or, Decl(conditionalTypes1.ts, 169, 65)) +>O4 : Symbol(O4, Decl(conditionalTypes1.ts, 191, 26)) +>Or : Symbol(Or, Decl(conditionalTypes1.ts, 165, 65)) type O5 = Or; // boolean ->O5 : Symbol(O5, Decl(conditionalTypes1.ts, 196, 25)) ->Or : Symbol(Or, Decl(conditionalTypes1.ts, 169, 65)) +>O5 : Symbol(O5, Decl(conditionalTypes1.ts, 192, 25)) +>Or : Symbol(Or, Decl(conditionalTypes1.ts, 165, 65)) type O6 = Or; // boolean ->O6 : Symbol(O6, Decl(conditionalTypes1.ts, 197, 29)) ->Or : Symbol(Or, Decl(conditionalTypes1.ts, 169, 65)) +>O6 : Symbol(O6, Decl(conditionalTypes1.ts, 193, 29)) +>Or : Symbol(Or, Decl(conditionalTypes1.ts, 165, 65)) type O7 = Or; // true ->O7 : Symbol(O7, Decl(conditionalTypes1.ts, 198, 29)) ->Or : Symbol(Or, Decl(conditionalTypes1.ts, 169, 65)) +>O7 : Symbol(O7, Decl(conditionalTypes1.ts, 194, 29)) +>Or : Symbol(Or, Decl(conditionalTypes1.ts, 165, 65)) type O8 = Or; // true ->O8 : Symbol(O8, Decl(conditionalTypes1.ts, 199, 28)) ->Or : Symbol(Or, Decl(conditionalTypes1.ts, 169, 65)) +>O8 : Symbol(O8, Decl(conditionalTypes1.ts, 195, 28)) +>Or : Symbol(Or, Decl(conditionalTypes1.ts, 165, 65)) type O9 = Or; // boolean ->O9 : Symbol(O9, Decl(conditionalTypes1.ts, 200, 28)) ->Or : Symbol(Or, Decl(conditionalTypes1.ts, 169, 65)) +>O9 : Symbol(O9, Decl(conditionalTypes1.ts, 196, 28)) +>Or : Symbol(Or, Decl(conditionalTypes1.ts, 165, 65)) type T40 = never extends never ? true : false; // true ->T40 : Symbol(T40, Decl(conditionalTypes1.ts, 201, 31)) +>T40 : Symbol(T40, Decl(conditionalTypes1.ts, 197, 31)) type T41 = number extends never ? true : false; // false ->T41 : Symbol(T41, Decl(conditionalTypes1.ts, 203, 46)) +>T41 : Symbol(T41, Decl(conditionalTypes1.ts, 199, 46)) type T42 = never extends number ? true : false; // boolean ->T42 : Symbol(T42, Decl(conditionalTypes1.ts, 204, 47)) +>T42 : Symbol(T42, Decl(conditionalTypes1.ts, 200, 47)) type IsNever = T extends never ? true : false; ->IsNever : Symbol(IsNever, Decl(conditionalTypes1.ts, 205, 47)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 207, 13)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 207, 13)) +>IsNever : Symbol(IsNever, Decl(conditionalTypes1.ts, 201, 47)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 203, 13)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 203, 13)) type T50 = IsNever; // true ->T50 : Symbol(T50, Decl(conditionalTypes1.ts, 207, 49)) ->IsNever : Symbol(IsNever, Decl(conditionalTypes1.ts, 205, 47)) +>T50 : Symbol(T50, Decl(conditionalTypes1.ts, 203, 49)) +>IsNever : Symbol(IsNever, Decl(conditionalTypes1.ts, 201, 47)) type T51 = IsNever; // false ->T51 : Symbol(T51, Decl(conditionalTypes1.ts, 209, 26)) ->IsNever : Symbol(IsNever, Decl(conditionalTypes1.ts, 205, 47)) +>T51 : Symbol(T51, Decl(conditionalTypes1.ts, 205, 26)) +>IsNever : Symbol(IsNever, Decl(conditionalTypes1.ts, 201, 47)) type T52 = IsNever; // false ->T52 : Symbol(T52, Decl(conditionalTypes1.ts, 210, 27)) ->IsNever : Symbol(IsNever, Decl(conditionalTypes1.ts, 205, 47)) +>T52 : Symbol(T52, Decl(conditionalTypes1.ts, 206, 27)) +>IsNever : Symbol(IsNever, Decl(conditionalTypes1.ts, 201, 47)) // Repros from #21664 type Eq = T extends U ? U extends T ? true : false : false; ->Eq : Symbol(Eq, Decl(conditionalTypes1.ts, 211, 24)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 215, 8)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 215, 10)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 215, 8)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 215, 10)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 215, 10)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 215, 8)) +>Eq : Symbol(Eq, Decl(conditionalTypes1.ts, 207, 24)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 211, 8)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 211, 10)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 211, 8)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 211, 10)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 211, 10)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 211, 8)) type T60 = Eq; // true ->T60 : Symbol(T60, Decl(conditionalTypes1.ts, 215, 65)) ->Eq : Symbol(Eq, Decl(conditionalTypes1.ts, 211, 24)) +>T60 : Symbol(T60, Decl(conditionalTypes1.ts, 211, 65)) +>Eq : Symbol(Eq, Decl(conditionalTypes1.ts, 207, 24)) type T61 = Eq; // false ->T61 : Symbol(T61, Decl(conditionalTypes1.ts, 216, 26)) ->Eq : Symbol(Eq, Decl(conditionalTypes1.ts, 211, 24)) +>T61 : Symbol(T61, Decl(conditionalTypes1.ts, 212, 26)) +>Eq : Symbol(Eq, Decl(conditionalTypes1.ts, 207, 24)) type T62 = Eq; // false ->T62 : Symbol(T62, Decl(conditionalTypes1.ts, 217, 27)) ->Eq : Symbol(Eq, Decl(conditionalTypes1.ts, 211, 24)) +>T62 : Symbol(T62, Decl(conditionalTypes1.ts, 213, 27)) +>Eq : Symbol(Eq, Decl(conditionalTypes1.ts, 207, 24)) type T63 = Eq; // true ->T63 : Symbol(T63, Decl(conditionalTypes1.ts, 218, 27)) ->Eq : Symbol(Eq, Decl(conditionalTypes1.ts, 211, 24)) +>T63 : Symbol(T63, Decl(conditionalTypes1.ts, 214, 27)) +>Eq : Symbol(Eq, Decl(conditionalTypes1.ts, 207, 24)) type Eq1 = Eq extends false ? false : true; ->Eq1 : Symbol(Eq1, Decl(conditionalTypes1.ts, 219, 28)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 221, 9)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 221, 11)) ->Eq : Symbol(Eq, Decl(conditionalTypes1.ts, 211, 24)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 221, 9)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 221, 11)) +>Eq1 : Symbol(Eq1, Decl(conditionalTypes1.ts, 215, 28)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 217, 9)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 217, 11)) +>Eq : Symbol(Eq, Decl(conditionalTypes1.ts, 207, 24)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 217, 9)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 217, 11)) type T70 = Eq1; // true ->T70 : Symbol(T70, Decl(conditionalTypes1.ts, 221, 55)) ->Eq1 : Symbol(Eq1, Decl(conditionalTypes1.ts, 219, 28)) +>T70 : Symbol(T70, Decl(conditionalTypes1.ts, 217, 55)) +>Eq1 : Symbol(Eq1, Decl(conditionalTypes1.ts, 215, 28)) type T71 = Eq1; // false ->T71 : Symbol(T71, Decl(conditionalTypes1.ts, 222, 27)) ->Eq1 : Symbol(Eq1, Decl(conditionalTypes1.ts, 219, 28)) +>T71 : Symbol(T71, Decl(conditionalTypes1.ts, 218, 27)) +>Eq1 : Symbol(Eq1, Decl(conditionalTypes1.ts, 215, 28)) type T72 = Eq1; // false ->T72 : Symbol(T72, Decl(conditionalTypes1.ts, 223, 28)) ->Eq1 : Symbol(Eq1, Decl(conditionalTypes1.ts, 219, 28)) +>T72 : Symbol(T72, Decl(conditionalTypes1.ts, 219, 28)) +>Eq1 : Symbol(Eq1, Decl(conditionalTypes1.ts, 215, 28)) type T73 = Eq1; // true ->T73 : Symbol(T73, Decl(conditionalTypes1.ts, 224, 28)) ->Eq1 : Symbol(Eq1, Decl(conditionalTypes1.ts, 219, 28)) +>T73 : Symbol(T73, Decl(conditionalTypes1.ts, 220, 28)) +>Eq1 : Symbol(Eq1, Decl(conditionalTypes1.ts, 215, 28)) type Eq2 = Eq extends true ? true : false; ->Eq2 : Symbol(Eq2, Decl(conditionalTypes1.ts, 225, 29)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 227, 9)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 227, 11)) ->Eq : Symbol(Eq, Decl(conditionalTypes1.ts, 211, 24)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 227, 9)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 227, 11)) +>Eq2 : Symbol(Eq2, Decl(conditionalTypes1.ts, 221, 29)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 223, 9)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 223, 11)) +>Eq : Symbol(Eq, Decl(conditionalTypes1.ts, 207, 24)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 223, 9)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 223, 11)) type T80 = Eq2; // true ->T80 : Symbol(T80, Decl(conditionalTypes1.ts, 227, 54)) ->Eq2 : Symbol(Eq2, Decl(conditionalTypes1.ts, 225, 29)) +>T80 : Symbol(T80, Decl(conditionalTypes1.ts, 223, 54)) +>Eq2 : Symbol(Eq2, Decl(conditionalTypes1.ts, 221, 29)) type T81 = Eq2; // false ->T81 : Symbol(T81, Decl(conditionalTypes1.ts, 228, 27)) ->Eq2 : Symbol(Eq2, Decl(conditionalTypes1.ts, 225, 29)) +>T81 : Symbol(T81, Decl(conditionalTypes1.ts, 224, 27)) +>Eq2 : Symbol(Eq2, Decl(conditionalTypes1.ts, 221, 29)) type T82 = Eq2; // false ->T82 : Symbol(T82, Decl(conditionalTypes1.ts, 229, 28)) ->Eq2 : Symbol(Eq2, Decl(conditionalTypes1.ts, 225, 29)) +>T82 : Symbol(T82, Decl(conditionalTypes1.ts, 225, 28)) +>Eq2 : Symbol(Eq2, Decl(conditionalTypes1.ts, 221, 29)) type T83 = Eq2; // true ->T83 : Symbol(T83, Decl(conditionalTypes1.ts, 230, 28)) ->Eq2 : Symbol(Eq2, Decl(conditionalTypes1.ts, 225, 29)) +>T83 : Symbol(T83, Decl(conditionalTypes1.ts, 226, 28)) +>Eq2 : Symbol(Eq2, Decl(conditionalTypes1.ts, 221, 29)) // Repro from #21756 type Foo = T extends string ? boolean : number; ->Foo : Symbol(Foo, Decl(conditionalTypes1.ts, 231, 29)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 235, 9)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 235, 9)) +>Foo : Symbol(Foo, Decl(conditionalTypes1.ts, 227, 29)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 231, 9)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 231, 9)) type Bar = T extends string ? boolean : number; ->Bar : Symbol(Bar, Decl(conditionalTypes1.ts, 235, 50)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 236, 9)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 236, 9)) +>Bar : Symbol(Bar, Decl(conditionalTypes1.ts, 231, 50)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 232, 9)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 232, 9)) const convert = (value: Foo): Bar => value; ->convert : Symbol(convert, Decl(conditionalTypes1.ts, 237, 5)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 237, 17)) ->value : Symbol(value, Decl(conditionalTypes1.ts, 237, 20)) ->Foo : Symbol(Foo, Decl(conditionalTypes1.ts, 231, 29)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 237, 17)) ->Bar : Symbol(Bar, Decl(conditionalTypes1.ts, 235, 50)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 237, 17)) ->value : Symbol(value, Decl(conditionalTypes1.ts, 237, 20)) +>convert : Symbol(convert, Decl(conditionalTypes1.ts, 233, 5)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 233, 17)) +>value : Symbol(value, Decl(conditionalTypes1.ts, 233, 20)) +>Foo : Symbol(Foo, Decl(conditionalTypes1.ts, 227, 29)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 233, 17)) +>Bar : Symbol(Bar, Decl(conditionalTypes1.ts, 231, 50)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 233, 17)) +>value : Symbol(value, Decl(conditionalTypes1.ts, 233, 20)) type Baz = Foo; ->Baz : Symbol(Baz, Decl(conditionalTypes1.ts, 237, 52)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 239, 9)) ->Foo : Symbol(Foo, Decl(conditionalTypes1.ts, 231, 29)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 239, 9)) +>Baz : Symbol(Baz, Decl(conditionalTypes1.ts, 233, 52)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 235, 9)) +>Foo : Symbol(Foo, Decl(conditionalTypes1.ts, 227, 29)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 235, 9)) const convert2 = (value: Foo): Baz => value; ->convert2 : Symbol(convert2, Decl(conditionalTypes1.ts, 240, 5)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 240, 18)) ->value : Symbol(value, Decl(conditionalTypes1.ts, 240, 21)) ->Foo : Symbol(Foo, Decl(conditionalTypes1.ts, 231, 29)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 240, 18)) ->Baz : Symbol(Baz, Decl(conditionalTypes1.ts, 237, 52)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 240, 18)) ->value : Symbol(value, Decl(conditionalTypes1.ts, 240, 21)) +>convert2 : Symbol(convert2, Decl(conditionalTypes1.ts, 236, 5)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 236, 18)) +>value : Symbol(value, Decl(conditionalTypes1.ts, 236, 21)) +>Foo : Symbol(Foo, Decl(conditionalTypes1.ts, 227, 29)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 236, 18)) +>Baz : Symbol(Baz, Decl(conditionalTypes1.ts, 233, 52)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 236, 18)) +>value : Symbol(value, Decl(conditionalTypes1.ts, 236, 21)) function f31() { ->f31 : Symbol(f31, Decl(conditionalTypes1.ts, 240, 53)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 242, 13)) +>f31 : Symbol(f31, Decl(conditionalTypes1.ts, 236, 53)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 238, 13)) type T1 = T extends string ? boolean : number; ->T1 : Symbol(T1, Decl(conditionalTypes1.ts, 242, 19)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 242, 13)) +>T1 : Symbol(T1, Decl(conditionalTypes1.ts, 238, 19)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 238, 13)) type T2 = T extends string ? boolean : number; ->T2 : Symbol(T2, Decl(conditionalTypes1.ts, 243, 50)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 242, 13)) +>T2 : Symbol(T2, Decl(conditionalTypes1.ts, 239, 50)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 238, 13)) var x: T1; ->x : Symbol(x, Decl(conditionalTypes1.ts, 245, 7), Decl(conditionalTypes1.ts, 246, 7)) ->T1 : Symbol(T1, Decl(conditionalTypes1.ts, 242, 19)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 241, 7), Decl(conditionalTypes1.ts, 242, 7)) +>T1 : Symbol(T1, Decl(conditionalTypes1.ts, 238, 19)) var x: T2; ->x : Symbol(x, Decl(conditionalTypes1.ts, 245, 7), Decl(conditionalTypes1.ts, 246, 7)) ->T2 : Symbol(T2, Decl(conditionalTypes1.ts, 243, 50)) +>x : Symbol(x, Decl(conditionalTypes1.ts, 241, 7), Decl(conditionalTypes1.ts, 242, 7)) +>T2 : Symbol(T2, Decl(conditionalTypes1.ts, 239, 50)) } function f32() { ->f32 : Symbol(f32, Decl(conditionalTypes1.ts, 247, 1)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 249, 13)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 249, 15)) +>f32 : Symbol(f32, Decl(conditionalTypes1.ts, 243, 1)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 245, 13)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 245, 15)) type T1 = T & U extends string ? boolean : number; ->T1 : Symbol(T1, Decl(conditionalTypes1.ts, 249, 22)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 249, 13)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 249, 15)) +>T1 : Symbol(T1, Decl(conditionalTypes1.ts, 245, 22)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 245, 13)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 245, 15)) type T2 = Foo; ->T2 : Symbol(T2, Decl(conditionalTypes1.ts, 250, 54)) ->Foo : Symbol(Foo, Decl(conditionalTypes1.ts, 231, 29)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 249, 13)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 249, 15)) +>T2 : Symbol(T2, Decl(conditionalTypes1.ts, 246, 54)) +>Foo : Symbol(Foo, Decl(conditionalTypes1.ts, 227, 29)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 245, 13)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 245, 15)) var z: T1; ->z : Symbol(z, Decl(conditionalTypes1.ts, 252, 7), Decl(conditionalTypes1.ts, 253, 7)) ->T1 : Symbol(T1, Decl(conditionalTypes1.ts, 249, 22)) +>z : Symbol(z, Decl(conditionalTypes1.ts, 248, 7), Decl(conditionalTypes1.ts, 249, 7)) +>T1 : Symbol(T1, Decl(conditionalTypes1.ts, 245, 22)) var z: T2; // Error, T2 is distributive, T1 isn't ->z : Symbol(z, Decl(conditionalTypes1.ts, 252, 7), Decl(conditionalTypes1.ts, 253, 7)) ->T2 : Symbol(T2, Decl(conditionalTypes1.ts, 250, 54)) +>z : Symbol(z, Decl(conditionalTypes1.ts, 248, 7), Decl(conditionalTypes1.ts, 249, 7)) +>T2 : Symbol(T2, Decl(conditionalTypes1.ts, 246, 54)) } function f33() { ->f33 : Symbol(f33, Decl(conditionalTypes1.ts, 254, 1)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 256, 13)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 256, 15)) +>f33 : Symbol(f33, Decl(conditionalTypes1.ts, 250, 1)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 252, 13)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 252, 15)) type T1 = Foo; ->T1 : Symbol(T1, Decl(conditionalTypes1.ts, 256, 22)) ->Foo : Symbol(Foo, Decl(conditionalTypes1.ts, 231, 29)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 256, 13)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 256, 15)) +>T1 : Symbol(T1, Decl(conditionalTypes1.ts, 252, 22)) +>Foo : Symbol(Foo, Decl(conditionalTypes1.ts, 227, 29)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 252, 13)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 252, 15)) type T2 = Bar; ->T2 : Symbol(T2, Decl(conditionalTypes1.ts, 257, 25)) ->Bar : Symbol(Bar, Decl(conditionalTypes1.ts, 235, 50)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 256, 13)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 256, 15)) +>T2 : Symbol(T2, Decl(conditionalTypes1.ts, 253, 25)) +>Bar : Symbol(Bar, Decl(conditionalTypes1.ts, 231, 50)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 252, 13)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 252, 15)) var z: T1; ->z : Symbol(z, Decl(conditionalTypes1.ts, 259, 7), Decl(conditionalTypes1.ts, 260, 7)) ->T1 : Symbol(T1, Decl(conditionalTypes1.ts, 256, 22)) +>z : Symbol(z, Decl(conditionalTypes1.ts, 255, 7), Decl(conditionalTypes1.ts, 256, 7)) +>T1 : Symbol(T1, Decl(conditionalTypes1.ts, 252, 22)) var z: T2; ->z : Symbol(z, Decl(conditionalTypes1.ts, 259, 7), Decl(conditionalTypes1.ts, 260, 7)) ->T2 : Symbol(T2, Decl(conditionalTypes1.ts, 257, 25)) +>z : Symbol(z, Decl(conditionalTypes1.ts, 255, 7), Decl(conditionalTypes1.ts, 256, 7)) +>T2 : Symbol(T2, Decl(conditionalTypes1.ts, 253, 25)) } // Repro from #21823 type T90 = T extends 0 ? 0 : () => 0; ->T90 : Symbol(T90, Decl(conditionalTypes1.ts, 261, 1)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 265, 9)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 265, 9)) +>T90 : Symbol(T90, Decl(conditionalTypes1.ts, 257, 1)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 261, 9)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 261, 9)) type T91 = T extends 0 ? 0 : () => 0; ->T91 : Symbol(T91, Decl(conditionalTypes1.ts, 265, 40)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 266, 9)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 266, 9)) +>T91 : Symbol(T91, Decl(conditionalTypes1.ts, 261, 40)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 262, 9)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 262, 9)) const f40 = (a: T90): T91 => a; ->f40 : Symbol(f40, Decl(conditionalTypes1.ts, 267, 5)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 267, 13)) ->a : Symbol(a, Decl(conditionalTypes1.ts, 267, 16)) ->T90 : Symbol(T90, Decl(conditionalTypes1.ts, 261, 1)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 267, 13)) ->T91 : Symbol(T91, Decl(conditionalTypes1.ts, 265, 40)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 267, 13)) ->a : Symbol(a, Decl(conditionalTypes1.ts, 267, 16)) +>f40 : Symbol(f40, Decl(conditionalTypes1.ts, 263, 5)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 263, 13)) +>a : Symbol(a, Decl(conditionalTypes1.ts, 263, 16)) +>T90 : Symbol(T90, Decl(conditionalTypes1.ts, 257, 1)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 263, 13)) +>T91 : Symbol(T91, Decl(conditionalTypes1.ts, 261, 40)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 263, 13)) +>a : Symbol(a, Decl(conditionalTypes1.ts, 263, 16)) const f41 = (a: T91): T90 => a; ->f41 : Symbol(f41, Decl(conditionalTypes1.ts, 268, 5)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 268, 13)) ->a : Symbol(a, Decl(conditionalTypes1.ts, 268, 16)) ->T91 : Symbol(T91, Decl(conditionalTypes1.ts, 265, 40)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 268, 13)) ->T90 : Symbol(T90, Decl(conditionalTypes1.ts, 261, 1)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 268, 13)) ->a : Symbol(a, Decl(conditionalTypes1.ts, 268, 16)) +>f41 : Symbol(f41, Decl(conditionalTypes1.ts, 264, 5)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 264, 13)) +>a : Symbol(a, Decl(conditionalTypes1.ts, 264, 16)) +>T91 : Symbol(T91, Decl(conditionalTypes1.ts, 261, 40)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 264, 13)) +>T90 : Symbol(T90, Decl(conditionalTypes1.ts, 257, 1)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 264, 13)) +>a : Symbol(a, Decl(conditionalTypes1.ts, 264, 16)) type T92 = T extends () => 0 ? () => 1 : () => 2; ->T92 : Symbol(T92, Decl(conditionalTypes1.ts, 268, 40)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 270, 9)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 270, 9)) +>T92 : Symbol(T92, Decl(conditionalTypes1.ts, 264, 40)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 266, 9)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 266, 9)) type T93 = T extends () => 0 ? () => 1 : () => 2; ->T93 : Symbol(T93, Decl(conditionalTypes1.ts, 270, 52)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 271, 9)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 271, 9)) +>T93 : Symbol(T93, Decl(conditionalTypes1.ts, 266, 52)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 267, 9)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 267, 9)) const f42 = (a: T92): T93 => a; ->f42 : Symbol(f42, Decl(conditionalTypes1.ts, 272, 5)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 272, 13)) ->a : Symbol(a, Decl(conditionalTypes1.ts, 272, 16)) ->T92 : Symbol(T92, Decl(conditionalTypes1.ts, 268, 40)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 272, 13)) ->T93 : Symbol(T93, Decl(conditionalTypes1.ts, 270, 52)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 272, 13)) ->a : Symbol(a, Decl(conditionalTypes1.ts, 272, 16)) +>f42 : Symbol(f42, Decl(conditionalTypes1.ts, 268, 5)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 268, 13)) +>a : Symbol(a, Decl(conditionalTypes1.ts, 268, 16)) +>T92 : Symbol(T92, Decl(conditionalTypes1.ts, 264, 40)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 268, 13)) +>T93 : Symbol(T93, Decl(conditionalTypes1.ts, 266, 52)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 268, 13)) +>a : Symbol(a, Decl(conditionalTypes1.ts, 268, 16)) const f43 = (a: T93): T92 => a; ->f43 : Symbol(f43, Decl(conditionalTypes1.ts, 273, 5)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 273, 13)) ->a : Symbol(a, Decl(conditionalTypes1.ts, 273, 16)) ->T93 : Symbol(T93, Decl(conditionalTypes1.ts, 270, 52)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 273, 13)) ->T92 : Symbol(T92, Decl(conditionalTypes1.ts, 268, 40)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 273, 13)) ->a : Symbol(a, Decl(conditionalTypes1.ts, 273, 16)) +>f43 : Symbol(f43, Decl(conditionalTypes1.ts, 269, 5)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 269, 13)) +>a : Symbol(a, Decl(conditionalTypes1.ts, 269, 16)) +>T93 : Symbol(T93, Decl(conditionalTypes1.ts, 266, 52)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 269, 13)) +>T92 : Symbol(T92, Decl(conditionalTypes1.ts, 264, 40)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 269, 13)) +>a : Symbol(a, Decl(conditionalTypes1.ts, 269, 16)) type T94 = T extends string ? true : 42; ->T94 : Symbol(T94, Decl(conditionalTypes1.ts, 273, 40)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 275, 9)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 275, 9)) +>T94 : Symbol(T94, Decl(conditionalTypes1.ts, 269, 40)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 271, 9)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 271, 9)) type T95 = T extends string ? boolean : number; ->T95 : Symbol(T95, Decl(conditionalTypes1.ts, 275, 43)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 276, 9)) ->T : Symbol(T, Decl(conditionalTypes1.ts, 276, 9)) +>T95 : Symbol(T95, Decl(conditionalTypes1.ts, 271, 43)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 272, 9)) +>T : Symbol(T, Decl(conditionalTypes1.ts, 272, 9)) const f44 = (value: T94): T95 => value; ->f44 : Symbol(f44, Decl(conditionalTypes1.ts, 277, 5)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 277, 13)) ->value : Symbol(value, Decl(conditionalTypes1.ts, 277, 16)) ->T94 : Symbol(T94, Decl(conditionalTypes1.ts, 273, 40)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 277, 13)) ->T95 : Symbol(T95, Decl(conditionalTypes1.ts, 275, 43)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 277, 13)) ->value : Symbol(value, Decl(conditionalTypes1.ts, 277, 16)) +>f44 : Symbol(f44, Decl(conditionalTypes1.ts, 273, 5)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 273, 13)) +>value : Symbol(value, Decl(conditionalTypes1.ts, 273, 16)) +>T94 : Symbol(T94, Decl(conditionalTypes1.ts, 269, 40)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 273, 13)) +>T95 : Symbol(T95, Decl(conditionalTypes1.ts, 271, 43)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 273, 13)) +>value : Symbol(value, Decl(conditionalTypes1.ts, 273, 16)) const f45 = (value: T95): T94 => value; // Error ->f45 : Symbol(f45, Decl(conditionalTypes1.ts, 278, 5)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 278, 13)) ->value : Symbol(value, Decl(conditionalTypes1.ts, 278, 16)) ->T95 : Symbol(T95, Decl(conditionalTypes1.ts, 275, 43)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 278, 13)) ->T94 : Symbol(T94, Decl(conditionalTypes1.ts, 273, 40)) ->U : Symbol(U, Decl(conditionalTypes1.ts, 278, 13)) ->value : Symbol(value, Decl(conditionalTypes1.ts, 278, 16)) +>f45 : Symbol(f45, Decl(conditionalTypes1.ts, 274, 5)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 274, 13)) +>value : Symbol(value, Decl(conditionalTypes1.ts, 274, 16)) +>T95 : Symbol(T95, Decl(conditionalTypes1.ts, 271, 43)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 274, 13)) +>T94 : Symbol(T94, Decl(conditionalTypes1.ts, 269, 40)) +>U : Symbol(U, Decl(conditionalTypes1.ts, 274, 13)) +>value : Symbol(value, Decl(conditionalTypes1.ts, 274, 16)) diff --git a/tests/baselines/reference/conditionalTypes1.types b/tests/baselines/reference/conditionalTypes1.types index 42cfeae5da0..b915b8438d0 100644 --- a/tests/baselines/reference/conditionalTypes1.types +++ b/tests/baselines/reference/conditionalTypes1.types @@ -1,91 +1,68 @@ === tests/cases/conformance/types/conditional/conditionalTypes1.ts === -type Diff = T extends U ? never : T; ->Diff : Diff ->T : T ->U : U ->T : T ->U : U ->T : T - -type Filter = T extends U ? T : never; ->Filter : Filter ->T : T ->U : U ->T : T ->U : U ->T : T - -type NonNullable = Diff; ->NonNullable : Diff ->T : T ->Diff : Diff ->T : T ->null : null - -type T00 = Diff<"a" | "b" | "c" | "d", "a" | "c" | "f">; // "b" | "d" +type T00 = Exclude<"a" | "b" | "c" | "d", "a" | "c" | "f">; // "b" | "d" >T00 : "b" | "d" ->Diff : Diff +>Exclude : Exclude -type T01 = Filter<"a" | "b" | "c" | "d", "a" | "c" | "f">; // "a" | "c" +type T01 = Extract<"a" | "b" | "c" | "d", "a" | "c" | "f">; // "a" | "c" >T01 : "a" | "c" ->Filter : Filter +>Extract : Extract -type T02 = Diff void), Function>; // string | number +type T02 = Exclude void), Function>; // string | number >T02 : string | number ->Diff : Diff +>Exclude : Exclude >Function : Function -type T03 = Filter void), Function>; // () => void +type T03 = Extract void), Function>; // () => void >T03 : () => void ->Filter : Filter +>Extract : Extract >Function : Function type T04 = NonNullable; // string | number >T04 : string | number ->NonNullable : Diff +>NonNullable : NonNullable type T05 = NonNullable<(() => string) | string[] | null | undefined>; // (() => string) | string[] >T05 : (() => string) | string[] ->NonNullable : Diff +>NonNullable : NonNullable >null : null function f1(x: T, y: NonNullable) { ->f1 : (x: T, y: Diff) => void +>f1 : (x: T, y: NonNullable) => void >T : T >x : T >T : T ->y : Diff ->NonNullable : Diff +>y : NonNullable +>NonNullable : NonNullable >T : T x = y; ->x = y : Diff +>x = y : NonNullable >x : T ->y : Diff +>y : NonNullable y = x; // Error >y = x : T ->y : Diff +>y : NonNullable >x : T } function f2(x: T, y: NonNullable) { ->f2 : (x: T, y: Diff) => void +>f2 : (x: T, y: NonNullable) => void >T : T >x : T >T : T ->y : Diff ->NonNullable : Diff +>y : NonNullable +>NonNullable : NonNullable >T : T x = y; ->x = y : Diff +>x = y : NonNullable >x : T ->y : Diff +>y : NonNullable y = x; // Error >y = x : T ->y : Diff +>y : NonNullable >x : T let s1: string = x; // Error @@ -94,51 +71,51 @@ function f2(x: T, y: NonNullable) { let s2: string = y; >s2 : string ->y : Diff +>y : NonNullable } function f3(x: Partial[keyof T], y: NonNullable[keyof T]>) { ->f3 : (x: Partial[keyof T], y: Diff[keyof T], null | undefined>) => void +>f3 : (x: Partial[keyof T], y: NonNullable[keyof T]>) => void >T : T >x : Partial[keyof T] >Partial : Partial >T : T >T : T ->y : Diff[keyof T], null | undefined> ->NonNullable : Diff +>y : NonNullable[keyof T]> +>NonNullable : NonNullable >Partial : Partial >T : T >T : T x = y; ->x = y : Diff[keyof T], null | undefined> +>x = y : NonNullable[keyof T]> >x : Partial[keyof T] ->y : Diff[keyof T], null | undefined> +>y : NonNullable[keyof T]> y = x; // Error >y = x : Partial[keyof T] ->y : Diff[keyof T], null | undefined> +>y : NonNullable[keyof T]> >x : Partial[keyof T] } function f4(x: T["x"], y: NonNullable) { ->f4 : (x: T["x"], y: Diff) => void +>f4 : (x: T["x"], y: NonNullable) => void >T : T >x : string | undefined >x : T["x"] >T : T ->y : Diff ->NonNullable : Diff +>y : NonNullable +>NonNullable : NonNullable >T : T x = y; ->x = y : Diff +>x = y : NonNullable >x : T["x"] ->y : Diff +>y : NonNullable y = x; // Error >y = x : T["x"] ->y : Diff +>y : NonNullable >x : T["x"] let s1: string = x; // Error @@ -147,7 +124,7 @@ function f4(x: T["x"], y: NonNullables2 : string ->y : Diff +>y : NonNullable } type Options = { k: "a", a: number } | { k: "b", b: string } | { k: "c", c: boolean }; @@ -159,52 +136,52 @@ type Options = { k: "a", a: number } | { k: "b", b: string } | { k: "c", c: bool >k : "c" >c : boolean -type T10 = Diff; // { k: "c", c: boolean } +type T10 = Exclude; // { k: "c", c: boolean } >T10 : { k: "c"; c: boolean; } ->Diff : Diff +>Exclude : Exclude >Options : Options >k : "a" | "b" -type T11 = Filter; // { k: "a", a: number } | { k: "b", b: string } +type T11 = Extract; // { k: "a", a: number } | { k: "b", b: string } >T11 : { k: "a"; a: number; } | { k: "b"; b: string; } ->Filter : Filter +>Extract : Extract >Options : Options >k : "a" | "b" -type T12 = Diff; // { k: "c", c: boolean } +type T12 = Exclude; // { k: "c", c: boolean } >T12 : { k: "c"; c: boolean; } ->Diff : Diff +>Exclude : Exclude >Options : Options >k : "a" >k : "b" -type T13 = Filter; // { k: "a", a: number } | { k: "b", b: string } +type T13 = Extract; // { k: "a", a: number } | { k: "b", b: string } >T13 : { k: "a"; a: number; } | { k: "b"; b: string; } ->Filter : Filter +>Extract : Extract >Options : Options >k : "a" >k : "b" -type T14 = Diff; // Options +type T14 = Exclude; // Options >T14 : Options ->Diff : Diff +>Exclude : Exclude >Options : Options >q : "a" -type T15 = Filter; // never +type T15 = Extract; // never >T15 : never ->Filter : Filter +>Extract : Extract >Options : Options >q : "a" -declare function f5(p: K): Filter; ->f5 : (p: K) => Filter +declare function f5(p: K): Extract; +>f5 : (p: K) => Extract >T : T >Options : Options >K : K >p : K >K : K ->Filter : Filter +>Extract : Extract >T : T >k : K >K : K @@ -212,31 +189,31 @@ declare function f5(p: K): Filterx0 : { k: "a"; a: number; } >f5("a") : { k: "a"; a: number; } ->f5 : (p: K) => Filter +>f5 : (p: K) => Extract >"a" : "a" -type OptionsOfKind = Filter; ->OptionsOfKind : Filter<{ k: "a"; a: number; }, { k: K; }> | Filter<{ k: "b"; b: string; }, { k: K; }> | Filter<{ k: "c"; c: boolean; }, { k: K; }> +type OptionsOfKind = Extract; +>OptionsOfKind : Extract<{ k: "a"; a: number; }, { k: K; }> | Extract<{ k: "b"; b: string; }, { k: K; }> | Extract<{ k: "c"; c: boolean; }, { k: K; }> >K : K >Options : Options ->Filter : Filter +>Extract : Extract >Options : Options >k : K >K : K type T16 = OptionsOfKind<"a" | "b">; // { k: "a", a: number } | { k: "b", b: string } >T16 : { k: "a"; a: number; } | { k: "b"; b: string; } ->OptionsOfKind : Filter<{ k: "a"; a: number; }, { k: K; }> | Filter<{ k: "b"; b: string; }, { k: K; }> | Filter<{ k: "c"; c: boolean; }, { k: K; }> +>OptionsOfKind : Extract<{ k: "a"; a: number; }, { k: K; }> | Extract<{ k: "b"; b: string; }, { k: K; }> | Extract<{ k: "c"; c: boolean; }, { k: K; }> -type Select = Filter; ->Select : Filter +type Select = Extract; +>Select : Extract >T : T >K : K >T : T >V : V >T : T >K : K ->Filter : Filter +>Extract : Extract >T : T >P : P >K : K @@ -244,7 +221,7 @@ type Select = Filter; type T17 = Select; // // { k: "a", a: number } | { k: "b", b: string } >T17 : { k: "a"; a: number; } | { k: "b"; b: string; } ->Select : Filter +>Select : Extract >Options : Options type TypeName = diff --git a/tests/baselines/reference/inferTypes1.errors.txt b/tests/baselines/reference/inferTypes1.errors.txt index 80edc31d37c..acc4b9029b1 100644 --- a/tests/baselines/reference/inferTypes1.errors.txt +++ b/tests/baselines/reference/inferTypes1.errors.txt @@ -1,21 +1,26 @@ -tests/cases/conformance/types/conditional/inferTypes1.ts(34,23): error TS2344: Type 'string' does not satisfy the constraint 'Function'. -tests/cases/conformance/types/conditional/inferTypes1.ts(43,25): error TS2344: Type '(x: string, y: string) => number' does not satisfy the constraint '(x: any) => any'. -tests/cases/conformance/types/conditional/inferTypes1.ts(44,25): error TS2344: Type 'Function' does not satisfy the constraint '(x: any) => any'. +tests/cases/conformance/types/conditional/inferTypes1.ts(31,23): error TS2344: Type 'string' does not satisfy the constraint '(...args: any[]) => any'. +tests/cases/conformance/types/conditional/inferTypes1.ts(32,23): error TS2344: Type 'Function' does not satisfy the constraint '(...args: any[]) => any'. + Type 'Function' provides no match for the signature '(...args: any[]): any'. +tests/cases/conformance/types/conditional/inferTypes1.ts(37,25): error TS2344: Type 'string' does not satisfy the constraint 'new (...args: any[]) => any'. +tests/cases/conformance/types/conditional/inferTypes1.ts(38,25): error TS2344: Type 'Function' does not satisfy the constraint 'new (...args: any[]) => any'. + Type 'Function' provides no match for the signature 'new (...args: any[]): any'. +tests/cases/conformance/types/conditional/inferTypes1.ts(46,25): error TS2344: Type '(x: string, y: string) => number' does not satisfy the constraint '(x: any) => any'. +tests/cases/conformance/types/conditional/inferTypes1.ts(47,25): error TS2344: Type 'Function' does not satisfy the constraint '(x: any) => any'. Type 'Function' provides no match for the signature '(x: any): any'. -tests/cases/conformance/types/conditional/inferTypes1.ts(70,12): error TS1338: 'infer' declarations are only permitted in the 'extends' clause of a conditional type. -tests/cases/conformance/types/conditional/inferTypes1.ts(71,15): error TS1338: 'infer' declarations are only permitted in the 'extends' clause of a conditional type. -tests/cases/conformance/types/conditional/inferTypes1.ts(71,41): error TS1338: 'infer' declarations are only permitted in the 'extends' clause of a conditional type. -tests/cases/conformance/types/conditional/inferTypes1.ts(71,51): error TS1338: 'infer' declarations are only permitted in the 'extends' clause of a conditional type. -tests/cases/conformance/types/conditional/inferTypes1.ts(72,15): error TS2304: Cannot find name 'U'. -tests/cases/conformance/types/conditional/inferTypes1.ts(72,15): error TS4081: Exported type alias 'T62' has or is using private name 'U'. -tests/cases/conformance/types/conditional/inferTypes1.ts(72,43): error TS2304: Cannot find name 'U'. -tests/cases/conformance/types/conditional/inferTypes1.ts(72,43): error TS4081: Exported type alias 'T62' has or is using private name 'U'. -tests/cases/conformance/types/conditional/inferTypes1.ts(78,44): error TS2344: Type 'U' does not satisfy the constraint 'string'. +tests/cases/conformance/types/conditional/inferTypes1.ts(73,12): error TS1338: 'infer' declarations are only permitted in the 'extends' clause of a conditional type. +tests/cases/conformance/types/conditional/inferTypes1.ts(74,15): error TS1338: 'infer' declarations are only permitted in the 'extends' clause of a conditional type. +tests/cases/conformance/types/conditional/inferTypes1.ts(74,41): error TS1338: 'infer' declarations are only permitted in the 'extends' clause of a conditional type. +tests/cases/conformance/types/conditional/inferTypes1.ts(74,51): error TS1338: 'infer' declarations are only permitted in the 'extends' clause of a conditional type. +tests/cases/conformance/types/conditional/inferTypes1.ts(75,15): error TS2304: Cannot find name 'U'. +tests/cases/conformance/types/conditional/inferTypes1.ts(75,15): error TS4081: Exported type alias 'T62' has or is using private name 'U'. +tests/cases/conformance/types/conditional/inferTypes1.ts(75,43): error TS2304: Cannot find name 'U'. +tests/cases/conformance/types/conditional/inferTypes1.ts(75,43): error TS4081: Exported type alias 'T62' has or is using private name 'U'. +tests/cases/conformance/types/conditional/inferTypes1.ts(81,44): error TS2344: Type 'U' does not satisfy the constraint 'string'. Type 'number' is not assignable to type 'string'. -tests/cases/conformance/types/conditional/inferTypes1.ts(131,40): error TS2322: Type 'T' is not assignable to type 'string'. +tests/cases/conformance/types/conditional/inferTypes1.ts(134,40): error TS2322: Type 'T' is not assignable to type 'string'. -==== tests/cases/conformance/types/conditional/inferTypes1.ts (13 errors) ==== +==== tests/cases/conformance/types/conditional/inferTypes1.ts (16 errors) ==== type Unpacked = T extends (infer U)[] ? U : T extends (...args: any[]) => infer U ? U : @@ -30,8 +35,6 @@ tests/cases/conformance/types/conditional/inferTypes1.ts(131,40): error TS2322: type T05 = Unpacked; // any type T06 = Unpacked; // never - type ReturnType = T extends ((...args: any[]) => infer R) | (new (...args: any[]) => infer R) ? R : any; - function f1(s: string) { return { a: 1, b: s }; } @@ -46,13 +49,26 @@ tests/cases/conformance/types/conditional/inferTypes1.ts(131,40): error TS2322: type T12 = ReturnType<(() => T)>; // {} type T13 = ReturnType<(() => T)>; // number[] type T14 = ReturnType; // { a: number, b: string } - type T15 = ReturnType; // C - type T16 = ReturnType; // any - type T17 = ReturnType; // any - type T18 = ReturnType; // Error + type T15 = ReturnType; // any + type T16 = ReturnType; // any + type T17 = ReturnType; // Error ~~~~~~ -!!! error TS2344: Type 'string' does not satisfy the constraint 'Function'. - type T19 = ReturnType; // any +!!! error TS2344: Type 'string' does not satisfy the constraint '(...args: any[]) => any'. + type T18 = ReturnType; // Error + ~~~~~~~~ +!!! error TS2344: Type 'Function' does not satisfy the constraint '(...args: any[]) => any'. +!!! error TS2344: Type 'Function' provides no match for the signature '(...args: any[]): any'. + + type U10 = InstanceType; // C + type U11 = InstanceType; // any + type U12 = InstanceType; // any + type U13 = InstanceType; // Error + ~~~~~~ +!!! error TS2344: Type 'string' does not satisfy the constraint 'new (...args: any[]) => any'. + type U14 = InstanceType; // Error + ~~~~~~~~ +!!! error TS2344: Type 'Function' does not satisfy the constraint 'new (...args: any[]) => any'. +!!! error TS2344: Type 'Function' provides no match for the signature 'new (...args: any[]): any'. type ArgumentType any> = T extends (a: infer A) => any ? A : any; diff --git a/tests/baselines/reference/inferTypes1.js b/tests/baselines/reference/inferTypes1.js index 21cada9c71b..146acdc1ce7 100644 --- a/tests/baselines/reference/inferTypes1.js +++ b/tests/baselines/reference/inferTypes1.js @@ -13,8 +13,6 @@ type T04 = Unpacked[]>>; // string type T05 = Unpacked; // any type T06 = Unpacked; // never -type ReturnType = T extends ((...args: any[]) => infer R) | (new (...args: any[]) => infer R) ? R : any; - function f1(s: string) { return { a: 1, b: s }; } @@ -29,11 +27,16 @@ type T11 = ReturnType<(s: string) => void>; // void type T12 = ReturnType<(() => T)>; // {} type T13 = ReturnType<(() => T)>; // number[] type T14 = ReturnType; // { a: number, b: string } -type T15 = ReturnType; // C -type T16 = ReturnType; // any -type T17 = ReturnType; // any -type T18 = ReturnType; // Error -type T19 = ReturnType; // any +type T15 = ReturnType; // any +type T16 = ReturnType; // any +type T17 = ReturnType; // Error +type T18 = ReturnType; // Error + +type U10 = InstanceType; // C +type U11 = InstanceType; // any +type U12 = InstanceType; // any +type U13 = InstanceType; // Error +type U14 = InstanceType; // Error type ArgumentType any> = T extends (a: infer A) => any ? A : any; diff --git a/tests/baselines/reference/inferTypes1.symbols b/tests/baselines/reference/inferTypes1.symbols index 6e8a9670f29..138f60aaf49 100644 --- a/tests/baselines/reference/inferTypes1.symbols +++ b/tests/baselines/reference/inferTypes1.symbols @@ -54,518 +54,524 @@ type T06 = Unpacked; // never >T06 : Symbol(T06, Decl(inferTypes1.ts, 11, 25)) >Unpacked : Symbol(Unpacked, Decl(inferTypes1.ts, 0, 0)) -type ReturnType = T extends ((...args: any[]) => infer R) | (new (...args: any[]) => infer R) ? R : any; ->ReturnType : Symbol(ReturnType, Decl(inferTypes1.ts, 12, 27)) ->T : Symbol(T, Decl(inferTypes1.ts, 14, 16)) ->Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->T : Symbol(T, Decl(inferTypes1.ts, 14, 16)) ->args : Symbol(args, Decl(inferTypes1.ts, 14, 50)) ->R : Symbol(R, Decl(inferTypes1.ts, 14, 74), Decl(inferTypes1.ts, 14, 110)) ->args : Symbol(args, Decl(inferTypes1.ts, 14, 86)) ->R : Symbol(R, Decl(inferTypes1.ts, 14, 74), Decl(inferTypes1.ts, 14, 110)) ->R : Symbol(R, Decl(inferTypes1.ts, 14, 74), Decl(inferTypes1.ts, 14, 110)) - function f1(s: string) { ->f1 : Symbol(f1, Decl(inferTypes1.ts, 14, 124)) ->s : Symbol(s, Decl(inferTypes1.ts, 16, 12)) +>f1 : Symbol(f1, Decl(inferTypes1.ts, 12, 27)) +>s : Symbol(s, Decl(inferTypes1.ts, 14, 12)) return { a: 1, b: s }; ->a : Symbol(a, Decl(inferTypes1.ts, 17, 12)) ->b : Symbol(b, Decl(inferTypes1.ts, 17, 18)) ->s : Symbol(s, Decl(inferTypes1.ts, 16, 12)) +>a : Symbol(a, Decl(inferTypes1.ts, 15, 12)) +>b : Symbol(b, Decl(inferTypes1.ts, 15, 18)) +>s : Symbol(s, Decl(inferTypes1.ts, 14, 12)) } class C { ->C : Symbol(C, Decl(inferTypes1.ts, 18, 1)) +>C : Symbol(C, Decl(inferTypes1.ts, 16, 1)) x = 0; ->x : Symbol(C.x, Decl(inferTypes1.ts, 20, 9)) +>x : Symbol(C.x, Decl(inferTypes1.ts, 18, 9)) y = 0; ->y : Symbol(C.y, Decl(inferTypes1.ts, 21, 10)) +>y : Symbol(C.y, Decl(inferTypes1.ts, 19, 10)) } type T10 = ReturnType<() => string>; // string ->T10 : Symbol(T10, Decl(inferTypes1.ts, 23, 1)) ->ReturnType : Symbol(ReturnType, Decl(inferTypes1.ts, 12, 27)) +>T10 : Symbol(T10, Decl(inferTypes1.ts, 21, 1)) +>ReturnType : Symbol(ReturnType, Decl(lib.d.ts, --, --)) type T11 = ReturnType<(s: string) => void>; // void ->T11 : Symbol(T11, Decl(inferTypes1.ts, 25, 36)) ->ReturnType : Symbol(ReturnType, Decl(inferTypes1.ts, 12, 27)) ->s : Symbol(s, Decl(inferTypes1.ts, 26, 23)) +>T11 : Symbol(T11, Decl(inferTypes1.ts, 23, 36)) +>ReturnType : Symbol(ReturnType, Decl(lib.d.ts, --, --)) +>s : Symbol(s, Decl(inferTypes1.ts, 24, 23)) type T12 = ReturnType<(() => T)>; // {} ->T12 : Symbol(T12, Decl(inferTypes1.ts, 26, 43)) ->ReturnType : Symbol(ReturnType, Decl(inferTypes1.ts, 12, 27)) ->T : Symbol(T, Decl(inferTypes1.ts, 27, 24)) ->T : Symbol(T, Decl(inferTypes1.ts, 27, 24)) +>T12 : Symbol(T12, Decl(inferTypes1.ts, 24, 43)) +>ReturnType : Symbol(ReturnType, Decl(lib.d.ts, --, --)) +>T : Symbol(T, Decl(inferTypes1.ts, 25, 24)) +>T : Symbol(T, Decl(inferTypes1.ts, 25, 24)) type T13 = ReturnType<(() => T)>; // number[] ->T13 : Symbol(T13, Decl(inferTypes1.ts, 27, 36)) ->ReturnType : Symbol(ReturnType, Decl(inferTypes1.ts, 12, 27)) ->T : Symbol(T, Decl(inferTypes1.ts, 28, 24)) ->U : Symbol(U, Decl(inferTypes1.ts, 28, 36)) ->U : Symbol(U, Decl(inferTypes1.ts, 28, 36)) ->T : Symbol(T, Decl(inferTypes1.ts, 28, 24)) +>T13 : Symbol(T13, Decl(inferTypes1.ts, 25, 36)) +>ReturnType : Symbol(ReturnType, Decl(lib.d.ts, --, --)) +>T : Symbol(T, Decl(inferTypes1.ts, 26, 24)) +>U : Symbol(U, Decl(inferTypes1.ts, 26, 36)) +>U : Symbol(U, Decl(inferTypes1.ts, 26, 36)) +>T : Symbol(T, Decl(inferTypes1.ts, 26, 24)) type T14 = ReturnType; // { a: number, b: string } ->T14 : Symbol(T14, Decl(inferTypes1.ts, 28, 66)) ->ReturnType : Symbol(ReturnType, Decl(inferTypes1.ts, 12, 27)) ->f1 : Symbol(f1, Decl(inferTypes1.ts, 14, 124)) +>T14 : Symbol(T14, Decl(inferTypes1.ts, 26, 66)) +>ReturnType : Symbol(ReturnType, Decl(lib.d.ts, --, --)) +>f1 : Symbol(f1, Decl(inferTypes1.ts, 12, 27)) -type T15 = ReturnType; // C ->T15 : Symbol(T15, Decl(inferTypes1.ts, 29, 33)) ->ReturnType : Symbol(ReturnType, Decl(inferTypes1.ts, 12, 27)) ->C : Symbol(C, Decl(inferTypes1.ts, 18, 1)) +type T15 = ReturnType; // any +>T15 : Symbol(T15, Decl(inferTypes1.ts, 27, 33)) +>ReturnType : Symbol(ReturnType, Decl(lib.d.ts, --, --)) -type T16 = ReturnType; // any ->T16 : Symbol(T16, Decl(inferTypes1.ts, 30, 32)) ->ReturnType : Symbol(ReturnType, Decl(inferTypes1.ts, 12, 27)) +type T16 = ReturnType; // any +>T16 : Symbol(T16, Decl(inferTypes1.ts, 28, 27)) +>ReturnType : Symbol(ReturnType, Decl(lib.d.ts, --, --)) -type T17 = ReturnType; // any ->T17 : Symbol(T17, Decl(inferTypes1.ts, 31, 27)) ->ReturnType : Symbol(ReturnType, Decl(inferTypes1.ts, 12, 27)) +type T17 = ReturnType; // Error +>T17 : Symbol(T17, Decl(inferTypes1.ts, 29, 29)) +>ReturnType : Symbol(ReturnType, Decl(lib.d.ts, --, --)) -type T18 = ReturnType; // Error ->T18 : Symbol(T18, Decl(inferTypes1.ts, 32, 29)) ->ReturnType : Symbol(ReturnType, Decl(inferTypes1.ts, 12, 27)) +type T18 = ReturnType; // Error +>T18 : Symbol(T18, Decl(inferTypes1.ts, 30, 30)) +>ReturnType : Symbol(ReturnType, Decl(lib.d.ts, --, --)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) -type T19 = ReturnType; // any ->T19 : Symbol(T19, Decl(inferTypes1.ts, 33, 30)) ->ReturnType : Symbol(ReturnType, Decl(inferTypes1.ts, 12, 27)) +type U10 = InstanceType; // C +>U10 : Symbol(U10, Decl(inferTypes1.ts, 31, 32)) +>InstanceType : Symbol(InstanceType, Decl(lib.d.ts, --, --)) +>C : Symbol(C, Decl(inferTypes1.ts, 16, 1)) + +type U11 = InstanceType; // any +>U11 : Symbol(U11, Decl(inferTypes1.ts, 33, 34)) +>InstanceType : Symbol(InstanceType, Decl(lib.d.ts, --, --)) + +type U12 = InstanceType; // any +>U12 : Symbol(U12, Decl(inferTypes1.ts, 34, 29)) +>InstanceType : Symbol(InstanceType, Decl(lib.d.ts, --, --)) + +type U13 = InstanceType; // Error +>U13 : Symbol(U13, Decl(inferTypes1.ts, 35, 31)) +>InstanceType : Symbol(InstanceType, Decl(lib.d.ts, --, --)) + +type U14 = InstanceType; // Error +>U14 : Symbol(U14, Decl(inferTypes1.ts, 36, 32)) +>InstanceType : Symbol(InstanceType, Decl(lib.d.ts, --, --)) >Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) type ArgumentType any> = T extends (a: infer A) => any ? A : any; ->ArgumentType : Symbol(ArgumentType, Decl(inferTypes1.ts, 34, 32)) ->T : Symbol(T, Decl(inferTypes1.ts, 36, 18)) ->x : Symbol(x, Decl(inferTypes1.ts, 36, 29)) ->T : Symbol(T, Decl(inferTypes1.ts, 36, 18)) ->a : Symbol(a, Decl(inferTypes1.ts, 36, 58)) ->A : Symbol(A, Decl(inferTypes1.ts, 36, 66)) ->A : Symbol(A, Decl(inferTypes1.ts, 36, 66)) +>ArgumentType : Symbol(ArgumentType, Decl(inferTypes1.ts, 37, 34)) +>T : Symbol(T, Decl(inferTypes1.ts, 39, 18)) +>x : Symbol(x, Decl(inferTypes1.ts, 39, 29)) +>T : Symbol(T, Decl(inferTypes1.ts, 39, 18)) +>a : Symbol(a, Decl(inferTypes1.ts, 39, 58)) +>A : Symbol(A, Decl(inferTypes1.ts, 39, 66)) +>A : Symbol(A, Decl(inferTypes1.ts, 39, 66)) type T20 = ArgumentType<() => void>; // never ->T20 : Symbol(T20, Decl(inferTypes1.ts, 36, 87)) ->ArgumentType : Symbol(ArgumentType, Decl(inferTypes1.ts, 34, 32)) +>T20 : Symbol(T20, Decl(inferTypes1.ts, 39, 87)) +>ArgumentType : Symbol(ArgumentType, Decl(inferTypes1.ts, 37, 34)) type T21 = ArgumentType<(x: string) => number>; // string ->T21 : Symbol(T21, Decl(inferTypes1.ts, 38, 36)) ->ArgumentType : Symbol(ArgumentType, Decl(inferTypes1.ts, 34, 32)) ->x : Symbol(x, Decl(inferTypes1.ts, 39, 25)) +>T21 : Symbol(T21, Decl(inferTypes1.ts, 41, 36)) +>ArgumentType : Symbol(ArgumentType, Decl(inferTypes1.ts, 37, 34)) +>x : Symbol(x, Decl(inferTypes1.ts, 42, 25)) type T22 = ArgumentType<(x?: string) => number>; // string | undefined ->T22 : Symbol(T22, Decl(inferTypes1.ts, 39, 47)) ->ArgumentType : Symbol(ArgumentType, Decl(inferTypes1.ts, 34, 32)) ->x : Symbol(x, Decl(inferTypes1.ts, 40, 25)) +>T22 : Symbol(T22, Decl(inferTypes1.ts, 42, 47)) +>ArgumentType : Symbol(ArgumentType, Decl(inferTypes1.ts, 37, 34)) +>x : Symbol(x, Decl(inferTypes1.ts, 43, 25)) type T23 = ArgumentType<(...args: string[]) => number>; // string ->T23 : Symbol(T23, Decl(inferTypes1.ts, 40, 48)) ->ArgumentType : Symbol(ArgumentType, Decl(inferTypes1.ts, 34, 32)) ->args : Symbol(args, Decl(inferTypes1.ts, 41, 25)) +>T23 : Symbol(T23, Decl(inferTypes1.ts, 43, 48)) +>ArgumentType : Symbol(ArgumentType, Decl(inferTypes1.ts, 37, 34)) +>args : Symbol(args, Decl(inferTypes1.ts, 44, 25)) type T24 = ArgumentType<(x: string, y: string) => number>; // Error ->T24 : Symbol(T24, Decl(inferTypes1.ts, 41, 55)) ->ArgumentType : Symbol(ArgumentType, Decl(inferTypes1.ts, 34, 32)) ->x : Symbol(x, Decl(inferTypes1.ts, 42, 25)) ->y : Symbol(y, Decl(inferTypes1.ts, 42, 35)) +>T24 : Symbol(T24, Decl(inferTypes1.ts, 44, 55)) +>ArgumentType : Symbol(ArgumentType, Decl(inferTypes1.ts, 37, 34)) +>x : Symbol(x, Decl(inferTypes1.ts, 45, 25)) +>y : Symbol(y, Decl(inferTypes1.ts, 45, 35)) type T25 = ArgumentType; // Error ->T25 : Symbol(T25, Decl(inferTypes1.ts, 42, 58)) ->ArgumentType : Symbol(ArgumentType, Decl(inferTypes1.ts, 34, 32)) +>T25 : Symbol(T25, Decl(inferTypes1.ts, 45, 58)) +>ArgumentType : Symbol(ArgumentType, Decl(inferTypes1.ts, 37, 34)) >Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) type T26 = ArgumentType; // any ->T26 : Symbol(T26, Decl(inferTypes1.ts, 43, 34)) ->ArgumentType : Symbol(ArgumentType, Decl(inferTypes1.ts, 34, 32)) +>T26 : Symbol(T26, Decl(inferTypes1.ts, 46, 34)) +>ArgumentType : Symbol(ArgumentType, Decl(inferTypes1.ts, 37, 34)) type T27 = ArgumentType; // any ->T27 : Symbol(T27, Decl(inferTypes1.ts, 44, 29)) ->ArgumentType : Symbol(ArgumentType, Decl(inferTypes1.ts, 34, 32)) +>T27 : Symbol(T27, Decl(inferTypes1.ts, 47, 29)) +>ArgumentType : Symbol(ArgumentType, Decl(inferTypes1.ts, 37, 34)) type X1 = T extends { x: infer X, y: infer Y } ? [X, Y] : any; ->X1 : Symbol(X1, Decl(inferTypes1.ts, 45, 31)) ->T : Symbol(T, Decl(inferTypes1.ts, 47, 8)) ->x : Symbol(x, Decl(inferTypes1.ts, 47, 19)) ->y : Symbol(y, Decl(inferTypes1.ts, 47, 27)) ->T : Symbol(T, Decl(inferTypes1.ts, 47, 8)) ->x : Symbol(x, Decl(inferTypes1.ts, 47, 51)) ->X : Symbol(X, Decl(inferTypes1.ts, 47, 60)) ->y : Symbol(y, Decl(inferTypes1.ts, 47, 63)) ->Y : Symbol(Y, Decl(inferTypes1.ts, 47, 72)) ->X : Symbol(X, Decl(inferTypes1.ts, 47, 60)) ->Y : Symbol(Y, Decl(inferTypes1.ts, 47, 72)) +>X1 : Symbol(X1, Decl(inferTypes1.ts, 48, 31)) +>T : Symbol(T, Decl(inferTypes1.ts, 50, 8)) +>x : Symbol(x, Decl(inferTypes1.ts, 50, 19)) +>y : Symbol(y, Decl(inferTypes1.ts, 50, 27)) +>T : Symbol(T, Decl(inferTypes1.ts, 50, 8)) +>x : Symbol(x, Decl(inferTypes1.ts, 50, 51)) +>X : Symbol(X, Decl(inferTypes1.ts, 50, 60)) +>y : Symbol(y, Decl(inferTypes1.ts, 50, 63)) +>Y : Symbol(Y, Decl(inferTypes1.ts, 50, 72)) +>X : Symbol(X, Decl(inferTypes1.ts, 50, 60)) +>Y : Symbol(Y, Decl(inferTypes1.ts, 50, 72)) type T30 = X1<{ x: any, y: any }>; // [any, any] ->T30 : Symbol(T30, Decl(inferTypes1.ts, 47, 92)) ->X1 : Symbol(X1, Decl(inferTypes1.ts, 45, 31)) ->x : Symbol(x, Decl(inferTypes1.ts, 49, 15)) ->y : Symbol(y, Decl(inferTypes1.ts, 49, 23)) +>T30 : Symbol(T30, Decl(inferTypes1.ts, 50, 92)) +>X1 : Symbol(X1, Decl(inferTypes1.ts, 48, 31)) +>x : Symbol(x, Decl(inferTypes1.ts, 52, 15)) +>y : Symbol(y, Decl(inferTypes1.ts, 52, 23)) type T31 = X1<{ x: number, y: string }>; // [number, string] ->T31 : Symbol(T31, Decl(inferTypes1.ts, 49, 34)) ->X1 : Symbol(X1, Decl(inferTypes1.ts, 45, 31)) ->x : Symbol(x, Decl(inferTypes1.ts, 50, 15)) ->y : Symbol(y, Decl(inferTypes1.ts, 50, 26)) +>T31 : Symbol(T31, Decl(inferTypes1.ts, 52, 34)) +>X1 : Symbol(X1, Decl(inferTypes1.ts, 48, 31)) +>x : Symbol(x, Decl(inferTypes1.ts, 53, 15)) +>y : Symbol(y, Decl(inferTypes1.ts, 53, 26)) type T32 = X1<{ x: number, y: string, z: boolean }>; // [number, string] ->T32 : Symbol(T32, Decl(inferTypes1.ts, 50, 40)) ->X1 : Symbol(X1, Decl(inferTypes1.ts, 45, 31)) ->x : Symbol(x, Decl(inferTypes1.ts, 51, 15)) ->y : Symbol(y, Decl(inferTypes1.ts, 51, 26)) ->z : Symbol(z, Decl(inferTypes1.ts, 51, 37)) +>T32 : Symbol(T32, Decl(inferTypes1.ts, 53, 40)) +>X1 : Symbol(X1, Decl(inferTypes1.ts, 48, 31)) +>x : Symbol(x, Decl(inferTypes1.ts, 54, 15)) +>y : Symbol(y, Decl(inferTypes1.ts, 54, 26)) +>z : Symbol(z, Decl(inferTypes1.ts, 54, 37)) type X2 = T extends { a: infer U, b: infer U } ? U : never; ->X2 : Symbol(X2, Decl(inferTypes1.ts, 51, 52)) ->T : Symbol(T, Decl(inferTypes1.ts, 53, 8)) ->T : Symbol(T, Decl(inferTypes1.ts, 53, 8)) ->a : Symbol(a, Decl(inferTypes1.ts, 53, 24)) ->U : Symbol(U, Decl(inferTypes1.ts, 53, 33), Decl(inferTypes1.ts, 53, 45)) ->b : Symbol(b, Decl(inferTypes1.ts, 53, 36)) ->U : Symbol(U, Decl(inferTypes1.ts, 53, 33), Decl(inferTypes1.ts, 53, 45)) ->U : Symbol(U, Decl(inferTypes1.ts, 53, 33), Decl(inferTypes1.ts, 53, 45)) +>X2 : Symbol(X2, Decl(inferTypes1.ts, 54, 52)) +>T : Symbol(T, Decl(inferTypes1.ts, 56, 8)) +>T : Symbol(T, Decl(inferTypes1.ts, 56, 8)) +>a : Symbol(a, Decl(inferTypes1.ts, 56, 24)) +>U : Symbol(U, Decl(inferTypes1.ts, 56, 33), Decl(inferTypes1.ts, 56, 45)) +>b : Symbol(b, Decl(inferTypes1.ts, 56, 36)) +>U : Symbol(U, Decl(inferTypes1.ts, 56, 33), Decl(inferTypes1.ts, 56, 45)) +>U : Symbol(U, Decl(inferTypes1.ts, 56, 33), Decl(inferTypes1.ts, 56, 45)) type T40 = X2<{}>; // never ->T40 : Symbol(T40, Decl(inferTypes1.ts, 53, 62)) ->X2 : Symbol(X2, Decl(inferTypes1.ts, 51, 52)) +>T40 : Symbol(T40, Decl(inferTypes1.ts, 56, 62)) +>X2 : Symbol(X2, Decl(inferTypes1.ts, 54, 52)) type T41 = X2<{ a: string }>; // never ->T41 : Symbol(T41, Decl(inferTypes1.ts, 55, 18)) ->X2 : Symbol(X2, Decl(inferTypes1.ts, 51, 52)) ->a : Symbol(a, Decl(inferTypes1.ts, 56, 15)) +>T41 : Symbol(T41, Decl(inferTypes1.ts, 58, 18)) +>X2 : Symbol(X2, Decl(inferTypes1.ts, 54, 52)) +>a : Symbol(a, Decl(inferTypes1.ts, 59, 15)) type T42 = X2<{ a: string, b: string }>; // string ->T42 : Symbol(T42, Decl(inferTypes1.ts, 56, 29)) ->X2 : Symbol(X2, Decl(inferTypes1.ts, 51, 52)) ->a : Symbol(a, Decl(inferTypes1.ts, 57, 15)) ->b : Symbol(b, Decl(inferTypes1.ts, 57, 26)) +>T42 : Symbol(T42, Decl(inferTypes1.ts, 59, 29)) +>X2 : Symbol(X2, Decl(inferTypes1.ts, 54, 52)) +>a : Symbol(a, Decl(inferTypes1.ts, 60, 15)) +>b : Symbol(b, Decl(inferTypes1.ts, 60, 26)) type T43 = X2<{ a: number, b: string }>; // string | number ->T43 : Symbol(T43, Decl(inferTypes1.ts, 57, 40)) ->X2 : Symbol(X2, Decl(inferTypes1.ts, 51, 52)) ->a : Symbol(a, Decl(inferTypes1.ts, 58, 15)) ->b : Symbol(b, Decl(inferTypes1.ts, 58, 26)) +>T43 : Symbol(T43, Decl(inferTypes1.ts, 60, 40)) +>X2 : Symbol(X2, Decl(inferTypes1.ts, 54, 52)) +>a : Symbol(a, Decl(inferTypes1.ts, 61, 15)) +>b : Symbol(b, Decl(inferTypes1.ts, 61, 26)) type T44 = X2<{ a: number, b: string, c: boolean }>; // string | number ->T44 : Symbol(T44, Decl(inferTypes1.ts, 58, 40)) ->X2 : Symbol(X2, Decl(inferTypes1.ts, 51, 52)) ->a : Symbol(a, Decl(inferTypes1.ts, 59, 15)) ->b : Symbol(b, Decl(inferTypes1.ts, 59, 26)) ->c : Symbol(c, Decl(inferTypes1.ts, 59, 37)) +>T44 : Symbol(T44, Decl(inferTypes1.ts, 61, 40)) +>X2 : Symbol(X2, Decl(inferTypes1.ts, 54, 52)) +>a : Symbol(a, Decl(inferTypes1.ts, 62, 15)) +>b : Symbol(b, Decl(inferTypes1.ts, 62, 26)) +>c : Symbol(c, Decl(inferTypes1.ts, 62, 37)) type X3 = T extends { a: (x: infer U) => void, b: (x: infer U) => void } ? U : never; ->X3 : Symbol(X3, Decl(inferTypes1.ts, 59, 52)) ->T : Symbol(T, Decl(inferTypes1.ts, 61, 8)) ->T : Symbol(T, Decl(inferTypes1.ts, 61, 8)) ->a : Symbol(a, Decl(inferTypes1.ts, 61, 24)) ->x : Symbol(x, Decl(inferTypes1.ts, 61, 29)) ->U : Symbol(U, Decl(inferTypes1.ts, 61, 37), Decl(inferTypes1.ts, 61, 62)) ->b : Symbol(b, Decl(inferTypes1.ts, 61, 49)) ->x : Symbol(x, Decl(inferTypes1.ts, 61, 54)) ->U : Symbol(U, Decl(inferTypes1.ts, 61, 37), Decl(inferTypes1.ts, 61, 62)) ->U : Symbol(U, Decl(inferTypes1.ts, 61, 37), Decl(inferTypes1.ts, 61, 62)) +>X3 : Symbol(X3, Decl(inferTypes1.ts, 62, 52)) +>T : Symbol(T, Decl(inferTypes1.ts, 64, 8)) +>T : Symbol(T, Decl(inferTypes1.ts, 64, 8)) +>a : Symbol(a, Decl(inferTypes1.ts, 64, 24)) +>x : Symbol(x, Decl(inferTypes1.ts, 64, 29)) +>U : Symbol(U, Decl(inferTypes1.ts, 64, 37), Decl(inferTypes1.ts, 64, 62)) +>b : Symbol(b, Decl(inferTypes1.ts, 64, 49)) +>x : Symbol(x, Decl(inferTypes1.ts, 64, 54)) +>U : Symbol(U, Decl(inferTypes1.ts, 64, 37), Decl(inferTypes1.ts, 64, 62)) +>U : Symbol(U, Decl(inferTypes1.ts, 64, 37), Decl(inferTypes1.ts, 64, 62)) type T50 = X3<{}>; // never ->T50 : Symbol(T50, Decl(inferTypes1.ts, 61, 88)) ->X3 : Symbol(X3, Decl(inferTypes1.ts, 59, 52)) +>T50 : Symbol(T50, Decl(inferTypes1.ts, 64, 88)) +>X3 : Symbol(X3, Decl(inferTypes1.ts, 62, 52)) type T51 = X3<{ a: (x: string) => void }>; // never ->T51 : Symbol(T51, Decl(inferTypes1.ts, 63, 18)) ->X3 : Symbol(X3, Decl(inferTypes1.ts, 59, 52)) ->a : Symbol(a, Decl(inferTypes1.ts, 64, 15)) ->x : Symbol(x, Decl(inferTypes1.ts, 64, 20)) - -type T52 = X3<{ a: (x: string) => void, b: (x: string) => void }>; // string ->T52 : Symbol(T52, Decl(inferTypes1.ts, 64, 42)) ->X3 : Symbol(X3, Decl(inferTypes1.ts, 59, 52)) ->a : Symbol(a, Decl(inferTypes1.ts, 65, 15)) ->x : Symbol(x, Decl(inferTypes1.ts, 65, 20)) ->b : Symbol(b, Decl(inferTypes1.ts, 65, 39)) ->x : Symbol(x, Decl(inferTypes1.ts, 65, 44)) - -type T53 = X3<{ a: (x: number) => void, b: (x: string) => void }>; // string & number ->T53 : Symbol(T53, Decl(inferTypes1.ts, 65, 66)) ->X3 : Symbol(X3, Decl(inferTypes1.ts, 59, 52)) ->a : Symbol(a, Decl(inferTypes1.ts, 66, 15)) ->x : Symbol(x, Decl(inferTypes1.ts, 66, 20)) ->b : Symbol(b, Decl(inferTypes1.ts, 66, 39)) ->x : Symbol(x, Decl(inferTypes1.ts, 66, 44)) - -type T54 = X3<{ a: (x: number) => void, b: () => void }>; // number ->T54 : Symbol(T54, Decl(inferTypes1.ts, 66, 66)) ->X3 : Symbol(X3, Decl(inferTypes1.ts, 59, 52)) +>T51 : Symbol(T51, Decl(inferTypes1.ts, 66, 18)) +>X3 : Symbol(X3, Decl(inferTypes1.ts, 62, 52)) >a : Symbol(a, Decl(inferTypes1.ts, 67, 15)) >x : Symbol(x, Decl(inferTypes1.ts, 67, 20)) ->b : Symbol(b, Decl(inferTypes1.ts, 67, 39)) + +type T52 = X3<{ a: (x: string) => void, b: (x: string) => void }>; // string +>T52 : Symbol(T52, Decl(inferTypes1.ts, 67, 42)) +>X3 : Symbol(X3, Decl(inferTypes1.ts, 62, 52)) +>a : Symbol(a, Decl(inferTypes1.ts, 68, 15)) +>x : Symbol(x, Decl(inferTypes1.ts, 68, 20)) +>b : Symbol(b, Decl(inferTypes1.ts, 68, 39)) +>x : Symbol(x, Decl(inferTypes1.ts, 68, 44)) + +type T53 = X3<{ a: (x: number) => void, b: (x: string) => void }>; // string & number +>T53 : Symbol(T53, Decl(inferTypes1.ts, 68, 66)) +>X3 : Symbol(X3, Decl(inferTypes1.ts, 62, 52)) +>a : Symbol(a, Decl(inferTypes1.ts, 69, 15)) +>x : Symbol(x, Decl(inferTypes1.ts, 69, 20)) +>b : Symbol(b, Decl(inferTypes1.ts, 69, 39)) +>x : Symbol(x, Decl(inferTypes1.ts, 69, 44)) + +type T54 = X3<{ a: (x: number) => void, b: () => void }>; // number +>T54 : Symbol(T54, Decl(inferTypes1.ts, 69, 66)) +>X3 : Symbol(X3, Decl(inferTypes1.ts, 62, 52)) +>a : Symbol(a, Decl(inferTypes1.ts, 70, 15)) +>x : Symbol(x, Decl(inferTypes1.ts, 70, 20)) +>b : Symbol(b, Decl(inferTypes1.ts, 70, 39)) type T60 = infer U; // Error ->T60 : Symbol(T60, Decl(inferTypes1.ts, 67, 57)) ->U : Symbol(U, Decl(inferTypes1.ts, 69, 16)) +>T60 : Symbol(T60, Decl(inferTypes1.ts, 70, 57)) +>U : Symbol(U, Decl(inferTypes1.ts, 72, 16)) type T61 = infer A extends infer B ? infer C : infer D; // Error ->T61 : Symbol(T61, Decl(inferTypes1.ts, 69, 19)) ->T : Symbol(T, Decl(inferTypes1.ts, 70, 9)) ->A : Symbol(A, Decl(inferTypes1.ts, 70, 19)) ->B : Symbol(B, Decl(inferTypes1.ts, 70, 35)) ->C : Symbol(C, Decl(inferTypes1.ts, 70, 45)) ->D : Symbol(D, Decl(inferTypes1.ts, 70, 55)) +>T61 : Symbol(T61, Decl(inferTypes1.ts, 72, 19)) +>T : Symbol(T, Decl(inferTypes1.ts, 73, 9)) +>A : Symbol(A, Decl(inferTypes1.ts, 73, 19)) +>B : Symbol(B, Decl(inferTypes1.ts, 73, 35)) +>C : Symbol(C, Decl(inferTypes1.ts, 73, 45)) +>D : Symbol(D, Decl(inferTypes1.ts, 73, 55)) type T62 = U extends (infer U)[] ? U : U; // Error ->T62 : Symbol(T62, Decl(inferTypes1.ts, 70, 58)) ->T : Symbol(T, Decl(inferTypes1.ts, 71, 9)) ->U : Symbol(U, Decl(inferTypes1.ts, 71, 30)) ->U : Symbol(U, Decl(inferTypes1.ts, 71, 30)) +>T62 : Symbol(T62, Decl(inferTypes1.ts, 73, 58)) +>T : Symbol(T, Decl(inferTypes1.ts, 74, 9)) +>U : Symbol(U, Decl(inferTypes1.ts, 74, 30)) +>U : Symbol(U, Decl(inferTypes1.ts, 74, 30)) type T70 = { x: T }; ->T70 : Symbol(T70, Decl(inferTypes1.ts, 71, 44)) ->T : Symbol(T, Decl(inferTypes1.ts, 73, 9)) ->x : Symbol(x, Decl(inferTypes1.ts, 73, 30)) ->T : Symbol(T, Decl(inferTypes1.ts, 73, 9)) +>T70 : Symbol(T70, Decl(inferTypes1.ts, 74, 44)) +>T : Symbol(T, Decl(inferTypes1.ts, 76, 9)) +>x : Symbol(x, Decl(inferTypes1.ts, 76, 30)) +>T : Symbol(T, Decl(inferTypes1.ts, 76, 9)) type T71 = T extends T70 ? T70 : never; ->T71 : Symbol(T71, Decl(inferTypes1.ts, 73, 38)) ->T : Symbol(T, Decl(inferTypes1.ts, 74, 9)) ->T : Symbol(T, Decl(inferTypes1.ts, 74, 9)) ->T70 : Symbol(T70, Decl(inferTypes1.ts, 71, 44)) ->U : Symbol(U, Decl(inferTypes1.ts, 74, 33)) ->T70 : Symbol(T70, Decl(inferTypes1.ts, 71, 44)) ->U : Symbol(U, Decl(inferTypes1.ts, 74, 33)) +>T71 : Symbol(T71, Decl(inferTypes1.ts, 76, 38)) +>T : Symbol(T, Decl(inferTypes1.ts, 77, 9)) +>T : Symbol(T, Decl(inferTypes1.ts, 77, 9)) +>T70 : Symbol(T70, Decl(inferTypes1.ts, 74, 44)) +>U : Symbol(U, Decl(inferTypes1.ts, 77, 33)) +>T70 : Symbol(T70, Decl(inferTypes1.ts, 74, 44)) +>U : Symbol(U, Decl(inferTypes1.ts, 77, 33)) type T72 = { y: T }; ->T72 : Symbol(T72, Decl(inferTypes1.ts, 74, 54)) ->T : Symbol(T, Decl(inferTypes1.ts, 76, 9)) ->y : Symbol(y, Decl(inferTypes1.ts, 76, 30)) ->T : Symbol(T, Decl(inferTypes1.ts, 76, 9)) +>T72 : Symbol(T72, Decl(inferTypes1.ts, 77, 54)) +>T : Symbol(T, Decl(inferTypes1.ts, 79, 9)) +>y : Symbol(y, Decl(inferTypes1.ts, 79, 30)) +>T : Symbol(T, Decl(inferTypes1.ts, 79, 9)) type T73 = T extends T72 ? T70 : never; // Error ->T73 : Symbol(T73, Decl(inferTypes1.ts, 76, 38)) ->T : Symbol(T, Decl(inferTypes1.ts, 77, 9)) ->T : Symbol(T, Decl(inferTypes1.ts, 77, 9)) ->T72 : Symbol(T72, Decl(inferTypes1.ts, 74, 54)) ->U : Symbol(U, Decl(inferTypes1.ts, 77, 33)) ->T70 : Symbol(T70, Decl(inferTypes1.ts, 71, 44)) ->U : Symbol(U, Decl(inferTypes1.ts, 77, 33)) +>T73 : Symbol(T73, Decl(inferTypes1.ts, 79, 38)) +>T : Symbol(T, Decl(inferTypes1.ts, 80, 9)) +>T : Symbol(T, Decl(inferTypes1.ts, 80, 9)) +>T72 : Symbol(T72, Decl(inferTypes1.ts, 77, 54)) +>U : Symbol(U, Decl(inferTypes1.ts, 80, 33)) +>T70 : Symbol(T70, Decl(inferTypes1.ts, 74, 44)) +>U : Symbol(U, Decl(inferTypes1.ts, 80, 33)) type T74 = { x: T, y: U }; ->T74 : Symbol(T74, Decl(inferTypes1.ts, 77, 54)) ->T : Symbol(T, Decl(inferTypes1.ts, 79, 9)) ->U : Symbol(U, Decl(inferTypes1.ts, 79, 26)) ->x : Symbol(x, Decl(inferTypes1.ts, 79, 48)) ->T : Symbol(T, Decl(inferTypes1.ts, 79, 9)) ->y : Symbol(y, Decl(inferTypes1.ts, 79, 54)) ->U : Symbol(U, Decl(inferTypes1.ts, 79, 26)) +>T74 : Symbol(T74, Decl(inferTypes1.ts, 80, 54)) +>T : Symbol(T, Decl(inferTypes1.ts, 82, 9)) +>U : Symbol(U, Decl(inferTypes1.ts, 82, 26)) +>x : Symbol(x, Decl(inferTypes1.ts, 82, 48)) +>T : Symbol(T, Decl(inferTypes1.ts, 82, 9)) +>y : Symbol(y, Decl(inferTypes1.ts, 82, 54)) +>U : Symbol(U, Decl(inferTypes1.ts, 82, 26)) type T75 = T extends T74 ? T70 | T72 | T74 : never; ->T75 : Symbol(T75, Decl(inferTypes1.ts, 79, 62)) ->T : Symbol(T, Decl(inferTypes1.ts, 80, 9)) ->T : Symbol(T, Decl(inferTypes1.ts, 80, 9)) ->T74 : Symbol(T74, Decl(inferTypes1.ts, 77, 54)) ->U : Symbol(U, Decl(inferTypes1.ts, 80, 33), Decl(inferTypes1.ts, 80, 42)) ->U : Symbol(U, Decl(inferTypes1.ts, 80, 33), Decl(inferTypes1.ts, 80, 42)) ->T70 : Symbol(T70, Decl(inferTypes1.ts, 71, 44)) ->U : Symbol(U, Decl(inferTypes1.ts, 80, 33), Decl(inferTypes1.ts, 80, 42)) ->T72 : Symbol(T72, Decl(inferTypes1.ts, 74, 54)) ->U : Symbol(U, Decl(inferTypes1.ts, 80, 33), Decl(inferTypes1.ts, 80, 42)) ->T74 : Symbol(T74, Decl(inferTypes1.ts, 77, 54)) ->U : Symbol(U, Decl(inferTypes1.ts, 80, 33), Decl(inferTypes1.ts, 80, 42)) ->U : Symbol(U, Decl(inferTypes1.ts, 80, 33), Decl(inferTypes1.ts, 80, 42)) +>T75 : Symbol(T75, Decl(inferTypes1.ts, 82, 62)) +>T : Symbol(T, Decl(inferTypes1.ts, 83, 9)) +>T : Symbol(T, Decl(inferTypes1.ts, 83, 9)) +>T74 : Symbol(T74, Decl(inferTypes1.ts, 80, 54)) +>U : Symbol(U, Decl(inferTypes1.ts, 83, 33), Decl(inferTypes1.ts, 83, 42)) +>U : Symbol(U, Decl(inferTypes1.ts, 83, 33), Decl(inferTypes1.ts, 83, 42)) +>T70 : Symbol(T70, Decl(inferTypes1.ts, 74, 44)) +>U : Symbol(U, Decl(inferTypes1.ts, 83, 33), Decl(inferTypes1.ts, 83, 42)) +>T72 : Symbol(T72, Decl(inferTypes1.ts, 77, 54)) +>U : Symbol(U, Decl(inferTypes1.ts, 83, 33), Decl(inferTypes1.ts, 83, 42)) +>T74 : Symbol(T74, Decl(inferTypes1.ts, 80, 54)) +>U : Symbol(U, Decl(inferTypes1.ts, 83, 33), Decl(inferTypes1.ts, 83, 42)) +>U : Symbol(U, Decl(inferTypes1.ts, 83, 33), Decl(inferTypes1.ts, 83, 42)) type T76 = { x: T }; ->T76 : Symbol(T76, Decl(inferTypes1.ts, 80, 84)) ->T : Symbol(T, Decl(inferTypes1.ts, 82, 9)) ->T : Symbol(T, Decl(inferTypes1.ts, 82, 9)) ->U : Symbol(U, Decl(inferTypes1.ts, 82, 23)) ->T : Symbol(T, Decl(inferTypes1.ts, 82, 9)) ->x : Symbol(x, Decl(inferTypes1.ts, 82, 40)) ->T : Symbol(T, Decl(inferTypes1.ts, 82, 9)) +>T76 : Symbol(T76, Decl(inferTypes1.ts, 83, 84)) +>T : Symbol(T, Decl(inferTypes1.ts, 85, 9)) +>T : Symbol(T, Decl(inferTypes1.ts, 85, 9)) +>U : Symbol(U, Decl(inferTypes1.ts, 85, 23)) +>T : Symbol(T, Decl(inferTypes1.ts, 85, 9)) +>x : Symbol(x, Decl(inferTypes1.ts, 85, 40)) +>T : Symbol(T, Decl(inferTypes1.ts, 85, 9)) type T77 = T extends T76 ? T76 : never; ->T77 : Symbol(T77, Decl(inferTypes1.ts, 82, 48)) ->T : Symbol(T, Decl(inferTypes1.ts, 83, 9)) ->T : Symbol(T, Decl(inferTypes1.ts, 83, 9)) ->T76 : Symbol(T76, Decl(inferTypes1.ts, 80, 84)) ->X : Symbol(X, Decl(inferTypes1.ts, 83, 33)) ->Y : Symbol(Y, Decl(inferTypes1.ts, 83, 42)) ->T76 : Symbol(T76, Decl(inferTypes1.ts, 80, 84)) ->X : Symbol(X, Decl(inferTypes1.ts, 83, 33)) ->Y : Symbol(Y, Decl(inferTypes1.ts, 83, 42)) +>T77 : Symbol(T77, Decl(inferTypes1.ts, 85, 48)) +>T : Symbol(T, Decl(inferTypes1.ts, 86, 9)) +>T : Symbol(T, Decl(inferTypes1.ts, 86, 9)) +>T76 : Symbol(T76, Decl(inferTypes1.ts, 83, 84)) +>X : Symbol(X, Decl(inferTypes1.ts, 86, 33)) +>Y : Symbol(Y, Decl(inferTypes1.ts, 86, 42)) +>T76 : Symbol(T76, Decl(inferTypes1.ts, 83, 84)) +>X : Symbol(X, Decl(inferTypes1.ts, 86, 33)) +>Y : Symbol(Y, Decl(inferTypes1.ts, 86, 42)) type T78 = T extends T76 ? T76 : never; ->T78 : Symbol(T78, Decl(inferTypes1.ts, 83, 66)) ->T : Symbol(T, Decl(inferTypes1.ts, 84, 9)) ->T : Symbol(T, Decl(inferTypes1.ts, 84, 9)) ->T76 : Symbol(T76, Decl(inferTypes1.ts, 80, 84)) ->X : Symbol(X, Decl(inferTypes1.ts, 84, 33), Decl(inferTypes1.ts, 84, 42)) ->X : Symbol(X, Decl(inferTypes1.ts, 84, 33), Decl(inferTypes1.ts, 84, 42)) ->T76 : Symbol(T76, Decl(inferTypes1.ts, 80, 84)) ->X : Symbol(X, Decl(inferTypes1.ts, 84, 33), Decl(inferTypes1.ts, 84, 42)) ->X : Symbol(X, Decl(inferTypes1.ts, 84, 33), Decl(inferTypes1.ts, 84, 42)) +>T78 : Symbol(T78, Decl(inferTypes1.ts, 86, 66)) +>T : Symbol(T, Decl(inferTypes1.ts, 87, 9)) +>T : Symbol(T, Decl(inferTypes1.ts, 87, 9)) +>T76 : Symbol(T76, Decl(inferTypes1.ts, 83, 84)) +>X : Symbol(X, Decl(inferTypes1.ts, 87, 33), Decl(inferTypes1.ts, 87, 42)) +>X : Symbol(X, Decl(inferTypes1.ts, 87, 33), Decl(inferTypes1.ts, 87, 42)) +>T76 : Symbol(T76, Decl(inferTypes1.ts, 83, 84)) +>X : Symbol(X, Decl(inferTypes1.ts, 87, 33), Decl(inferTypes1.ts, 87, 42)) +>X : Symbol(X, Decl(inferTypes1.ts, 87, 33), Decl(inferTypes1.ts, 87, 42)) // Example from #21496 type JsonifiedObject = { [K in keyof T]: Jsonified }; ->JsonifiedObject : Symbol(JsonifiedObject, Decl(inferTypes1.ts, 84, 66)) ->T : Symbol(T, Decl(inferTypes1.ts, 88, 21)) ->K : Symbol(K, Decl(inferTypes1.ts, 88, 44)) ->T : Symbol(T, Decl(inferTypes1.ts, 88, 21)) ->Jsonified : Symbol(Jsonified, Decl(inferTypes1.ts, 88, 77)) ->T : Symbol(T, Decl(inferTypes1.ts, 88, 21)) ->K : Symbol(K, Decl(inferTypes1.ts, 88, 44)) +>JsonifiedObject : Symbol(JsonifiedObject, Decl(inferTypes1.ts, 87, 66)) +>T : Symbol(T, Decl(inferTypes1.ts, 91, 21)) +>K : Symbol(K, Decl(inferTypes1.ts, 91, 44)) +>T : Symbol(T, Decl(inferTypes1.ts, 91, 21)) +>Jsonified : Symbol(Jsonified, Decl(inferTypes1.ts, 91, 77)) +>T : Symbol(T, Decl(inferTypes1.ts, 91, 21)) +>K : Symbol(K, Decl(inferTypes1.ts, 91, 44)) type Jsonified = ->Jsonified : Symbol(Jsonified, Decl(inferTypes1.ts, 88, 77)) ->T : Symbol(T, Decl(inferTypes1.ts, 90, 15)) +>Jsonified : Symbol(Jsonified, Decl(inferTypes1.ts, 91, 77)) +>T : Symbol(T, Decl(inferTypes1.ts, 93, 15)) T extends string | number | boolean | null ? T ->T : Symbol(T, Decl(inferTypes1.ts, 90, 15)) ->T : Symbol(T, Decl(inferTypes1.ts, 90, 15)) +>T : Symbol(T, Decl(inferTypes1.ts, 93, 15)) +>T : Symbol(T, Decl(inferTypes1.ts, 93, 15)) : T extends undefined | Function ? never // undefined and functions are removed ->T : Symbol(T, Decl(inferTypes1.ts, 90, 15)) +>T : Symbol(T, Decl(inferTypes1.ts, 93, 15)) >Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) : T extends { toJSON(): infer R } ? R // toJSON is called if it exists (e.g. Date) ->T : Symbol(T, Decl(inferTypes1.ts, 90, 15)) ->toJSON : Symbol(toJSON, Decl(inferTypes1.ts, 93, 17)) ->R : Symbol(R, Decl(inferTypes1.ts, 93, 33)) ->R : Symbol(R, Decl(inferTypes1.ts, 93, 33)) +>T : Symbol(T, Decl(inferTypes1.ts, 93, 15)) +>toJSON : Symbol(toJSON, Decl(inferTypes1.ts, 96, 17)) +>R : Symbol(R, Decl(inferTypes1.ts, 96, 33)) +>R : Symbol(R, Decl(inferTypes1.ts, 96, 33)) : T extends object ? JsonifiedObject ->T : Symbol(T, Decl(inferTypes1.ts, 90, 15)) ->JsonifiedObject : Symbol(JsonifiedObject, Decl(inferTypes1.ts, 84, 66)) ->T : Symbol(T, Decl(inferTypes1.ts, 90, 15)) +>T : Symbol(T, Decl(inferTypes1.ts, 93, 15)) +>JsonifiedObject : Symbol(JsonifiedObject, Decl(inferTypes1.ts, 87, 66)) +>T : Symbol(T, Decl(inferTypes1.ts, 93, 15)) : "what is this"; type Example = { ->Example : Symbol(Example, Decl(inferTypes1.ts, 95, 21)) +>Example : Symbol(Example, Decl(inferTypes1.ts, 98, 21)) str: "literalstring", ->str : Symbol(str, Decl(inferTypes1.ts, 97, 16)) +>str : Symbol(str, Decl(inferTypes1.ts, 100, 16)) fn: () => void, ->fn : Symbol(fn, Decl(inferTypes1.ts, 98, 25)) +>fn : Symbol(fn, Decl(inferTypes1.ts, 101, 25)) date: Date, ->date : Symbol(date, Decl(inferTypes1.ts, 99, 19)) +>date : Symbol(date, Decl(inferTypes1.ts, 102, 19)) >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) customClass: MyClass, ->customClass : Symbol(customClass, Decl(inferTypes1.ts, 100, 15)) ->MyClass : Symbol(MyClass, Decl(inferTypes1.ts, 107, 1)) +>customClass : Symbol(customClass, Decl(inferTypes1.ts, 103, 15)) +>MyClass : Symbol(MyClass, Decl(inferTypes1.ts, 110, 1)) obj: { ->obj : Symbol(obj, Decl(inferTypes1.ts, 101, 25)) +>obj : Symbol(obj, Decl(inferTypes1.ts, 104, 25)) prop: "property", ->prop : Symbol(prop, Decl(inferTypes1.ts, 102, 10)) +>prop : Symbol(prop, Decl(inferTypes1.ts, 105, 10)) clz: MyClass, ->clz : Symbol(clz, Decl(inferTypes1.ts, 103, 25)) ->MyClass : Symbol(MyClass, Decl(inferTypes1.ts, 107, 1)) +>clz : Symbol(clz, Decl(inferTypes1.ts, 106, 25)) +>MyClass : Symbol(MyClass, Decl(inferTypes1.ts, 110, 1)) nested: { attr: Date } ->nested : Symbol(nested, Decl(inferTypes1.ts, 104, 21)) ->attr : Symbol(attr, Decl(inferTypes1.ts, 105, 17)) +>nested : Symbol(nested, Decl(inferTypes1.ts, 107, 21)) +>attr : Symbol(attr, Decl(inferTypes1.ts, 108, 17)) >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) }, } declare class MyClass { ->MyClass : Symbol(MyClass, Decl(inferTypes1.ts, 107, 1)) +>MyClass : Symbol(MyClass, Decl(inferTypes1.ts, 110, 1)) toJSON(): "correct"; ->toJSON : Symbol(MyClass.toJSON, Decl(inferTypes1.ts, 109, 23)) +>toJSON : Symbol(MyClass.toJSON, Decl(inferTypes1.ts, 112, 23)) } type JsonifiedExample = Jsonified; ->JsonifiedExample : Symbol(JsonifiedExample, Decl(inferTypes1.ts, 111, 1)) ->Jsonified : Symbol(Jsonified, Decl(inferTypes1.ts, 88, 77)) ->Example : Symbol(Example, Decl(inferTypes1.ts, 95, 21)) +>JsonifiedExample : Symbol(JsonifiedExample, Decl(inferTypes1.ts, 114, 1)) +>Jsonified : Symbol(Jsonified, Decl(inferTypes1.ts, 91, 77)) +>Example : Symbol(Example, Decl(inferTypes1.ts, 98, 21)) declare let ex: JsonifiedExample; ->ex : Symbol(ex, Decl(inferTypes1.ts, 114, 11)) ->JsonifiedExample : Symbol(JsonifiedExample, Decl(inferTypes1.ts, 111, 1)) +>ex : Symbol(ex, Decl(inferTypes1.ts, 117, 11)) +>JsonifiedExample : Symbol(JsonifiedExample, Decl(inferTypes1.ts, 114, 1)) const z1: "correct" = ex.customClass; ->z1 : Symbol(z1, Decl(inferTypes1.ts, 115, 5)) ->ex.customClass : Symbol(customClass, Decl(inferTypes1.ts, 100, 15)) ->ex : Symbol(ex, Decl(inferTypes1.ts, 114, 11)) ->customClass : Symbol(customClass, Decl(inferTypes1.ts, 100, 15)) +>z1 : Symbol(z1, Decl(inferTypes1.ts, 118, 5)) +>ex.customClass : Symbol(customClass, Decl(inferTypes1.ts, 103, 15)) +>ex : Symbol(ex, Decl(inferTypes1.ts, 117, 11)) +>customClass : Symbol(customClass, Decl(inferTypes1.ts, 103, 15)) const z2: string = ex.obj.nested.attr; ->z2 : Symbol(z2, Decl(inferTypes1.ts, 116, 5)) ->ex.obj.nested.attr : Symbol(attr, Decl(inferTypes1.ts, 105, 17)) ->ex.obj.nested : Symbol(nested, Decl(inferTypes1.ts, 104, 21)) ->ex.obj : Symbol(obj, Decl(inferTypes1.ts, 101, 25)) ->ex : Symbol(ex, Decl(inferTypes1.ts, 114, 11)) ->obj : Symbol(obj, Decl(inferTypes1.ts, 101, 25)) ->nested : Symbol(nested, Decl(inferTypes1.ts, 104, 21)) ->attr : Symbol(attr, Decl(inferTypes1.ts, 105, 17)) +>z2 : Symbol(z2, Decl(inferTypes1.ts, 119, 5)) +>ex.obj.nested.attr : Symbol(attr, Decl(inferTypes1.ts, 108, 17)) +>ex.obj.nested : Symbol(nested, Decl(inferTypes1.ts, 107, 21)) +>ex.obj : Symbol(obj, Decl(inferTypes1.ts, 104, 25)) +>ex : Symbol(ex, Decl(inferTypes1.ts, 117, 11)) +>obj : Symbol(obj, Decl(inferTypes1.ts, 104, 25)) +>nested : Symbol(nested, Decl(inferTypes1.ts, 107, 21)) +>attr : Symbol(attr, Decl(inferTypes1.ts, 108, 17)) // Repros from #21631 type A1> = [T, U]; ->A1 : Symbol(A1, Decl(inferTypes1.ts, 116, 38)) ->T : Symbol(T, Decl(inferTypes1.ts, 120, 8)) ->U : Symbol(U, Decl(inferTypes1.ts, 120, 10)) ->A1 : Symbol(A1, Decl(inferTypes1.ts, 116, 38)) ->T : Symbol(T, Decl(inferTypes1.ts, 120, 8)) ->U : Symbol(U, Decl(inferTypes1.ts, 120, 10)) +>A1 : Symbol(A1, Decl(inferTypes1.ts, 119, 38)) +>T : Symbol(T, Decl(inferTypes1.ts, 123, 8)) +>U : Symbol(U, Decl(inferTypes1.ts, 123, 10)) +>A1 : Symbol(A1, Decl(inferTypes1.ts, 119, 38)) +>T : Symbol(T, Decl(inferTypes1.ts, 123, 8)) +>U : Symbol(U, Decl(inferTypes1.ts, 123, 10)) type B1 = S extends A1 ? [T, U] : never; ->B1 : Symbol(B1, Decl(inferTypes1.ts, 120, 44)) ->S : Symbol(S, Decl(inferTypes1.ts, 121, 8)) ->S : Symbol(S, Decl(inferTypes1.ts, 121, 8)) ->A1 : Symbol(A1, Decl(inferTypes1.ts, 116, 38)) ->T : Symbol(T, Decl(inferTypes1.ts, 121, 31)) ->U : Symbol(U, Decl(inferTypes1.ts, 121, 40)) ->T : Symbol(T, Decl(inferTypes1.ts, 121, 31)) ->U : Symbol(U, Decl(inferTypes1.ts, 121, 40)) +>B1 : Symbol(B1, Decl(inferTypes1.ts, 123, 44)) +>S : Symbol(S, Decl(inferTypes1.ts, 124, 8)) +>S : Symbol(S, Decl(inferTypes1.ts, 124, 8)) +>A1 : Symbol(A1, Decl(inferTypes1.ts, 119, 38)) +>T : Symbol(T, Decl(inferTypes1.ts, 124, 31)) +>U : Symbol(U, Decl(inferTypes1.ts, 124, 40)) +>T : Symbol(T, Decl(inferTypes1.ts, 124, 31)) +>U : Symbol(U, Decl(inferTypes1.ts, 124, 40)) type A2 = [T, U]; ->A2 : Symbol(A2, Decl(inferTypes1.ts, 121, 61)) ->T : Symbol(T, Decl(inferTypes1.ts, 123, 8)) ->U : Symbol(U, Decl(inferTypes1.ts, 123, 10)) ->T : Symbol(T, Decl(inferTypes1.ts, 123, 8)) ->U : Symbol(U, Decl(inferTypes1.ts, 123, 10)) +>A2 : Symbol(A2, Decl(inferTypes1.ts, 124, 61)) +>T : Symbol(T, Decl(inferTypes1.ts, 126, 8)) +>U : Symbol(U, Decl(inferTypes1.ts, 126, 10)) +>T : Symbol(T, Decl(inferTypes1.ts, 126, 8)) +>U : Symbol(U, Decl(inferTypes1.ts, 126, 10)) type B2 = S extends A2 ? [T, U] : never; ->B2 : Symbol(B2, Decl(inferTypes1.ts, 123, 36)) ->S : Symbol(S, Decl(inferTypes1.ts, 124, 8)) ->S : Symbol(S, Decl(inferTypes1.ts, 124, 8)) ->A2 : Symbol(A2, Decl(inferTypes1.ts, 121, 61)) ->T : Symbol(T, Decl(inferTypes1.ts, 124, 31)) ->U : Symbol(U, Decl(inferTypes1.ts, 124, 40)) ->T : Symbol(T, Decl(inferTypes1.ts, 124, 31)) ->U : Symbol(U, Decl(inferTypes1.ts, 124, 40)) +>B2 : Symbol(B2, Decl(inferTypes1.ts, 126, 36)) +>S : Symbol(S, Decl(inferTypes1.ts, 127, 8)) +>S : Symbol(S, Decl(inferTypes1.ts, 127, 8)) +>A2 : Symbol(A2, Decl(inferTypes1.ts, 124, 61)) +>T : Symbol(T, Decl(inferTypes1.ts, 127, 31)) +>U : Symbol(U, Decl(inferTypes1.ts, 127, 40)) +>T : Symbol(T, Decl(inferTypes1.ts, 127, 31)) +>U : Symbol(U, Decl(inferTypes1.ts, 127, 40)) type C2 = S extends A2 ? [T, U] : never; ->C2 : Symbol(C2, Decl(inferTypes1.ts, 124, 61)) ->S : Symbol(S, Decl(inferTypes1.ts, 125, 8)) ->U : Symbol(U, Decl(inferTypes1.ts, 125, 10)) ->S : Symbol(S, Decl(inferTypes1.ts, 125, 8)) ->A2 : Symbol(A2, Decl(inferTypes1.ts, 121, 61)) ->T : Symbol(T, Decl(inferTypes1.ts, 125, 47)) ->U : Symbol(U, Decl(inferTypes1.ts, 125, 10)) ->T : Symbol(T, Decl(inferTypes1.ts, 125, 47)) ->U : Symbol(U, Decl(inferTypes1.ts, 125, 10)) +>C2 : Symbol(C2, Decl(inferTypes1.ts, 127, 61)) +>S : Symbol(S, Decl(inferTypes1.ts, 128, 8)) +>U : Symbol(U, Decl(inferTypes1.ts, 128, 10)) +>S : Symbol(S, Decl(inferTypes1.ts, 128, 8)) +>A2 : Symbol(A2, Decl(inferTypes1.ts, 124, 61)) +>T : Symbol(T, Decl(inferTypes1.ts, 128, 47)) +>U : Symbol(U, Decl(inferTypes1.ts, 128, 10)) +>T : Symbol(T, Decl(inferTypes1.ts, 128, 47)) +>U : Symbol(U, Decl(inferTypes1.ts, 128, 10)) // Repro from #21735 type A = T extends string ? { [P in T]: void; } : T; ->A : Symbol(A, Decl(inferTypes1.ts, 125, 71)) ->T : Symbol(T, Decl(inferTypes1.ts, 129, 7)) ->T : Symbol(T, Decl(inferTypes1.ts, 129, 7)) ->P : Symbol(P, Decl(inferTypes1.ts, 129, 34)) ->T : Symbol(T, Decl(inferTypes1.ts, 129, 7)) ->T : Symbol(T, Decl(inferTypes1.ts, 129, 7)) +>A : Symbol(A, Decl(inferTypes1.ts, 128, 71)) +>T : Symbol(T, Decl(inferTypes1.ts, 132, 7)) +>T : Symbol(T, Decl(inferTypes1.ts, 132, 7)) +>P : Symbol(P, Decl(inferTypes1.ts, 132, 34)) +>T : Symbol(T, Decl(inferTypes1.ts, 132, 7)) +>T : Symbol(T, Decl(inferTypes1.ts, 132, 7)) type B = string extends T ? { [P in T]: void; } : T; // Error ->B : Symbol(B, Decl(inferTypes1.ts, 129, 55)) ->T : Symbol(T, Decl(inferTypes1.ts, 130, 7)) ->T : Symbol(T, Decl(inferTypes1.ts, 130, 7)) ->P : Symbol(P, Decl(inferTypes1.ts, 130, 34)) ->T : Symbol(T, Decl(inferTypes1.ts, 130, 7)) ->T : Symbol(T, Decl(inferTypes1.ts, 130, 7)) +>B : Symbol(B, Decl(inferTypes1.ts, 132, 55)) +>T : Symbol(T, Decl(inferTypes1.ts, 133, 7)) +>T : Symbol(T, Decl(inferTypes1.ts, 133, 7)) +>P : Symbol(P, Decl(inferTypes1.ts, 133, 34)) +>T : Symbol(T, Decl(inferTypes1.ts, 133, 7)) +>T : Symbol(T, Decl(inferTypes1.ts, 133, 7)) diff --git a/tests/baselines/reference/inferTypes1.types b/tests/baselines/reference/inferTypes1.types index 141a3d0aac6..f29c380a0ad 100644 --- a/tests/baselines/reference/inferTypes1.types +++ b/tests/baselines/reference/inferTypes1.types @@ -54,17 +54,6 @@ type T06 = Unpacked; // never >T06 : never >Unpacked : Unpacked -type ReturnType = T extends ((...args: any[]) => infer R) | (new (...args: any[]) => infer R) ? R : any; ->ReturnType : ReturnType ->T : T ->Function : Function ->T : T ->args : any[] ->R : R ->args : any[] ->R : R ->R : R - function f1(s: string) { >f1 : (s: string) => { a: number; b: string; } >s : string @@ -117,26 +106,43 @@ type T14 = ReturnType; // { a: number, b: string } >ReturnType : ReturnType >f1 : (s: string) => { a: number; b: string; } -type T15 = ReturnType; // C ->T15 : C +type T15 = ReturnType; // any +>T15 : any >ReturnType : ReturnType ->C : typeof C -type T16 = ReturnType; // any +type T16 = ReturnType; // any >T16 : any >ReturnType : ReturnType -type T17 = ReturnType; // any +type T17 = ReturnType; // Error >T17 : any >ReturnType : ReturnType -type T18 = ReturnType; // Error +type T18 = ReturnType; // Error >T18 : any >ReturnType : ReturnType +>Function : Function -type T19 = ReturnType; // any ->T19 : any ->ReturnType : ReturnType +type U10 = InstanceType; // C +>U10 : C +>InstanceType : InstanceType +>C : typeof C + +type U11 = InstanceType; // any +>U11 : any +>InstanceType : InstanceType + +type U12 = InstanceType; // any +>U12 : any +>InstanceType : InstanceType + +type U13 = InstanceType; // Error +>U13 : any +>InstanceType : InstanceType + +type U14 = InstanceType; // Error +>U14 : any +>InstanceType : InstanceType >Function : Function type ArgumentType any> = T extends (a: infer A) => any ? A : any; diff --git a/tests/baselines/reference/textChanges/deleteNode2.js b/tests/baselines/reference/textChanges/deleteNode2.js index 828a9b5b8fa..654c4929f15 100644 --- a/tests/baselines/reference/textChanges/deleteNode2.js +++ b/tests/baselines/reference/textChanges/deleteNode2.js @@ -9,4 +9,8 @@ var z = 3; // comment 4 ===MODIFIED=== -var x = 1;var z = 3; // comment 4 +var x = 1; // some comment - 1 +/** + * comment 2 + */ +var z = 3; // comment 4 diff --git a/tests/baselines/reference/textChanges/deleteNode4.js b/tests/baselines/reference/textChanges/deleteNode4.js index b6edb25bc5c..d6c35e5d2e1 100644 --- a/tests/baselines/reference/textChanges/deleteNode4.js +++ b/tests/baselines/reference/textChanges/deleteNode4.js @@ -9,5 +9,9 @@ var z = 3; // comment 4 ===MODIFIED=== -var x = 1; // comment 3 +var x = 1; // some comment - 1 +/** + * comment 2 + */ + // comment 3 var z = 3; // comment 4 diff --git a/tests/baselines/reference/textChanges/deleteNodeRange2.js b/tests/baselines/reference/textChanges/deleteNodeRange2.js index aacea6ff5ee..08274885af4 100644 --- a/tests/baselines/reference/textChanges/deleteNodeRange2.js +++ b/tests/baselines/reference/textChanges/deleteNodeRange2.js @@ -11,5 +11,7 @@ var a = 4; // comment 7 ===MODIFIED=== // comment 1 -var x = 1;// comment 6 +var x = 1; // comment 2 +// comment 3 +// comment 6 var a = 4; // comment 7 diff --git a/tests/baselines/reference/textChanges/deleteNodeRange4.js b/tests/baselines/reference/textChanges/deleteNodeRange4.js index 3e9ad960b13..5314c59c9e4 100644 --- a/tests/baselines/reference/textChanges/deleteNodeRange4.js +++ b/tests/baselines/reference/textChanges/deleteNodeRange4.js @@ -11,6 +11,8 @@ var a = 4; // comment 7 ===MODIFIED=== // comment 1 -var x = 1; // comment 5 +var x = 1; // comment 2 +// comment 3 + // comment 5 // comment 6 var a = 4; // comment 7 diff --git a/tests/baselines/reference/textChanges/replaceNode2.js b/tests/baselines/reference/textChanges/replaceNode2.js index 66a17f7c910..f474aaa327b 100644 --- a/tests/baselines/reference/textChanges/replaceNode2.js +++ b/tests/baselines/reference/textChanges/replaceNode2.js @@ -10,7 +10,9 @@ var a = 4; // comment 7 ===MODIFIED=== // comment 1 -var x = 1; +var x = 1; // comment 2 +// comment 3 + public class class1 implements interface1 { property1: boolean; diff --git a/tests/baselines/reference/textChanges/replaceNode4.js b/tests/baselines/reference/textChanges/replaceNode4.js index e5bbf0e306d..b5a998a88cd 100644 --- a/tests/baselines/reference/textChanges/replaceNode4.js +++ b/tests/baselines/reference/textChanges/replaceNode4.js @@ -10,7 +10,9 @@ var a = 4; // comment 7 ===MODIFIED=== // comment 1 -var x = 1;public class class1 implements interface1 +var x = 1; // comment 2 +// comment 3 +public class class1 implements interface1 { property1: boolean; } // comment 4 diff --git a/tests/baselines/reference/textChanges/replaceNode5.js b/tests/baselines/reference/textChanges/replaceNode5.js index ad3ec0ab0ea..9fc6d7777c9 100644 --- a/tests/baselines/reference/textChanges/replaceNode5.js +++ b/tests/baselines/reference/textChanges/replaceNode5.js @@ -8,6 +8,8 @@ var z = 3; // comment 5 // comment 6 var a = 4; // comment 7 ===MODIFIED=== + +// comment 1 public class class1 implements interface1 { property1: boolean; diff --git a/tests/baselines/reference/textChanges/replaceNodeRange2.js b/tests/baselines/reference/textChanges/replaceNodeRange2.js index e8f9506d608..ebd26644740 100644 --- a/tests/baselines/reference/textChanges/replaceNodeRange2.js +++ b/tests/baselines/reference/textChanges/replaceNodeRange2.js @@ -10,7 +10,9 @@ var a = 4; // comment 7 ===MODIFIED=== // comment 1 -var x = 1; +var x = 1; // comment 2 +// comment 3 + public class class1 implements interface1 { property1: boolean; diff --git a/tests/baselines/reference/textChanges/replaceNodeRange4.js b/tests/baselines/reference/textChanges/replaceNodeRange4.js index ad50a1f01fc..b21468dd06d 100644 --- a/tests/baselines/reference/textChanges/replaceNodeRange4.js +++ b/tests/baselines/reference/textChanges/replaceNodeRange4.js @@ -10,7 +10,9 @@ var a = 4; // comment 7 ===MODIFIED=== // comment 1 -var x = 1;public class class1 implements interface1 +var x = 1; // comment 2 +// comment 3 +public class class1 implements interface1 { property1: boolean; } // comment 5 diff --git a/tests/cases/conformance/types/conditional/conditionalTypes1.ts b/tests/cases/conformance/types/conditional/conditionalTypes1.ts index 8efd5f3d3c1..10cfceb0132 100644 --- a/tests/cases/conformance/types/conditional/conditionalTypes1.ts +++ b/tests/cases/conformance/types/conditional/conditionalTypes1.ts @@ -1,15 +1,11 @@ // @strict: true // @declaration: true -type Diff = T extends U ? never : T; -type Filter = T extends U ? T : never; -type NonNullable = Diff; +type T00 = Exclude<"a" | "b" | "c" | "d", "a" | "c" | "f">; // "b" | "d" +type T01 = Extract<"a" | "b" | "c" | "d", "a" | "c" | "f">; // "a" | "c" -type T00 = Diff<"a" | "b" | "c" | "d", "a" | "c" | "f">; // "b" | "d" -type T01 = Filter<"a" | "b" | "c" | "d", "a" | "c" | "f">; // "a" | "c" - -type T02 = Diff void), Function>; // string | number -type T03 = Filter void), Function>; // () => void +type T02 = Exclude void), Function>; // string | number +type T03 = Extract void), Function>; // () => void type T04 = NonNullable; // string | number type T05 = NonNullable<(() => string) | string[] | null | undefined>; // (() => string) | string[] @@ -40,23 +36,23 @@ function f4(x: T["x"], y: NonNullable; // { k: "c", c: boolean } -type T11 = Filter; // { k: "a", a: number } | { k: "b", b: string } +type T10 = Exclude; // { k: "c", c: boolean } +type T11 = Extract; // { k: "a", a: number } | { k: "b", b: string } -type T12 = Diff; // { k: "c", c: boolean } -type T13 = Filter; // { k: "a", a: number } | { k: "b", b: string } +type T12 = Exclude; // { k: "c", c: boolean } +type T13 = Extract; // { k: "a", a: number } | { k: "b", b: string } -type T14 = Diff; // Options -type T15 = Filter; // never +type T14 = Exclude; // Options +type T15 = Extract; // never -declare function f5(p: K): Filter; +declare function f5(p: K): Extract; let x0 = f5("a"); // { k: "a", a: number } -type OptionsOfKind = Filter; +type OptionsOfKind = Extract; type T16 = OptionsOfKind<"a" | "b">; // { k: "a", a: number } | { k: "b", b: string } -type Select = Filter; +type Select = Extract; type T17 = Select; // // { k: "a", a: number } | { k: "b", b: string } diff --git a/tests/cases/conformance/types/conditional/inferTypes1.ts b/tests/cases/conformance/types/conditional/inferTypes1.ts index 99cfa8a2460..cb803103bae 100644 --- a/tests/cases/conformance/types/conditional/inferTypes1.ts +++ b/tests/cases/conformance/types/conditional/inferTypes1.ts @@ -15,8 +15,6 @@ type T04 = Unpacked[]>>; // string type T05 = Unpacked; // any type T06 = Unpacked; // never -type ReturnType = T extends ((...args: any[]) => infer R) | (new (...args: any[]) => infer R) ? R : any; - function f1(s: string) { return { a: 1, b: s }; } @@ -31,11 +29,16 @@ type T11 = ReturnType<(s: string) => void>; // void type T12 = ReturnType<(() => T)>; // {} type T13 = ReturnType<(() => T)>; // number[] type T14 = ReturnType; // { a: number, b: string } -type T15 = ReturnType; // C -type T16 = ReturnType; // any -type T17 = ReturnType; // any -type T18 = ReturnType; // Error -type T19 = ReturnType; // any +type T15 = ReturnType; // any +type T16 = ReturnType; // any +type T17 = ReturnType; // Error +type T18 = ReturnType; // Error + +type U10 = InstanceType; // C +type U11 = InstanceType; // any +type U12 = InstanceType; // any +type U13 = InstanceType; // Error +type U14 = InstanceType; // Error type ArgumentType any> = T extends (a: infer A) => any ? A : any; diff --git a/tests/cases/fourslash/completionsRecommended_nonAccessibleSymbol.ts b/tests/cases/fourslash/completionsRecommended_nonAccessibleSymbol.ts new file mode 100644 index 00000000000..0f27e824d2b --- /dev/null +++ b/tests/cases/fourslash/completionsRecommended_nonAccessibleSymbol.ts @@ -0,0 +1,10 @@ +/// + +////function f() { +//// class C {} +//// return (c: C) => void; +////} +////f()(new /**/); + +goTo.marker(""); +verify.not.completionListContains("C"); // Not accessible diff --git a/tests/cases/fourslash/findAllRefsExportNotAtTopLevel.ts b/tests/cases/fourslash/findAllRefsExportNotAtTopLevel.ts new file mode 100644 index 00000000000..7f9c258bbe2 --- /dev/null +++ b/tests/cases/fourslash/findAllRefsExportNotAtTopLevel.ts @@ -0,0 +1,8 @@ +/// + +////{ +//// export const [|{| "isWriteAccess": true, "isDefinition": true |}x|] = 0; +//// [|x|]; +////} + +verify.singleReferenceGroup("const x: 0"); diff --git a/tests/cases/fourslash/findAllRefsReExport_broken.ts b/tests/cases/fourslash/findAllRefsReExport_broken.ts new file mode 100644 index 00000000000..7c42d9e2b6c --- /dev/null +++ b/tests/cases/fourslash/findAllRefsReExport_broken.ts @@ -0,0 +1,6 @@ +/// + +// @Filename: /a.ts +////export { [|{| "isWriteAccess": true, "isDefinition": true |}x|] }; + +verify.singleReferenceGroup("import x"); diff --git a/tests/cases/fourslash/findAllRefsReExport_broken2.ts b/tests/cases/fourslash/findAllRefsReExport_broken2.ts new file mode 100644 index 00000000000..4f8a3ea5f45 --- /dev/null +++ b/tests/cases/fourslash/findAllRefsReExport_broken2.ts @@ -0,0 +1,6 @@ +/// + +// @Filename: /a.ts +////export { [|{| "isWriteAccess": true, "isDefinition": true |}x|] } from "nonsense"; + +verify.singleReferenceGroup("import x"); diff --git a/tests/cases/fourslash/refactorConvertToEs6Module_triggers_declarationList.ts b/tests/cases/fourslash/refactorConvertToEs6Module_triggers_declarationList.ts new file mode 100644 index 00000000000..36ec32b0561 --- /dev/null +++ b/tests/cases/fourslash/refactorConvertToEs6Module_triggers_declarationList.ts @@ -0,0 +1,9 @@ +/// + +// @allowJs: true + +// @Filename: /a.js +////c[|o|]nst; +////require("x"); + +goTo.eachRange(() => verify.not.refactorAvailable("Convert to ES6 module"));