From 429b88f6a551ddb4767688d8464073ae934ae8e2 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Tue, 2 Feb 2021 14:32:24 -0800 Subject: [PATCH] Add another example from an issue, albeit slightly modified --- .../contextualOverloadListFromArrayUnion.js | 110 ++++++++++- ...ntextualOverloadListFromArrayUnion.symbols | 159 ++++++++++++++++ ...contextualOverloadListFromArrayUnion.types | 179 ++++++++++++++++++ .../contextualOverloadListFromArrayUnion.ts | 58 ++++++ 4 files changed, 496 insertions(+), 10 deletions(-) diff --git a/tests/baselines/reference/contextualOverloadListFromArrayUnion.js b/tests/baselines/reference/contextualOverloadListFromArrayUnion.js index ef2c9d29286e4..81f853ecbeda8 100644 --- a/tests/baselines/reference/contextualOverloadListFromArrayUnion.js +++ b/tests/baselines/reference/contextualOverloadListFromArrayUnion.js @@ -5,16 +5,106 @@ declare const y: never[] | string[]; export const yThen = y.map(item => item.length); //// [two.ts] declare const y: number[][] | string[]; -export const yThen = y.map(item => item.length); - +export const yThen = y.map(item => item.length); +//// [three.ts] +// #42504 +interface ResizeObserverCallback { + (entries: ResizeObserverEntry[], observer: ResizeObserver): void; +} +interface ResizeObserverCallback { // duplicate for effect + (entries: ResizeObserverEntry[], observer: ResizeObserver): void; +} + +const resizeObserver = new ResizeObserver(([entry]) => { + entry +}); +// comment in #35501 +interface Callback { + (error: null, result: T): unknown + (error: Error, result: null): unknown +} + +interface Task { + (callback: Callback): unknown +} + +export function series(tasks: Task[], callback: Callback): void { + let index = 0 + let results: T[] = [] + + function next() { + let task = tasks[index] + if (!task) { + callback(null, results) + } else { + task((error, result) => { + if (error) { + callback(error, null) + } else { + // must use postfix-!, since `error` and `result` don't have a + // causal relationship when the overloads are combined + results.push(result!) + next() + } + }) + } + } + next() +} + +series([ + cb => setTimeout(() => cb(null, 1), 300), + cb => setTimeout(() => cb(null, 2), 200), + cb => setTimeout(() => cb(null, 3), 100), +], (error, results) => { + if (error) { + console.error(error) + } else { + console.log(results) + } +}) //// [one.js] -"use strict"; -exports.__esModule = true; -exports.yThen = void 0; -exports.yThen = y.map(function (item) { return item.length; }); +export const yThen = y.map(item => item.length); //// [two.js] -"use strict"; -exports.__esModule = true; -exports.yThen = void 0; -exports.yThen = y.map(function (item) { return item.length; }); +export const yThen = y.map(item => item.length); +//// [three.js] +const resizeObserver = new ResizeObserver(([entry]) => { + entry; +}); +export function series(tasks, callback) { + let index = 0; + let results = []; + function next() { + let task = tasks[index]; + if (!task) { + callback(null, results); + } + else { + task((error, result) => { + if (error) { + callback(error, null); + } + else { + // must use postfix-!, since `error` and `result` don't have a + // causal relationship when the overloads are combined + results.push(result); + next(); + } + }); + } + } + next(); +} +series([ + cb => setTimeout(() => cb(null, 1), 300), + cb => setTimeout(() => cb(null, 2), 200), + cb => setTimeout(() => cb(null, 3), 100), +], (error, results) => { + if (error) { + console.error(error); + } + else { + console.log(results); + } +}); diff --git a/tests/baselines/reference/contextualOverloadListFromArrayUnion.symbols b/tests/baselines/reference/contextualOverloadListFromArrayUnion.symbols index 0ea129d7ace52..c79042b66ddad 100644 --- a/tests/baselines/reference/contextualOverloadListFromArrayUnion.symbols +++ b/tests/baselines/reference/contextualOverloadListFromArrayUnion.symbols @@ -26,3 +26,162 @@ export const yThen = y.map(item => item.length); >item : Symbol(item, Decl(two.ts, 1, 27)) >length : Symbol(length, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +=== tests/cases/compiler/three.ts === +// #42504 +interface ResizeObserverCallback { +>ResizeObserverCallback : Symbol(ResizeObserverCallback, Decl(three.ts, 0, 0), Decl(three.ts, 3, 1)) + + (entries: ResizeObserverEntry[], observer: ResizeObserver): void; +>entries : Symbol(entries, Decl(three.ts, 2, 5)) +>ResizeObserverEntry : Symbol(ResizeObserverEntry, Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --)) +>observer : Symbol(observer, Decl(three.ts, 2, 36)) +>ResizeObserver : Symbol(ResizeObserver, Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --)) +} +interface ResizeObserverCallback { // duplicate for effect +>ResizeObserverCallback : Symbol(ResizeObserverCallback, Decl(three.ts, 0, 0), Decl(three.ts, 3, 1)) + + (entries: ResizeObserverEntry[], observer: ResizeObserver): void; +>entries : Symbol(entries, Decl(three.ts, 5, 5)) +>ResizeObserverEntry : Symbol(ResizeObserverEntry, Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --)) +>observer : Symbol(observer, Decl(three.ts, 5, 36)) +>ResizeObserver : Symbol(ResizeObserver, Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --)) +} + +const resizeObserver = new ResizeObserver(([entry]) => { +>resizeObserver : Symbol(resizeObserver, Decl(three.ts, 8, 5)) +>ResizeObserver : Symbol(ResizeObserver, Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --)) +>entry : Symbol(entry, Decl(three.ts, 8, 44)) + + entry +>entry : Symbol(entry, Decl(three.ts, 8, 44)) + +}); +// comment in #35501 +interface Callback { +>Callback : Symbol(Callback, Decl(three.ts, 10, 3)) +>T : Symbol(T, Decl(three.ts, 12, 19)) + + (error: null, result: T): unknown +>error : Symbol(error, Decl(three.ts, 13, 5)) +>result : Symbol(result, Decl(three.ts, 13, 17)) +>T : Symbol(T, Decl(three.ts, 12, 19)) + + (error: Error, result: null): unknown +>error : Symbol(error, Decl(three.ts, 14, 5)) +>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>result : Symbol(result, Decl(three.ts, 14, 18)) +} + +interface Task { +>Task : Symbol(Task, Decl(three.ts, 15, 1)) +>T : Symbol(T, Decl(three.ts, 17, 15)) + + (callback: Callback): unknown +>callback : Symbol(callback, Decl(three.ts, 18, 5)) +>Callback : Symbol(Callback, Decl(three.ts, 10, 3)) +>T : Symbol(T, Decl(three.ts, 17, 15)) +} + +export function series(tasks: Task[], callback: Callback): void { +>series : Symbol(series, Decl(three.ts, 19, 1)) +>T : Symbol(T, Decl(three.ts, 21, 23)) +>tasks : Symbol(tasks, Decl(three.ts, 21, 26)) +>Task : Symbol(Task, Decl(three.ts, 15, 1)) +>T : Symbol(T, Decl(three.ts, 21, 23)) +>callback : Symbol(callback, Decl(three.ts, 21, 43)) +>Callback : Symbol(Callback, Decl(three.ts, 10, 3)) +>T : Symbol(T, Decl(three.ts, 21, 23)) + + let index = 0 +>index : Symbol(index, Decl(three.ts, 22, 7)) + + let results: T[] = [] +>results : Symbol(results, Decl(three.ts, 23, 7)) +>T : Symbol(T, Decl(three.ts, 21, 23)) + + function next() { +>next : Symbol(next, Decl(three.ts, 23, 25)) + + let task = tasks[index] +>task : Symbol(task, Decl(three.ts, 26, 11)) +>tasks : Symbol(tasks, Decl(three.ts, 21, 26)) +>index : Symbol(index, Decl(three.ts, 22, 7)) + + if (!task) { +>task : Symbol(task, Decl(three.ts, 26, 11)) + + callback(null, results) +>callback : Symbol(callback, Decl(three.ts, 21, 43)) +>results : Symbol(results, Decl(three.ts, 23, 7)) + + } else { + task((error, result) => { +>task : Symbol(task, Decl(three.ts, 26, 11)) +>error : Symbol(error, Decl(three.ts, 30, 18)) +>result : Symbol(result, Decl(three.ts, 30, 24)) + + if (error) { +>error : Symbol(error, Decl(three.ts, 30, 18)) + + callback(error, null) +>callback : Symbol(callback, Decl(three.ts, 21, 43)) +>error : Symbol(error, Decl(three.ts, 30, 18)) + + } else { + // must use postfix-!, since `error` and `result` don't have a + // causal relationship when the overloads are combined + results.push(result!) +>results.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>results : Symbol(results, Decl(three.ts, 23, 7)) +>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>result : Symbol(result, Decl(three.ts, 30, 24)) + + next() +>next : Symbol(next, Decl(three.ts, 23, 25)) + } + }) + } + } + next() +>next : Symbol(next, Decl(three.ts, 23, 25)) +} + +series([ +>series : Symbol(series, Decl(three.ts, 19, 1)) + + cb => setTimeout(() => cb(null, 1), 300), +>cb : Symbol(cb, Decl(three.ts, 45, 8)) +>setTimeout : Symbol(setTimeout, Decl(lib.dom.d.ts, --, --)) +>cb : Symbol(cb, Decl(three.ts, 45, 8)) + + cb => setTimeout(() => cb(null, 2), 200), +>cb : Symbol(cb, Decl(three.ts, 46, 45)) +>setTimeout : Symbol(setTimeout, Decl(lib.dom.d.ts, --, --)) +>cb : Symbol(cb, Decl(three.ts, 46, 45)) + + cb => setTimeout(() => cb(null, 3), 100), +>cb : Symbol(cb, Decl(three.ts, 47, 45)) +>setTimeout : Symbol(setTimeout, Decl(lib.dom.d.ts, --, --)) +>cb : Symbol(cb, Decl(three.ts, 47, 45)) + +], (error, results) => { +>error : Symbol(error, Decl(three.ts, 49, 4)) +>results : Symbol(results, Decl(three.ts, 49, 10)) + + if (error) { +>error : Symbol(error, Decl(three.ts, 49, 4)) + + console.error(error) +>console.error : Symbol(Console.error, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>error : Symbol(Console.error, Decl(lib.dom.d.ts, --, --)) +>error : Symbol(error, Decl(three.ts, 49, 4)) + + } else { + console.log(results) +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>results : Symbol(results, Decl(three.ts, 49, 10)) + } +}) diff --git a/tests/baselines/reference/contextualOverloadListFromArrayUnion.types b/tests/baselines/reference/contextualOverloadListFromArrayUnion.types index d9a04a37bfffc..497df387b5c0a 100644 --- a/tests/baselines/reference/contextualOverloadListFromArrayUnion.types +++ b/tests/baselines/reference/contextualOverloadListFromArrayUnion.types @@ -30,3 +30,182 @@ export const yThen = y.map(item => item.length); >item : string | number[] >length : number +=== tests/cases/compiler/three.ts === +// #42504 +interface ResizeObserverCallback { + (entries: ResizeObserverEntry[], observer: ResizeObserver): void; +>entries : ResizeObserverEntry[] +>observer : ResizeObserver +} +interface ResizeObserverCallback { // duplicate for effect + (entries: ResizeObserverEntry[], observer: ResizeObserver): void; +>entries : ResizeObserverEntry[] +>observer : ResizeObserver +} + +const resizeObserver = new ResizeObserver(([entry]) => { +>resizeObserver : ResizeObserver +>new ResizeObserver(([entry]) => { entry}) : ResizeObserver +>ResizeObserver : { new (callback: globalThis.ResizeObserverCallback): ResizeObserver; prototype: ResizeObserver; } +>([entry]) => { entry} : ([entry]: ResizeObserverEntry[]) => void +>entry : ResizeObserverEntry + + entry +>entry : ResizeObserverEntry + +}); +// comment in #35501 +interface Callback { + (error: null, result: T): unknown +>error : null +>null : null +>result : T + + (error: Error, result: null): unknown +>error : Error +>result : null +>null : null +} + +interface Task { + (callback: Callback): unknown +>callback : Callback +} + +export function series(tasks: Task[], callback: Callback): void { +>series : (tasks: Task[], callback: Callback) => void +>tasks : Task[] +>callback : Callback + + let index = 0 +>index : number +>0 : 0 + + let results: T[] = [] +>results : T[] +>[] : never[] + + function next() { +>next : () => void + + let task = tasks[index] +>task : Task +>tasks[index] : Task +>tasks : Task[] +>index : number + + if (!task) { +>!task : false +>task : Task + + callback(null, results) +>callback(null, results) : unknown +>callback : Callback +>null : null +>results : T[] + + } else { + task((error, result) => { +>task((error, result) => { if (error) { callback(error, null) } else { // must use postfix-!, since `error` and `result` don't have a // causal relationship when the overloads are combined results.push(result!) next() } }) : unknown +>task : Task +>(error, result) => { if (error) { callback(error, null) } else { // must use postfix-!, since `error` and `result` don't have a // causal relationship when the overloads are combined results.push(result!) next() } } : (error: Error | null, result: T | null) => void +>error : Error | null +>result : T | null + + if (error) { +>error : Error | null + + callback(error, null) +>callback(error, null) : unknown +>callback : Callback +>error : Error +>null : null + + } else { + // must use postfix-!, since `error` and `result` don't have a + // causal relationship when the overloads are combined + results.push(result!) +>results.push(result!) : number +>results.push : (...items: T[]) => number +>results : T[] +>push : (...items: T[]) => number +>result! : NonNullable +>result : T | null + + next() +>next() : void +>next : () => void + } + }) + } + } + next() +>next() : void +>next : () => void +} + +series([ +>series([ cb => setTimeout(() => cb(null, 1), 300), cb => setTimeout(() => cb(null, 2), 200), cb => setTimeout(() => cb(null, 3), 100),], (error, results) => { if (error) { console.error(error) } else { console.log(results) }}) : void +>series : (tasks: Task[], callback: Callback) => void +>[ cb => setTimeout(() => cb(null, 1), 300), cb => setTimeout(() => cb(null, 2), 200), cb => setTimeout(() => cb(null, 3), 100),] : ((cb: Callback) => number)[] + + cb => setTimeout(() => cb(null, 1), 300), +>cb => setTimeout(() => cb(null, 1), 300) : (cb: Callback) => number +>cb : Callback +>setTimeout(() => cb(null, 1), 300) : number +>setTimeout : (handler: TimerHandler, timeout?: number | undefined, ...arguments: any[]) => number +>() => cb(null, 1) : () => unknown +>cb(null, 1) : unknown +>cb : Callback +>null : null +>1 : 1 +>300 : 300 + + cb => setTimeout(() => cb(null, 2), 200), +>cb => setTimeout(() => cb(null, 2), 200) : (cb: Callback) => number +>cb : Callback +>setTimeout(() => cb(null, 2), 200) : number +>setTimeout : (handler: TimerHandler, timeout?: number | undefined, ...arguments: any[]) => number +>() => cb(null, 2) : () => unknown +>cb(null, 2) : unknown +>cb : Callback +>null : null +>2 : 2 +>200 : 200 + + cb => setTimeout(() => cb(null, 3), 100), +>cb => setTimeout(() => cb(null, 3), 100) : (cb: Callback) => number +>cb : Callback +>setTimeout(() => cb(null, 3), 100) : number +>setTimeout : (handler: TimerHandler, timeout?: number | undefined, ...arguments: any[]) => number +>() => cb(null, 3) : () => unknown +>cb(null, 3) : unknown +>cb : Callback +>null : null +>3 : 3 +>100 : 100 + +], (error, results) => { +>(error, results) => { if (error) { console.error(error) } else { console.log(results) }} : (error: Error | null, results: unknown[] | null) => void +>error : Error | null +>results : unknown[] | null + + if (error) { +>error : Error | null + + console.error(error) +>console.error(error) : void +>console.error : (...data: any[]) => void +>console : Console +>error : (...data: any[]) => void +>error : Error + + } else { + console.log(results) +>console.log(results) : void +>console.log : (...data: any[]) => void +>console : Console +>log : (...data: any[]) => void +>results : unknown[] | null + } +}) diff --git a/tests/cases/compiler/contextualOverloadListFromArrayUnion.ts b/tests/cases/compiler/contextualOverloadListFromArrayUnion.ts index 876324d24d7de..eb0d45ef43504 100644 --- a/tests/cases/compiler/contextualOverloadListFromArrayUnion.ts +++ b/tests/cases/compiler/contextualOverloadListFromArrayUnion.ts @@ -1,7 +1,65 @@ // @strict: true +// @target: es6 // @filename: one.ts declare const y: never[] | string[]; export const yThen = y.map(item => item.length); // @filename: two.ts declare const y: number[][] | string[]; export const yThen = y.map(item => item.length); +// @filename: three.ts +// #42504 +interface ResizeObserverCallback { + (entries: ResizeObserverEntry[], observer: ResizeObserver): void; +} +interface ResizeObserverCallback { // duplicate for effect + (entries: ResizeObserverEntry[], observer: ResizeObserver): void; +} + +const resizeObserver = new ResizeObserver(([entry]) => { + entry +}); +// comment in #35501 +interface Callback { + (error: null, result: T): unknown + (error: Error, result: null): unknown +} + +interface Task { + (callback: Callback): unknown +} + +export function series(tasks: Task[], callback: Callback): void { + let index = 0 + let results: T[] = [] + + function next() { + let task = tasks[index] + if (!task) { + callback(null, results) + } else { + task((error, result) => { + if (error) { + callback(error, null) + } else { + // must use postfix-!, since `error` and `result` don't have a + // causal relationship when the overloads are combined + results.push(result!) + next() + } + }) + } + } + next() +} + +series([ + cb => setTimeout(() => cb(null, 1), 300), + cb => setTimeout(() => cb(null, 2), 200), + cb => setTimeout(() => cb(null, 3), 100), +], (error, results) => { + if (error) { + console.error(error) + } else { + console.log(results) + } +})