removed BooleanConverter, using BooleanConstructor instead. Updated tests results for that.

Author: craigphicks

meldlocal.js

@@ -0,0 +1,114 @@
+/* eslint-disable @typescript-eslint/quotes */
+const cp = require("child_process");
+//const fs = require("fs/promises");
+const fs = require("fs");
+const path = require("path");
+const readlinem = require("readline");
+const dir = "tests/baselines/local/";
+
+function escapeRegExp1(text) {
+    return Array.from(text)
+           .map(char => `\\u{${char.charCodeAt(0).toString(16)}}`)
+           .join('');
+}
+function escapeRegExp2(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
+}
+
+
+let idx = 2;
+let interactiveAccept = false;
+if (process.argv[idx]==="-i"){
+    interactiveAccept = true;
+    idx++;
+}
+
+// eslint-disable-next-line prefer-const
+let basefilts = process.argv.slice(idx);
+//basefilts = basefilts.map(filt=>escapeRegExp2(filt));
+console.log(`basefilt: [${basefilts.length}] ${basefilts}`);
+basefilts.forEach((b,idx)=>{
+    console.log(`baseline[${idx}]: ${b}, re.source: ${(new RegExp(b)).source}, re: ${new RegExp(b)}`);
+});
+
+function askUser(question) {
+    const readline = readlinem.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise(resolve => {
+        readline.question(question, (ans) => {
+            readline.close();
+            resolve(ans);
+        });
+    });
+}
+
+async function main(){
+    const arrdirent = await fs.promises.readdir(dir,{ withFileTypes:true });
+    arrdirent.forEach(de=>{
+        if (de.isFile()){
+            console.log(`de.name:${de.name}`);
+        }
+        else console.log(`de.name:${de.name} (dir)`);
+    });
+    arrdirent.reduce(async (promise,de)=>{
+        await promise;
+        if (de.isFile()){
+            // if (!basefilts.every(filt=>de.name.includes(filt))) return;
+            if (!basefilts.every(filt=>{
+                const re = new RegExp(filt);
+                const tmp = de.name+"";
+                return tmp.match(re);
+            })) return;
+            if (de.name.endsWith(".symbols")) return;
+            console.log(`de.name:${de.name}`);
+            const right = dir+de.name;
+            let left = right.replace("local","reference");
+            if (left.endsWith("errors.txt.delete")){
+                left = left.replace("errors.txt.delete","errors.txt");
+            }
+            const cmd = `meld ${left} ${right}`;
+            console.log(cmd);
+            cp.execSync(cmd);
+            if (interactiveAccept && path.extname(de.name)===".types"){
+                const accept = await askUser(`accept into baseline? Ny (${path.basename(de.name)})`);
+                if (accept!=="y"){
+                    console.log(`not accepting ${de.name}`);
+                }
+                else {
+                    console.log(`accepting ${de.name}`);
+                    await fs.promises.copyFile(right,left);
+                    console.log(`copy ${right} -> ${left} success`);
+
+                    const jsFile = right.replace(".types",".js");
+                    if (fs.existsSync(jsFile)){
+                        const jsFileLeft = left.replace(".types",".js");
+                        await fs.promises.copyFile(jsFile,jsFileLeft);
+                        console.log(`copy ${jsFile} -> ${jsFileLeft} success`);
+                    }
+
+                    const symbolsFile = right.replace(".types",".symbols");
+                    if (fs.existsSync(symbolsFile)){
+                        const symbolsFileLeft = left.replace(".types",".symbols");
+                        await fs.promises.copyFile(symbolsFile,symbolsFileLeft);
+                        console.log(`copy ${symbolsFile} -> ${symbolsFileLeft} success`);
+                    }
+                    const errorsFile = right.replace(".types",".errors.txt");
+                    if (fs.existsSync(errorsFile)){
+                        const errorsFileLeft = left.replace(".types",".errors.txt");
+                        await fs.promises.copyFile(errorsFile,errorsFileLeft);
+                        console.log(`copy ${errorsFile} -> ${errorsFileLeft} success`);
+                    }
+                }
+            }
+        }
+    }, Promise.resolve());
+}
+
+main()
+.then(()=>{ console.log("done");})
+.catch(err=>{ console.log(err); });
+
+
+

src/harness/fourslashInterfaceImpl.ts

@@ -1123,7 +1123,6 @@ export namespace Completion {
         interfaceEntry("StringConstructor"),
         varEntry("Boolean"),
         interfaceEntry("BooleanConstructor"),
-        interfaceEntry("BooleanConverter"),
         varEntry("Number"),
         interfaceEntry("NumberConstructor"),
         interfaceEntry("TemplateStringsArray"),

src/lib/es5.d.ts

@@ -536,11 +536,6 @@ interface BooleanConstructor {
     readonly prototype: Boolean;
 }
 
-interface BooleanConverter {
-    <T>(value?: T): boolean;
-    readonly prototype: Boolean;
-}
-
 declare var Boolean: BooleanConstructor;
 
 interface Number {
@@ -1267,7 +1262,7 @@ interface ReadonlyArray<T> {
      * @param predicate Must be exactly "Boolean"
      * @param thisArg An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.
      */
-    filter(predicate: BooleanConverter, thisArg?: any): (T extends false | 0 | "" | null | undefined | 0n ? never : T)[];
+    filter(predicate: BooleanConstructor, thisArg?: any): (T extends false | 0 | "" | null | undefined | 0n ? never : T)[];
     /**
      * Returns the elements of an array that meet the condition specified in a callback function.
      * @param predicate A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.
@@ -1464,7 +1459,7 @@ interface Array<T> {
      * @param predicate Must be exactly "Boolean"
      * @param thisArg An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.
      */
-    filter(predicate: BooleanConverter, thisArg?: any): (T extends false | 0 | "" | null | undefined | 0n ? never : T)[];
+    filter(predicate: BooleanConstructor, thisArg?: any): (T extends false | 0 | "" | null | undefined | 0n ? never : T)[];
     /**
      * Returns the elements of an array that meet the condition specified in a callback function.
      * @param predicate A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.

tests/baselines/reference/arrayFilter.types

@@ -23,9 +23,9 @@ var foo = [
 
 foo.filter(x => x.name); //should accepted all possible types not only boolean! 
 >foo.filter(x => x.name) : { name: string; }[]
->foo.filter : { <S extends { name: string; }>(predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConverter, thisArg?: any): { name: string; }[]; (predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => unknown, thisArg?: any): { name: string; }[]; }
+>foo.filter : { <S extends { name: string; }>(predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConstructor, thisArg?: any): { name: string; }[]; (predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => unknown, thisArg?: any): { name: string; }[]; }
 >foo : { name: string; }[]
->filter : { <S extends { name: string; }>(predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConverter, thisArg?: any): { name: string; }[]; (predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => unknown, thisArg?: any): { name: string; }[]; }
+>filter : { <S extends { name: string; }>(predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConstructor, thisArg?: any): { name: string; }[]; (predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => unknown, thisArg?: any): { name: string; }[]; }
 >x => x.name : (x: { name: string; }) => string
 >x : { name: string; }
 >x.name : string

tests/baselines/reference/arrayFilterBooleanOverload.types

@@ -10,18 +10,18 @@ const nullableValues = ['a', 'b', null]; // expect (string | null)[]
 const values1 = nullableValues.filter(Boolean); // expect string[]
 >values1 : string[]
 >nullableValues.filter(Boolean) : string[]
->nullableValues.filter : { <S extends string | null>(predicate: (value: string | null, index: number, array: (string | null)[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConverter, thisArg?: any): string[]; (predicate: (value: string | null, index: number, array: (string | null)[]) => unknown, thisArg?: any): (string | null)[]; }
+>nullableValues.filter : { <S extends string | null>(predicate: (value: string | null, index: number, array: (string | null)[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConstructor, thisArg?: any): string[]; (predicate: (value: string | null, index: number, array: (string | null)[]) => unknown, thisArg?: any): (string | null)[]; }
 >nullableValues : (string | null)[]
->filter : { <S extends string | null>(predicate: (value: string | null, index: number, array: (string | null)[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConverter, thisArg?: any): string[]; (predicate: (value: string | null, index: number, array: (string | null)[]) => unknown, thisArg?: any): (string | null)[]; }
+>filter : { <S extends string | null>(predicate: (value: string | null, index: number, array: (string | null)[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConstructor, thisArg?: any): string[]; (predicate: (value: string | null, index: number, array: (string | null)[]) => unknown, thisArg?: any): (string | null)[]; }
 >Boolean : BooleanConstructor
 
 // @ts-expect-error
 const values2 = nullableValues.filter(new Boolean);
 >values2 : (string | null)[]
 >nullableValues.filter(new Boolean) : (string | null)[]
->nullableValues.filter : { <S extends string | null>(predicate: (value: string | null, index: number, array: (string | null)[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConverter, thisArg?: any): string[]; (predicate: (value: string | null, index: number, array: (string | null)[]) => unknown, thisArg?: any): (string | null)[]; }
+>nullableValues.filter : { <S extends string | null>(predicate: (value: string | null, index: number, array: (string | null)[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConstructor, thisArg?: any): string[]; (predicate: (value: string | null, index: number, array: (string | null)[]) => unknown, thisArg?: any): (string | null)[]; }
 >nullableValues : (string | null)[]
->filter : { <S extends string | null>(predicate: (value: string | null, index: number, array: (string | null)[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConverter, thisArg?: any): string[]; (predicate: (value: string | null, index: number, array: (string | null)[]) => unknown, thisArg?: any): (string | null)[]; }
+>filter : { <S extends string | null>(predicate: (value: string | null, index: number, array: (string | null)[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConstructor, thisArg?: any): string[]; (predicate: (value: string | null, index: number, array: (string | null)[]) => unknown, thisArg?: any): (string | null)[]; }
 >new Boolean : Boolean
 >Boolean : BooleanConstructor
 
@@ -37,9 +37,9 @@ const arr = [0, 1, "", "foo", null] as const;
 const arr2 = arr.filter(Boolean); // expect ("foo" | 1)[]
 >arr2 : (1 | "foo")[]
 >arr.filter(Boolean) : (1 | "foo")[]
->arr.filter : { <S extends "" | 0 | 1 | "foo" | null>(predicate: (value: "" | 0 | 1 | "foo" | null, index: number, array: readonly ("" | 0 | 1 | "foo" | null)[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConverter, thisArg?: any): (1 | "foo")[]; (predicate: (value: "" | 0 | 1 | "foo" | null, index: number, array: readonly ("" | 0 | 1 | "foo" | null)[]) => unknown, thisArg?: any): ("" | 0 | 1 | "foo" | null)[]; }
+>arr.filter : { <S extends "" | 0 | 1 | "foo" | null>(predicate: (value: "" | 0 | 1 | "foo" | null, index: number, array: readonly ("" | 0 | 1 | "foo" | null)[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConstructor, thisArg?: any): (1 | "foo")[]; (predicate: (value: "" | 0 | 1 | "foo" | null, index: number, array: readonly ("" | 0 | 1 | "foo" | null)[]) => unknown, thisArg?: any): ("" | 0 | 1 | "foo" | null)[]; }
 >arr : readonly [0, 1, "", "foo", null]
->filter : { <S extends "" | 0 | 1 | "foo" | null>(predicate: (value: "" | 0 | 1 | "foo" | null, index: number, array: readonly ("" | 0 | 1 | "foo" | null)[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConverter, thisArg?: any): (1 | "foo")[]; (predicate: (value: "" | 0 | 1 | "foo" | null, index: number, array: readonly ("" | 0 | 1 | "foo" | null)[]) => unknown, thisArg?: any): ("" | 0 | 1 | "foo" | null)[]; }
+>filter : { <S extends "" | 0 | 1 | "foo" | null>(predicate: (value: "" | 0 | 1 | "foo" | null, index: number, array: readonly ("" | 0 | 1 | "foo" | null)[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConstructor, thisArg?: any): (1 | "foo")[]; (predicate: (value: "" | 0 | 1 | "foo" | null, index: number, array: readonly ("" | 0 | 1 | "foo" | null)[]) => unknown, thisArg?: any): ("" | 0 | 1 | "foo" | null)[]; }
 >Boolean : BooleanConstructor
 
 

tests/baselines/reference/booleanFilterAnyArray.types

@@ -47,9 +47,9 @@ var ys: any[];
 var ys = realanys.filter(Boolean)
 >ys : any[]
 >realanys.filter(Boolean) : any[]
->realanys.filter : { <S extends any>(predicate: (value: any, index: number, array: any[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConverter, thisArg?: any): any[]; (predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any): any[]; }
+>realanys.filter : { <S extends any>(predicate: (value: any, index: number, array: any[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConstructor, thisArg?: any): any[]; (predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any): any[]; }
 >realanys : any[]
->filter : { <S extends any>(predicate: (value: any, index: number, array: any[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConverter, thisArg?: any): any[]; (predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any): any[]; }
+>filter : { <S extends any>(predicate: (value: any, index: number, array: any[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConstructor, thisArg?: any): any[]; (predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any): any[]; }
 >Boolean : BooleanConstructor
 
 var foo = [{ name: 'x' }]
@@ -66,9 +66,9 @@ var foor: Array<{name: string}>
 var foor = foo.filter(x => x.name)
 >foor : { name: string; }[]
 >foo.filter(x => x.name) : { name: string; }[]
->foo.filter : { <S extends { name: string; }>(predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConverter, thisArg?: any): { name: string; }[]; (predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => unknown, thisArg?: any): { name: string; }[]; }
+>foo.filter : { <S extends { name: string; }>(predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConstructor, thisArg?: any): { name: string; }[]; (predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => unknown, thisArg?: any): { name: string; }[]; }
 >foo : { name: string; }[]
->filter : { <S extends { name: string; }>(predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConverter, thisArg?: any): { name: string; }[]; (predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => unknown, thisArg?: any): { name: string; }[]; }
+>filter : { <S extends { name: string; }>(predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConstructor, thisArg?: any): { name: string; }[]; (predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => unknown, thisArg?: any): { name: string; }[]; }
 >x => x.name : (x: { name: string; }) => string
 >x : { name: string; }
 >x.name : string
@@ -81,12 +81,12 @@ var foos: Array<boolean>
 var foos = [true, true, false, null].filter((thing): thing is boolean => thing !== null)
 >foos : boolean[]
 >[true, true, false, null].filter((thing): thing is boolean => thing !== null) : boolean[]
->[true, true, false, null].filter : { <S extends boolean>(predicate: (value: boolean, index: number, array: boolean[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConverter, thisArg?: any): true[]; (predicate: (value: boolean, index: number, array: boolean[]) => unknown, thisArg?: any): boolean[]; }
+>[true, true, false, null].filter : { <S extends boolean>(predicate: (value: boolean, index: number, array: boolean[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConstructor, thisArg?: any): true[]; (predicate: (value: boolean, index: number, array: boolean[]) => unknown, thisArg?: any): boolean[]; }
 >[true, true, false, null] : boolean[]
 >true : true
 >true : true
 >false : false
->filter : { <S extends boolean>(predicate: (value: boolean, index: number, array: boolean[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConverter, thisArg?: any): true[]; (predicate: (value: boolean, index: number, array: boolean[]) => unknown, thisArg?: any): boolean[]; }
+>filter : { <S extends boolean>(predicate: (value: boolean, index: number, array: boolean[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConstructor, thisArg?: any): true[]; (predicate: (value: boolean, index: number, array: boolean[]) => unknown, thisArg?: any): boolean[]; }
 >(thing): thing is boolean => thing !== null : (thing: boolean) => thing is boolean
 >thing : boolean
 >thing !== null : boolean

tests/baselines/reference/contextuallyTypeAsyncFunctionReturnType.types

@@ -211,11 +211,11 @@ async function copyExtensions(
 >fromExtensions        .filter((e) => !e.isApplicationScoped)        .map(async (e) => [e, await scanMetadata(e)]) : Promise<[ILocalExtension, Metadata]>[]
 >fromExtensions        .filter((e) => !e.isApplicationScoped)        .map : <U>(callbackfn: (value: ILocalExtension, index: number, array: ILocalExtension[]) => U, thisArg?: any) => U[]
 >fromExtensions        .filter((e) => !e.isApplicationScoped) : ILocalExtension[]
->fromExtensions        .filter : { <S extends ILocalExtension>(predicate: (value: ILocalExtension, index: number, array: ILocalExtension[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConverter, thisArg?: any): ILocalExtension[]; (predicate: (value: ILocalExtension, index: number, array: ILocalExtension[]) => unknown, thisArg?: any): ILocalExtension[]; }
+>fromExtensions        .filter : { <S extends ILocalExtension>(predicate: (value: ILocalExtension, index: number, array: ILocalExtension[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConstructor, thisArg?: any): ILocalExtension[]; (predicate: (value: ILocalExtension, index: number, array: ILocalExtension[]) => unknown, thisArg?: any): ILocalExtension[]; }
 >fromExtensions : ILocalExtension[]
 
         .filter((e) => !e.isApplicationScoped)
->filter : { <S extends ILocalExtension>(predicate: (value: ILocalExtension, index: number, array: ILocalExtension[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConverter, thisArg?: any): ILocalExtension[]; (predicate: (value: ILocalExtension, index: number, array: ILocalExtension[]) => unknown, thisArg?: any): ILocalExtension[]; }
+>filter : { <S extends ILocalExtension>(predicate: (value: ILocalExtension, index: number, array: ILocalExtension[]) => value is S, thisArg?: any): S[]; (predicate: BooleanConstructor, thisArg?: any): ILocalExtension[]; (predicate: (value: ILocalExtension, index: number, array: ILocalExtension[]) => unknown, thisArg?: any): ILocalExtension[]; }
 >(e) => !e.isApplicationScoped : (e: ILocalExtension) => boolean
 >e : ILocalExtension
 >!e.isApplicationScoped : boolean