Fix TypeGaurd on classes not saved to variables

Code from @Copilot at https://github.com/saulshanabrook/mypy/pull/1/files#diff-f96a2d6138bc6cdf2a07c4d37f6071cc25c1631afc107e277a28d5b59fc0ef04R6239-R6295

Author: saulshanabrook

mypy/checker.py

@@ -6156,6 +6156,9 @@ def find_isinstance_check_helper(
 
         if isinstance(node, CallExpr) and len(node.args) != 0:
             expr = collapse_walrus(node.args[0])
+            print("[TypeGuard Debug] --- find_isinstance_check_helper ---")
+            print(f"[TypeGuard Debug] {node=}")
+            print(f"[TypeGuard Debug] {node.callee=}")
             if refers_to_fullname(node.callee, "builtins.isinstance"):
                 if len(node.args) != 2:  # the error will be reported elsewhere
                     return {}, {}
@@ -6236,6 +6239,68 @@ def find_isinstance_check_helper(
                                     consider_runtime_isinstance=False,
                                 ),
                             )
+            elif isinstance(node.callee, CallExpr):
+                # Handle case where callee is a call expression like E()(x)
+                # where E() returns an object with __call__ method that has TypeGuard
+                if len(node.args) == 0:
+                    return {}, {}
+                callee_type = get_proper_type(self.lookup_type(node.callee))
+                if isinstance(callee_type, Instance):
+                    call_member = find_member(
+                        "__call__", callee_type, callee_type, is_operator=True
+                    )
+                    if call_member is not None:
+                        call_type = get_proper_type(call_member)
+                        # Check if the __call__ method has type_guard or type_is
+                        if isinstance(call_type, CallableType) and (
+                            call_type.type_guard is not None or call_type.type_is is not None
+                        ):
+                            # Handle keyword arguments similar to RefExpr case
+                            expr = collapse_walrus(node.args[0])  # Default to first positional arg
+                            if node.arg_kinds[0] != nodes.ARG_POS:
+                                # the first argument might be used as a kwarg
+                                if isinstance(call_type, (CallableType, Overloaded)):
+                                    if isinstance(call_type, Overloaded):
+                                        # Use first overload for argument name lookup
+                                        first_callable = call_type.items[0]
+                                    else:
+                                        first_callable = call_type
+
+                                    if first_callable.arg_names:
+                                        name = first_callable.arg_names[0]
+                                        if name in node.arg_names:
+                                            idx = node.arg_names.index(name)
+                                            # we want the idx-th variable to be narrowed
+                                            expr = collapse_walrus(node.args[idx])
+                                        else:
+                                            kind = (
+                                                "guard"
+                                                if call_type.type_guard is not None
+                                                else "narrower"
+                                            )
+                                            self.fail(
+                                                message_registry.TYPE_GUARD_POS_ARG_REQUIRED.format(
+                                                    kind
+                                                ),
+                                                node,
+                                            )
+                                            return {}, {}
+
+                            if literal(expr) == LITERAL_TYPE:
+                                # Apply the same TypeGuard narrowing logic
+                                if call_type.type_guard is not None:
+                                    return {expr: TypeGuardedType(call_type.type_guard)}, {}
+                                else:
+                                    assert call_type.type_is is not None
+                                    return conditional_types_to_typemaps(
+                                        expr,
+                                        *self.conditional_types_with_intersection(
+                                            self.lookup_type(expr),
+                                            [TypeRange(call_type.type_is, is_upper_bound=False)],
+                                            expr,
+                                            consider_runtime_isinstance=False,
+                                        ),
+                                    )
         elif isinstance(node, ComparisonExpr):
             return self.comparison_type_narrowing_helper(node)
         elif isinstance(node, AssignmentExpr):