WIP: Don't declare attributes on Expression to avoid confusing mypyc

Author: davidfstr

mypy/checkexpr.py

@@ -71,6 +71,7 @@
     LambdaExpr,
     ListComprehension,
     ListExpr,
+    MaybeTypeExpression,
     MemberExpr,
     MypyFile,
     NamedTupleExpr,
@@ -5949,6 +5950,7 @@ def accept(
             elif (
                 isinstance(p_type_context, TypeType)
                 and p_type_context.is_type_form
+                and isinstance(node, MaybeTypeExpression)
                 and node.as_type is not None
             ):
                 typ = TypeType.make_normalized(

mypy/nodes.py

@@ -201,19 +201,7 @@ def accept(self, visitor: StatementVisitor[T]) -> T:
 class Expression(Node):
     """An expression node."""
 
-    # NOTE: Cannot use __slots__ because some subclasses also inherit from
-    #       a different superclass with its own __slots__. A subclass in
-    #       Python is not allowed to have multiple superclasses that define
-    #       __slots__.
-    # __slots__ = ('as_type',)
-
-    # If this value expression can also be parsed as a valid type expression,
-    # represents the type denoted by the type expression.
-    as_type: mypy.types.Type | None
-
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        super().__init__(*args, **kwargs)
-        self.as_type = None
+    __slots__ = ()
 
     def accept(self, visitor: ExpressionVisitor[T]) -> T:
         raise RuntimeError("Not implemented", type(self))
@@ -2110,6 +2098,7 @@ class OpExpr(Expression):
         "right_always",
         "right_unreachable",
         "analyzed",
+        "as_type",
     )
 
     __match_args__ = ("left", "op", "right")
@@ -2125,6 +2114,9 @@ class OpExpr(Expression):
     right_unreachable: bool
     # Used for expressions that represent a type "X | Y" in some contexts
     analyzed: TypeAliasExpr | None
+    # If this value expression can also be parsed as a valid type expression,
+    # represents the type denoted by the type expression.
+    as_type: mypy.types.Type | None
 
     def __init__(
         self, op: str, left: Expression, right: Expression, analyzed: TypeAliasExpr | None = None
@@ -2137,11 +2129,18 @@ def __init__(
         self.right_always = False
         self.right_unreachable = False
         self.analyzed = analyzed
+        self.as_type = None
 
     def accept(self, visitor: ExpressionVisitor[T]) -> T:
         return visitor.visit_op_expr(self)
 
 
+# Expression subtypes that could represent the root of a valid type expression.
+# Always contains an "as_type" attribute.
+# TODO: Make this into a Protocol if mypyc is OK with that.
+MaybeTypeExpression = OpExpr
+
+
 class ComparisonExpr(Expression):
     """Comparison expression (e.g. a < b > c < d)."""
 

mypy/semanal.py

@@ -136,6 +136,7 @@
     ListExpr,
     Lvalue,
     MatchStmt,
+    MaybeTypeExpression,
     MemberExpr,
     MypyFile,
     NamedTupleExpr,
@@ -3541,7 +3542,7 @@ def analyze_lvalues(self, s: AssignmentStmt) -> None:
 
     def analyze_rvalue_as_type_form(self, s: AssignmentStmt) -> None:
         if TYPE_FORM in self.options.enable_incomplete_feature:
-            s.rvalue.as_type = self.try_parse_as_type_expression(s.rvalue)
+            self.try_parse_as_type_expression(s.rvalue)
 
     def apply_dynamic_class_hook(self, s: AssignmentStmt) -> None:
         if not isinstance(s.rvalue, CallExpr):
@@ -5278,7 +5279,7 @@ def visit_return_stmt(self, s: ReturnStmt) -> None:
         if s.expr:
             s.expr.accept(self)
             if TYPE_FORM in self.options.enable_incomplete_feature:
-                s.expr.as_type = self.try_parse_as_type_expression(s.expr)
+                self.try_parse_as_type_expression(s.expr)
 
     def visit_raise_stmt(self, s: RaiseStmt) -> None:
         self.statement = s
@@ -5823,7 +5824,7 @@ def visit_call_expr(self, expr: CallExpr) -> None:
             for a in expr.args:
                 a.accept(self)
                 if calculate_type_forms:
-                    a.as_type = self.try_parse_as_type_expression(a)
+                    self.try_parse_as_type_expression(a)
 
             if (
                 isinstance(expr.callee, MemberExpr)
@@ -7618,9 +7619,16 @@ def visit_pass_stmt(self, o: PassStmt, /) -> None:
     def visit_singleton_pattern(self, o: SingletonPattern, /) -> None:
         return None
 
-    def try_parse_as_type_expression(self, maybe_type_expr: Expression) -> Type | None:
-        """Try to parse maybe_type_expr as a type expression.
-        If parsing fails return None and emit no errors."""
+    def try_parse_as_type_expression(self, maybe_type_expr: Expression) -> None:
+        """Try to parse a value Expression as a type expression.
+        If success then annotate the Expression with the type that it spells.
+        If fails then emit no errors and take no further action.
+
+        A value expression that is parsable as a type expression may be used
+        where a TypeForm is expected to represent the spelled type."""
+        if not isinstance(maybe_type_expr, MaybeTypeExpression):
+            return
+
         # Save SemanticAnalyzer state
         original_errors = self.errors  # altered by fail()
         original_num_incomplete_refs = (
@@ -7649,7 +7657,8 @@ def try_parse_as_type_expression(self, maybe_type_expr: Expression) -> Type | No
             self.progress = original_progress
             self.deferred = original_deferred
             del self.deferral_debug_context[original_deferral_debug_context_len:]
-        return t
+
+        maybe_type_expr.as_type = t
 
 
 def replace_implicit_first_type(sig: FunctionLike, new: Type) -> FunctionLike:

mypy/typeanal.py

@@ -1360,18 +1360,7 @@ def visit_typeddict_type(self, t: TypedDictType) -> Type:
                     t,
                 )
             required_keys = req_keys
-            try:
-                fallback = self.named_type("typing._TypedDict")
-            except AssertionError as e:
-                if str(e) == "typing._TypedDict":
-                    # Can happen when running mypy tests, typing._TypedDict
-                    # is not defined by typing.pyi stubs, and
-                    # try_parse_as_type_expression() is called on an dict
-                    # expression that looks like an inline TypedDict type.
-                    self.fail("Internal error: typing._TypedDict not found", t)
-                    fallback = self.named_type("builtins.object")
-                else:
-                    raise
+            fallback = self.named_type("typing._TypedDict")
             for typ in t.extra_items_from:
                 analyzed = self.analyze_type(typ)
                 p_analyzed = get_proper_type(analyzed)