Uncalled function checks check negation condition

src/compiler/checker.ts

@@ -42919,7 +42919,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         }
 
         function helper(condExpr: Expression, body: Expression | Statement | undefined) {
-            const location = isLogicalOrCoalescingBinaryExpression(condExpr) ? skipParentheses(condExpr.right) : condExpr;
+            const location = isLogicalOrCoalescingBinaryExpression(condExpr) ? skipParentheses(condExpr.right)
+                : isPrefixUnaryExpression(condExpr) ? condExpr.operand
+                : condExpr;
             if (isModuleExportsAccessExpression(location)) {
                 return;
             }
@@ -42936,7 +42938,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             // the block as a heuristic to identify the most common bugs. There
             // are too many false positives for values sourced from type
             // definitions without strictNullChecks otherwise.
-            const callSignatures = getSignaturesOfType(type, SignatureKind.Call);
+            const testedType = isPrefixUnaryExpression(condExpr) ? checkExpression(location) : type;
+            const callSignatures = getSignaturesOfType(testedType, SignatureKind.Call);
             const isPromise = !!getAwaitedTypeOfPromise(type);
             if (callSignatures.length === 0 && !isPromise) {
                 return;

src/compiler/moduleSpecifiers.ts

@@ -996,7 +996,7 @@ function tryGetModuleNameFromRootDirs(rootDirs: readonly string[], moduleFileNam
 }
 
 function tryGetModuleNameAsNodeModule({ path, isRedirect }: ModulePath, { getCanonicalFileName, canonicalSourceDirectory }: Info, importingSourceFile: SourceFile, host: ModuleSpecifierResolutionHost, options: CompilerOptions, userPreferences: UserPreferences, packageNameOnly?: boolean, overrideMode?: ResolutionMode): string | undefined {
-    if (!host.fileExists || !host.readFile) {
+    if (!host.readFile) {
         return undefined;
     }
     const parts: NodeModulePathParts = getNodeModulePathParts(path)!;
@@ -1145,7 +1145,6 @@ function tryGetModuleNameAsNodeModule({ path, isRedirect }: ModulePath, { getCan
 }
 
 function tryGetAnyFileFromPath(host: ModuleSpecifierResolutionHost, path: string) {
-    if (!host.fileExists) return;
     // We check all js, `node` and `json` extensions in addition to TS, since node module resolution would also choose those over the directory
     const extensions = flatten(getSupportedExtensions({ allowJs: true }, [{ extension: "node", isMixedContent: false }, { extension: "json", isMixedContent: false, scriptKind: ScriptKind.JSON }]));
     for (const e of extensions) {

src/compiler/sys.ts

@@ -131,9 +131,6 @@ let pollingChunkSize = createPollingIntervalBasedLevels(defaultChunkLevels);
 export let unchangedPollThresholds = createPollingIntervalBasedLevels(defaultChunkLevels);
 
 function setCustomPollingValues(system: System) {
-    if (!system.getEnvironmentVariable) {
-        return;
-    }
     const pollingIntervalChanged = setCustomLevels("TSC_WATCH_POLLINGINTERVAL", PollingInterval);
     pollingChunkSize = getCustomPollingBasedLevels("TSC_WATCH_POLLINGCHUNKSIZE", defaultChunkLevels) || pollingChunkSize;
     unchangedPollThresholds = getCustomPollingBasedLevels("TSC_WATCH_UNCHANGEDPOLLTHRESHOLDS", defaultChunkLevels) || unchangedPollThresholds;

src/services/stringCompletions.ts

@@ -1182,8 +1182,6 @@ function getCompletionEntriesFromTypings(host: LanguageServiceHost, options: Com
 }
 
 function enumerateNodeModulesVisibleToScript(host: LanguageServiceHost, scriptPath: string): readonly string[] {
-    if (!host.readFile || !host.fileExists) return emptyArray;
-
     const result: string[] = [];
     for (const packageJson of findPackageJsons(scriptPath, host)) {
         const contents = readJson(packageJson, host as { readFile: (filename: string) => string | undefined; }); // Cast to assert that readFile is defined

src/services/utilities.ts

@@ -3670,10 +3670,6 @@ export function findPackageJson(directory: string, host: LanguageServiceHost): s
 
 /** @internal */
 export function getPackageJsonsVisibleToFile(fileName: string, host: LanguageServiceHost): readonly ProjectPackageJsonInfo[] {
-    if (!host.fileExists) {
-        return [];
-    }
-
     const packageJsons: ProjectPackageJsonInfo[] = [];
     forEachAncestorDirectory(getDirectoryPath(fileName), ancestor => {
         const packageJsonFileName = combinePaths(ancestor, "package.json");

tests/baselines/reference/contextualOverloadListFromArrayUnion.errors.txt

@@ -0,0 +1,69 @@
+three.ts(28,14): error TS2774: This condition will always return true since this function is always defined. Did you mean to call it instead?
+
+
+==== one.ts (0 errors) ====
+    declare const y: never[] | string[];
+    export const yThen = y.map(item => item.length);
+==== two.ts (0 errors) ====
+    declare const y: number[][] | string[];
+    export const yThen = y.map(item => item.length);
+==== three.ts (1 errors) ====
+    // #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<T> {
+        (error: null, result: T): unknown
+        (error: Error, result: null): unknown
+    }
+
+    interface Task<T> {
+        (callback: Callback<T>): unknown
+    }
+
+    export function series<T>(tasks: Task<T>[], callback: Callback<T[]>): void {
+        let index = 0
+        let results: T[] = []
+
+        function next() {
+            let task = tasks[index]
+            if (!task) {
+                 ~~~~
+!!! error TS2774: This condition will always return true since this function is always defined. Did you mean to call it instead?
+                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)
+        }
+    })
+

tests/baselines/reference/uncalledFunctionChecksInConditional.errors.txt

@@ -1,17 +1,22 @@
-uncalledFunctionChecksInConditional.ts(5,5): error TS2774: This condition will always return true since this function is always defined. Did you mean to call it instead?
-uncalledFunctionChecksInConditional.ts(9,5): error TS2774: This condition will always return true since this function is always defined. Did you mean to call it instead?
-uncalledFunctionChecksInConditional.ts(9,14): error TS2774: This condition will always return true since this function is always defined. Did you mean to call it instead?
-uncalledFunctionChecksInConditional.ts(13,5): error TS2774: This condition will always return true since this function is always defined. Did you mean to call it instead?
-uncalledFunctionChecksInConditional.ts(32,10): error TS2774: This condition will always return true since this function is always defined. Did you mean to call it instead?
-uncalledFunctionChecksInConditional.ts(36,5): error TS2774: This condition will always return true since this function is always defined. Did you mean to call it instead?
-uncalledFunctionChecksInConditional.ts(40,22): error TS2774: This condition will always return true since this function is always defined. Did you mean to call it instead?
-uncalledFunctionChecksInConditional.ts(44,16): error TS2774: This condition will always return true since this function is always defined. Did you mean to call it instead?
-uncalledFunctionChecksInConditional.ts(48,22): error TS2774: This condition will always return true since this function is always defined. Did you mean to call it instead?
+uncalledFunctionChecksInConditional.ts(6,5): error TS2774: This condition will always return true since this function is always defined. Did you mean to call it instead?
+uncalledFunctionChecksInConditional.ts(10,5): error TS2774: This condition will always return true since this function is always defined. Did you mean to call it instead?
+uncalledFunctionChecksInConditional.ts(10,14): error TS2774: This condition will always return true since this function is always defined. Did you mean to call it instead?
+uncalledFunctionChecksInConditional.ts(14,5): error TS2774: This condition will always return true since this function is always defined. Did you mean to call it instead?
+uncalledFunctionChecksInConditional.ts(33,10): error TS2774: This condition will always return true since this function is always defined. Did you mean to call it instead?
+uncalledFunctionChecksInConditional.ts(37,5): error TS2774: This condition will always return true since this function is always defined. Did you mean to call it instead?
+uncalledFunctionChecksInConditional.ts(41,22): error TS2774: This condition will always return true since this function is always defined. Did you mean to call it instead?
+uncalledFunctionChecksInConditional.ts(45,16): error TS2774: This condition will always return true since this function is always defined. Did you mean to call it instead?
+uncalledFunctionChecksInConditional.ts(49,22): error TS2774: This condition will always return true since this function is always defined. Did you mean to call it instead?
+uncalledFunctionChecksInConditional.ts(58,6): error TS2774: This condition will always return true since this function is always defined. Did you mean to call it instead?
+uncalledFunctionChecksInConditional.ts(62,6): error TS2774: This condition will always return true since this function is always defined. Did you mean to call it instead?
+uncalledFunctionChecksInConditional.ts(66,6): error TS2801: This condition will always return true since this 'Promise<boolean | undefined>' is always defined.
+uncalledFunctionChecksInConditional.ts(74,6): error TS2774: This condition will always return true since this function is always defined. Did you mean to call it instead?
 
 
-==== uncalledFunctionChecksInConditional.ts (9 errors) ====
+==== uncalledFunctionChecksInConditional.ts (13 errors) ====
     declare function isFoo(): boolean;
     declare function isBar(): boolean;
+    declare function isFooPromise(): Promise<boolean | undefined>;
     declare const isUndefinedFoo: (() => boolean) | undefined;
 
     if (isFoo) {
@@ -82,4 +87,33 @@ uncalledFunctionChecksInConditional.ts(48,22): error TS2774: This condition will
     if (x && z) {
         // no error
         z();
+    }
+
+    if (!isFoo) {
+         ~~~~~
+!!! error TS2774: This condition will always return true since this function is always defined. Did you mean to call it instead?
+        // error on isFoo
+    }
+
+    if (!isFoo || !isFoo()) {
+         ~~~~~
+!!! error TS2774: This condition will always return true since this function is always defined. Did you mean to call it instead?
+        // error on isFoo
+    }
+
+    if (!isFooPromise()) {
+         ~~~~~~~~~~~~~~
+!!! error TS2801: This condition will always return true since this 'Promise<boolean | undefined>' is always defined.
+!!! related TS2773 uncalledFunctionChecksInConditional.ts:66:6: Did you forget to use 'await'?
+        // ts2801 error on isFooPromise
+    }
+
+    if (!isUndefinedFoo) {
+        // no error
+    }
+
+    if (!isFooPromise) {
+         ~~~~~~~~~~~~
+!!! error TS2774: This condition will always return true since this function is always defined. Did you mean to call it instead?
+        // error on isFooPromise
     }

tests/baselines/reference/uncalledFunctionChecksInConditional.js

@@ -3,6 +3,7 @@
 //// [uncalledFunctionChecksInConditional.ts]
 declare function isFoo(): boolean;
 declare function isBar(): boolean;
+declare function isFooPromise(): Promise<boolean | undefined>;
 declare const isUndefinedFoo: (() => boolean) | undefined;
 
 if (isFoo) {
@@ -55,6 +56,26 @@ if (ux || y || uz || isFoo) {
 if (x && z) {
     // no error
     z();
+}
+
+if (!isFoo) {
+    // error on isFoo
+}
+
+if (!isFoo || !isFoo()) {
+    // error on isFoo
+}
+
+if (!isFooPromise()) {
+    // ts2801 error on isFooPromise
+}
+
+if (!isUndefinedFoo) {
+    // no error
+}
+
+if (!isFooPromise) {
+    // error on isFooPromise
 }
 
 //// [uncalledFunctionChecksInConditional.js]
@@ -92,3 +113,18 @@ if (x && z) {
     // no error
     z();
 }
+if (!isFoo) {
+    // error on isFoo
+}
+if (!isFoo || !isFoo()) {
+    // error on isFoo
+}
+if (!isFooPromise()) {
+    // ts2801 error on isFooPromise
+}
+if (!isUndefinedFoo) {
+    // no error
+}
+if (!isFooPromise) {
+    // error on isFooPromise
+}