fix

mypy/checker.py

@@ -6549,6 +6549,7 @@ def comparison_type_narrowing_helper(self, node: ComparisonExpr) -> tuple[TypeMa
                 and not is_false_literal(expr)
                 and not is_true_literal(expr)
                 and not self.is_literal_enum(expr)
+                and not (isinstance(expr_type, CallableType) and expr_type.is_type_obj())
             ):
                 h = literal_hash(expr)
                 if h is not None:
@@ -6658,11 +6659,7 @@ def equality_type_narrowing_helper(
         # If we haven't been able to narrow types yet, we might be dealing with a
         # explicit type(x) == some_type check
         if_map, else_map = self.narrow_type_by_equality(
-            operator,
-            operands,
-            operand_types,
-            expr_indices,
-            narrowable_indices=narrowable_indices,
+            operator, operands, operand_types, expr_indices, narrowable_indices=narrowable_indices
         )
         if node is not None:
             type_if_map, type_else_map = self.find_type_equals_check(node, expr_indices)
@@ -6962,12 +6959,12 @@ def refine_identity_comparison_expression(
             else:
                 type_targets.append((i, TypeRange(expr_type, is_upper_bound=False)))
 
-        # print = lambda *a: None
-        # print()
-        # print("operands", operands)
-        # print("operand_types", operand_types)
-        # print("operator_specific_targets", operator_specific_targets)
-        # print("type_targets", type_targets)
+        if False:
+            print()
+            print("operands", operands)
+            print("operand_types", operand_types)
+            print("operator_specific_targets", operator_specific_targets)
+            print("type_targets", type_targets)
 
         partial_type_maps = []
 
@@ -7000,9 +6997,18 @@ def refine_identity_comparison_expression(
                             else_map = {}
                             partial_type_maps.append((if_map, else_map))
 
-        final_if_map, final_else_map = reduce_conditional_maps(partial_type_maps, use_meet=len(operands) > 2)
-        # print("final_if_map", {str(k): str(v) for k, v in final_if_map.items()})
-        # print("final_else_map", {str(k): str(v) for k, v in final_else_map.items()})
+        final_if_map, final_else_map = reduce_conditional_maps(
+            partial_type_maps, use_meet=len(operands) > 2
+        )
+        if False:
+            print(
+                "final_if_map",
+                {str(k): str(v) for k, v in final_if_map.items()} if final_if_map else None,
+            )
+            print(
+                "final_else_map",
+                {str(k): str(v) for k, v in final_else_map.items()} if final_else_map else None,
+            )
         return final_if_map, final_else_map
 
     def refine_away_none_in_comparison(

test-data/unit/check-narrowing.test

@@ -2767,6 +2767,6 @@ def get_type(setting_name: str) -> Callable[[Box1], Any] | type[Any]:
 def main(key: str):
     existing_value_type = get_type(key)
     if existing_value_type is TupleLike:
-        reveal_type(TupleLike)  # N: Revealed type is "(def (__main__.Box1[Any]) -> Any) | type[Any]"
-        TupleLike(Box2("str"))  # E: Argument 1 has incompatible type "Box2[str]"; expected "Box1[Any]"
+        reveal_type(TupleLike)  # N: Revealed type is "def [_T_co] (__main__.Boxxy[_T_co`1]) -> __main__.TupleLike[_T_co`1]"
+        TupleLike(Box2("str"))
 [builtins fixtures/tuple.pyi]