Avoid NoReturn analysis for Any or Unknown calls

packages/pyright-internal/src/analyzer/codeFlowEngine.ts

@@ -48,6 +48,7 @@ import {
     ClassType,
     combineTypes,
     FunctionType,
+    isAnyOrUnknown,
     isClass,
     isClassInstance,
     isFunction,
@@ -59,6 +60,7 @@ import {
     isTypeSame,
     isTypeVar,
     isTypeVarTuple,
+    isUnion,
     maxTypeRecursionCount,
     NeverType,
     OverloadedType,
@@ -1772,17 +1774,24 @@ export function getCodeFlowEngine(
             const callTypeResult = evaluator.getTypeOfExpression(node.d.leftExpr, EvalFlags.CallBaseDefaults);
             const callType = callTypeResult.type;
 
-            doForEachSubtype(callType, (callSubtype) => {
+            const callSubtypes = isUnion(callType) ? callType.priv.subtypes : [callType];
+            for (let callSubtype of callSubtypes) {
                 // Track the number of subtypes we've examined.
                 subtypeCount++;
 
+                // Any or Unknown can never establish a guaranteed NoReturn result, so any
+                // union containing either is immediately a negative answer.
+                if (isAnyOrUnknown(callSubtype)) {
+                    return false;
+                }
+
                 if (isInstantiableClass(callSubtype)) {
                     // Does the class have a custom metaclass that implements a `__call__` method?
                     // If so, it will be called instead of `__init__` or `__new__`. We'll assume
                     // in this case that the __call__ method is not a NoReturn type.
                     const metaclassCallResult = getBoundCallMethod(evaluator, node, callSubtype);
                     if (metaclassCallResult) {
-                        return;
+                        continue;
                     }
 
                     const newMethodResult = getBoundNewMethod(evaluator, node, callSubtype);
@@ -1839,7 +1848,7 @@ export function getCodeFlowEngine(
                         }
                     }
                 }
-            });
+            }
 
             // The call is considered NoReturn if all subtypes evaluate to NoReturn.
             const callIsNoReturn = subtypeCount > 0 && noReturnTypeCount === subtypeCount;

packages/pyright-internal/src/tests/samples/unreachable1.py

@@ -3,7 +3,7 @@
 import os
 import sys
 from abc import abstractmethod
-from typing import NoReturn
+from typing import Callable, NoReturn
 
 
 def func1():
@@ -92,6 +92,14 @@ def func9():
     return 3
 
 
+def func9_1(noreturn_func: Callable[[], NoReturn], unknown_func, flag: bool):
+    callback = noreturn_func if flag else unknown_func
+    callback()
+
+    # This should not be marked unreachable because the call target includes Unknown.
+    return 3
+
+
 def func10():
     e = OSError()
     a1 = os.name == "nt" and None == e.errno