speedup typechecking of nested if expressions

Deeply nested if/else expressions have a worst-case exponential behavior.

This will for instance manifest when returning literal values which cause
repeated analysis of conditional branches with subtly different type context
for each literal.

This can be optimized by observing that a simple literal context will yield
the same analysis as its fallback type, and likewise, two literals of the
same fallback type will yield the same analysis. In those case we can avoid
the repeated analysis and prevent the worst-case exponential behavior.

Fixes #9591

Author: hugues-aff

mypy/checkexpr.py

@@ -69,7 +69,7 @@
     try_expanding_sum_type_to_union, tuple_fallback, make_simplified_union,
     true_only, false_only, erase_to_union_or_bound, function_type,
     callable_type, try_getting_str_literals, custom_special_method,
-    is_literal_type_like,
+    is_literal_type_like, simple_literal_type,
 )
 from mypy.message_registry import ErrorMessage
 import mypy.errorcodes as codes
@@ -3894,9 +3894,15 @@ def visit_conditional_expr(self, e: ConditionalExpr, allow_none_return: bool = F
         if_type = self.analyze_cond_branch(if_map, e.if_expr, context=ctx,
                                            allow_none_return=allow_none_return)
 
+        # check for simple literals for fast path below
+        ctx_lit = simple_literal_type(get_proper_type(ctx)) if ctx is not None else None
+        if_lit = simple_literal_type(get_proper_type(if_type)) if if_type != ctx else None
+
         # Analyze the right branch using full type context and store the type
         full_context_else_type = self.analyze_cond_branch(else_map, e.else_expr, context=ctx,
                                                           allow_none_return=allow_none_return)
+
+        # print(f'{ctx} {if_type} {full_context_else_type}')
         if not mypy.checker.is_valid_inferred_type(if_type):
             # Analyze the right branch disregarding the left branch.
             else_type = full_context_else_type
@@ -3910,6 +3916,15 @@ def visit_conditional_expr(self, e: ConditionalExpr, allow_none_return: bool = F
                 if_type = self.analyze_cond_branch(if_map, e.if_expr, context=else_type,
                                                    allow_none_return=allow_none_return)
 
+        elif if_type == ctx or (if_lit is not None and (if_lit == ctx or if_lit == ctx_lit)):
+            # There is no point re-running the analysis if if_type is equal to ctx.
+            # That would  be an exact duplicate of the work we just did.
+            # Likewise, when simple literals are involved we can avoid duplicate work as the
+            # join below will turn them back into the relevant fallback type.
+            # This optimization is particularly important to avoid exponential blowup with nested
+            # if/else expressions: https://github.com/python/mypy/issues/9591
+            # TODO: would checking for is_proper_subtype also work and cover more cases?
+            else_type = full_context_else_type
         else:
             # Analyze the right branch in the context of the left
             # branch's type.