Merge branch 'master' into warn_unreachable_in_mypy

Author: wyattscarpenter

mypy/checker.py

@@ -5502,7 +5502,7 @@ def visit_with_stmt(self, s: WithStmt) -> None:
             self.accept(s.body)
 
     def check_untyped_after_decorator(self, typ: Type, func: FuncDef) -> None:
-        if not self.options.disallow_any_decorated or self.is_stub:
+        if not self.options.disallow_any_decorated or self.is_stub or self.current_node_deferred:
             return
 
         if mypy.checkexpr.has_any_type(typ):

mypy/semanal.py

@@ -1059,7 +1059,7 @@ def remove_unpack_kwargs(self, defn: FuncDef, typ: CallableType) -> CallableType
         # It is OK for TypedDict to have a key named 'kwargs'.
         overlap.discard(typ.arg_names[-1])
         if overlap:
-            overlapped = ", ".join([f'"{name}"' for name in overlap])
+            overlapped = ", ".join([f'"{name}"' for name in sorted(filter(None, overlap))])
             self.fail(f"Overlap between argument names and ** TypedDict items: {overlapped}", defn)
             new_arg_types = typ.arg_types[:-1] + [AnyType(TypeOfAny.from_error)]
             return typ.copy_modified(arg_types=new_arg_types)
@@ -5332,13 +5332,15 @@ def visit_expression_stmt(self, s: ExpressionStmt) -> None:
         s.expr.accept(self)
 
     def visit_return_stmt(self, s: ReturnStmt) -> None:
+        old = self.statement
         self.statement = s
         if not self.is_func_scope():
             self.fail('"return" outside function', s)
         if self.return_stmt_inside_except_star_block:
             self.fail('"return" not allowed in except* block', s, serious=True)
         if s.expr:
             s.expr.accept(self)
+        self.statement = old
 
     def visit_raise_stmt(self, s: RaiseStmt) -> None:
         self.statement = s

mypyc/irbuild/format_str_tokenizer.py

@@ -12,7 +12,7 @@
 )
 from mypy.errors import Errors
 from mypy.messages import MessageBuilder
-from mypy.nodes import Context, Expression
+from mypy.nodes import Context, Expression, StrExpr
 from mypy.options import Options
 from mypyc.ir.ops import Integer, Value
 from mypyc.ir.rtypes import (
@@ -143,7 +143,9 @@ def convert_format_expr_to_str(
     for x, format_op in zip(exprs, format_ops):
         node_type = builder.node_type(x)
         if format_op == FormatOp.STR:
-            if is_str_rprimitive(node_type):
+            if is_str_rprimitive(node_type) or isinstance(
+                x, StrExpr
+            ):  # NOTE: why does mypyc think our fake StrExprs are not str rprimitives?
                 var_str = builder.accept(x)
             elif is_int_rprimitive(node_type) or is_short_int_rprimitive(node_type):
                 var_str = builder.primitive_op(int_to_str_op, [builder.accept(x)], line)

mypyc/irbuild/specialize.py

@@ -31,6 +31,7 @@
     RefExpr,
     StrExpr,
     TupleExpr,
+    Var,
 )
 from mypy.types import AnyType, TypeOfAny
 from mypyc.ir.ops import (
@@ -710,6 +711,22 @@ def translate_fstring(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Va
                 format_ops.append(FormatOp.STR)
                 exprs.append(item.args[0])
 
+        def get_literal_str(expr: Expression) -> str | None:
+            if isinstance(expr, StrExpr):
+                return expr.value
+            elif isinstance(expr, RefExpr) and isinstance(expr.node, Var) and expr.node.is_final:
+                return str(expr.node.final_value)
+            return None
+
+        for i in range(len(exprs) - 1):
+            while (
+                len(exprs) >= i + 2
+                and (first := get_literal_str(exprs[i])) is not None
+                and (second := get_literal_str(exprs[i + 1])) is not None
+            ):
+                exprs = [*exprs[:i], StrExpr(first + second), *exprs[i + 2 :]]
+                format_ops = [*format_ops[:i], FormatOp.STR, *format_ops[i + 2 :]]
+
         substitutions = convert_format_expr_to_str(builder, format_ops, exprs, expr.line)
         if substitutions is None:
             return None

mypyc/test-data/irbuild-str.test

@@ -605,3 +605,43 @@ L3:
     r6 = r7
 L4:
     return r6
+
+[case testFStringFromConstants]
+from typing import Final
+string: Final = "abc"
+integer: Final = 123
+floating: Final = 3.14
+boolean: Final = True
+
+def test(x: str) -> str:
+    return f"{string}{integer}{floating}{boolean}{x}{boolean}{floating}{integer}{string}{x}{string}{integer}{floating}{boolean}"
+def test2(x: str) -> str:
+    return f"{string}{integer}{floating}{boolean}{x}{boolean}{floating}{integer}{string}{x}{string}{integer}{floating}{boolean}{x}"
+def test3(x: str) -> str:
+    return f"{x}{string}{integer}{floating}{boolean}{x}{boolean}{floating}{integer}{string}{x}{string}{integer}{floating}{boolean}{x}"
+
+[out]
+def test(x):
+    x, r0, r1, r2, r3 :: str
+L0:
+    r0 = 'abc1233.14True'
+    r1 = 'True3.14123abc'
+    r2 = 'abc1233.14True'
+    r3 = CPyStr_Build(5, r0, x, r1, x, r2)
+    return r3
+def test2(x):
+    x, r0, r1, r2, r3 :: str
+L0:
+    r0 = 'abc1233.14True'
+    r1 = 'True3.14123abc'
+    r2 = 'abc1233.14True'
+    r3 = CPyStr_Build(6, r0, x, r1, x, r2, x)
+    return r3
+def test3(x):
+    x, r0, r1, r2, r3 :: str
+L0:
+    r0 = 'abc1233.14True'
+    r1 = 'True3.14123abc'
+    r2 = 'abc1233.14True'
+    r3 = CPyStr_Build(7, x, r0, x, r1, x, r2, x)
+    return r3

mypyc/test/test_cheader.py

@@ -7,7 +7,6 @@
 import re
 import unittest
 
-from mypyc.ir.ops import PrimitiveDescription
 from mypyc.primitives import registry
 
 
@@ -32,8 +31,6 @@ def check_name(name: str) -> None:
             registry.function_ops.values(),
         ]:
             for ops in values:
-                if isinstance(ops, PrimitiveDescription):
-                    ops = [ops]
                 for op in ops:
                     if op.c_function_name is not None:
                         check_name(op.c_function_name)

test-data/unit/check-classes.test

@@ -9258,3 +9258,18 @@ main:5: note:     def __eq__(self, other: object) -> bool:
 main:5: note:         if not isinstance(other, C):
 main:5: note:             return NotImplemented
 main:5: note:         return <logic to compare two C instances>
+
+[case testLambdaInAttributeCallValue]
+# https://github.com/python/mypy/issues/19632
+import foo
+
+def nop(fn: object) -> foo.Bar:
+    return foo.Bar()
+
+class Bar:
+    foo: foo.Bar = nop(
+        lambda: 0
+    )
+[file foo.py]
+class Bar:
+    ...

test-data/unit/check-flags.test

@@ -1116,6 +1116,39 @@ def f(x: Any) -> Any:  # E: Function is untyped after decorator transformation
 def h(x):  # E: Function is untyped after decorator transformation
     pass
 [builtins fixtures/list.pyi]
+
+[case testDisallowAnyDecoratedUnannotatedDecoratorDeferred1]
+# flags: --disallow-any-decorated
+from typing import Callable
+
+def d(f: Callable[[int], None]) -> Callable[[int], None]:
+    return f
+
+def wrapper() -> None:
+    if c:
+        @d
+        def h(x):
+            pass
+
+c = [1]
+[builtins fixtures/list.pyi]
+
+[case testDisallowAnyDecoratedUnannotatedDecoratorDeferred2]
+# flags: --disallow-any-decorated
+from typing import Callable
+
+def d(f: Callable[[int], None]) -> Callable[[int], None]:
+    return f
+
+c = 1  # no deferral - check that the previous testcase is valid
+
+def wrapper() -> None:
+    if c:
+        @d
+        def h(x):
+            pass
+[builtins fixtures/list.pyi]
+
 [case testDisallowAnyDecoratedErrorIsReportedOnlyOnce]
 # flags: --disallow-any-decorated