Run pyupgrade on the mypyc source code

mypyc/build.py

@@ -23,8 +23,20 @@
 import re
 import sys
 import time
-from typing import Any, Dict, Iterable, List, Optional, Set, Tuple, Union, cast
-from typing_extensions import TYPE_CHECKING, NoReturn, Type
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Iterable,
+    List,
+    NoReturn,
+    Optional,
+    Set,
+    Tuple,
+    Type,
+    Union,
+    cast,
+)
 
 from mypy.build import BuildSource
 from mypy.errors import CompileError
@@ -222,7 +234,7 @@ def generate_c(
 
     # ... you know, just in case.
     if options.junit_xml:
-        py_version = "{}_{}".format(options.python_version[0], options.python_version[1])
+        py_version = f"{options.python_version[0]}_{options.python_version[1]}"
         write_junit_xml(
             t2 - t0, serious, messages, options.junit_xml, py_version, options.platform
         )

mypyc/codegen/emit.py

@@ -338,7 +338,7 @@ def emit_undefined_attr_check(
                 self.tuple_undefined_check_cond(rtype, attr_expr, self.c_undefined_value, compare)
             )
         else:
-            check = "({} {} {})".format(attr_expr, compare, self.c_undefined_value(rtype))
+            check = f"({attr_expr} {compare} {self.c_undefined_value(rtype)})"
         if unlikely:
             check = f"(unlikely{check})"
         self.emit_line(f"if {check} {{")
@@ -361,7 +361,7 @@ def tuple_undefined_check_cond(
                 item_type, tuple_expr_in_c + ".f0", c_type_compare_val, compare
             )
         else:
-            return "{}.f0 {} {}".format(tuple_expr_in_c, compare, c_type_compare_val(item_type))
+            return f"{tuple_expr_in_c}.f0 {compare} {c_type_compare_val(item_type)}"
 
     def tuple_undefined_value(self, rtuple: RTuple) -> str:
         return "tuple_undefined_" + rtuple.unique_id
@@ -629,7 +629,7 @@ def emit_cast_error_handler(
                 )
                 self.emit_line("goto %s;" % error.label)
                 return
-            self.emit_line('CPy_TypeError("{}", {}); '.format(self.pretty_name(typ), src))
+            self.emit_line(f'CPy_TypeError("{self.pretty_name(typ)}", {src}); ')
         if isinstance(error, AssignHandler):
             self.emit_line("%s = NULL;" % dest)
         elif isinstance(error, GotoHandler):
@@ -811,8 +811,8 @@ def emit_unbox(
         elif is_int32_rprimitive(typ):
             # Whether we are borrowing or not makes no difference.
             if declare_dest:
-                self.emit_line("int32_t {};".format(dest))
-            self.emit_line("{} = CPyLong_AsInt32({});".format(dest, src))
+                self.emit_line(f"int32_t {dest};")
+            self.emit_line(f"{dest} = CPyLong_AsInt32({src});")
             # TODO: Handle 'optional'
             # TODO: Handle 'failure'
         elif isinstance(typ, RTuple):

mypyc/codegen/emitclass.py

@@ -369,7 +369,7 @@ def generate_object_struct(cl: ClassIR, emitter: Emitter) -> None:
         if not base.is_trait:
             for attr, rtype in base.attributes.items():
                 if (attr, rtype) not in seen_attrs:
-                    lines.append("{}{};".format(emitter.ctype_spaced(rtype), emitter.attr(attr)))
+                    lines.append(f"{emitter.ctype_spaced(rtype)}{emitter.attr(attr)};")
                     seen_attrs.add((attr, rtype))
 
                     if isinstance(rtype, RTuple):
@@ -435,7 +435,7 @@ def trait_offset_table_name(trait: ClassIR) -> str:
     for trait, vtable in base.trait_vtables.items():
         # Trait methods entry (vtable index -> method implementation).
         emitter.emit_line(
-            "static CPyVTableItem {}[{}];".format(trait_vtable_name(trait), max(1, len(vtable)))
+            f"static CPyVTableItem {trait_vtable_name(trait)}[{max(1, len(vtable))}];"
         )
         # Trait attributes entry (attribute number in trait -> offset in actual struct).
         emitter.emit_line(
@@ -474,9 +474,7 @@ def generate_offset_table(
     """Generate attribute offset row of a trait vtable."""
     emitter.emit_line(f"size_t {trait_offset_table_name}_scratch[] = {{")
     for attr in trait.attributes:
-        emitter.emit_line(
-            "offsetof({}, {}),".format(cl.struct_name(emitter.names), emitter.attr(attr))
-        )
+        emitter.emit_line(f"offsetof({cl.struct_name(emitter.names)}, {emitter.attr(attr)}),")
     if not trait.attributes:
         # This is for msvc.
         emitter.emit_line("0")
@@ -534,9 +532,7 @@ def generate_setup_for_class(
     emitter.emit_line(f"{func_name}(PyTypeObject *type)")
     emitter.emit_line("{")
     emitter.emit_line(f"{cl.struct_name(emitter.names)} *self;")
-    emitter.emit_line(
-        "self = ({struct} *)type->tp_alloc(type, 0);".format(struct=cl.struct_name(emitter.names))
-    )
+    emitter.emit_line(f"self = ({cl.struct_name(emitter.names)} *)type->tp_alloc(type, 0);")
     emitter.emit_line("if (self == NULL)")
     emitter.emit_line("    return NULL;")
 
@@ -555,9 +551,7 @@ def generate_setup_for_class(
 
     for base in reversed(cl.base_mro):
         for attr, rtype in base.attributes.items():
-            emitter.emit_line(
-                r"self->{} = {};".format(emitter.attr(attr), emitter.c_undefined_value(rtype))
-            )
+            emitter.emit_line(rf"self->{emitter.attr(attr)} = {emitter.c_undefined_value(rtype)};")
 
     # Initialize attributes to default values, if necessary
     if defaults_fn is not None:
@@ -605,7 +599,7 @@ def generate_constructor_for_class(
 
     # If there is a nontrivial ctor that we didn't define, invoke it via tp_init
     elif len(fn.sig.args) > 1:
-        emitter.emit_line("int res = {}->tp_init({});".format(emitter.type_struct_name(cl), args))
+        emitter.emit_line(f"int res = {emitter.type_struct_name(cl)}->tp_init({args});")
 
         emitter.emit_line("if (res < 0) {")
         emitter.emit_line("Py_DECREF(self);")
@@ -698,7 +692,7 @@ def generate_traverse_for_class(cl: ClassIR, func_name: str, emitter: Emitter) -
     """Emit function that performs cycle GC traversal of an instance."""
     emitter.emit_line("static int")
     emitter.emit_line(
-        "{}({} *self, visitproc visit, void *arg)".format(func_name, cl.struct_name(emitter.names))
+        f"{func_name}({cl.struct_name(emitter.names)} *self, visitproc visit, void *arg)"
     )
     emitter.emit_line("{")
     for base in reversed(cl.base_mro):
@@ -708,10 +702,10 @@ def generate_traverse_for_class(cl: ClassIR, func_name: str, emitter: Emitter) -
         struct_name = cl.struct_name(emitter.names)
         # __dict__ lives right after the struct and __weakref__ lives right after that
         emitter.emit_gc_visit(
-            "*((PyObject **)((char *)self + sizeof({})))".format(struct_name), object_rprimitive
+            f"*((PyObject **)((char *)self + sizeof({struct_name})))", object_rprimitive
         )
         emitter.emit_gc_visit(
-            "*((PyObject **)((char *)self + sizeof(PyObject *) + sizeof({})))".format(struct_name),
+            f"*((PyObject **)((char *)self + sizeof(PyObject *) + sizeof({struct_name})))",
             object_rprimitive,
         )
     emitter.emit_line("return 0;")
@@ -729,10 +723,10 @@ def generate_clear_for_class(cl: ClassIR, func_name: str, emitter: Emitter) -> N
         struct_name = cl.struct_name(emitter.names)
         # __dict__ lives right after the struct and __weakref__ lives right after that
         emitter.emit_gc_clear(
-            "*((PyObject **)((char *)self + sizeof({})))".format(struct_name), object_rprimitive
+            f"*((PyObject **)((char *)self + sizeof({struct_name})))", object_rprimitive
         )
         emitter.emit_gc_clear(
-            "*((PyObject **)((char *)self + sizeof(PyObject *) + sizeof({})))".format(struct_name),
+            f"*((PyObject **)((char *)self + sizeof(PyObject *) + sizeof({struct_name})))",
             object_rprimitive,
         )
     emitter.emit_line("return 0;")
@@ -893,7 +887,7 @@ def generate_getter(cl: ClassIR, attr: str, rtype: RType, emitter: Emitter) -> N
     if not always_defined:
         emitter.emit_undefined_attr_check(rtype, attr_expr, "==", unlikely=True)
         emitter.emit_line("PyErr_SetString(PyExc_AttributeError,")
-        emitter.emit_line('    "attribute {} of {} undefined");'.format(repr(attr), repr(cl.name)))
+        emitter.emit_line(f'    "attribute {repr(attr)} of {repr(cl.name)} undefined");')
         emitter.emit_line("return NULL;")
         emitter.emit_line("}")
     emitter.emit_inc_ref(f"self->{attr_field}", rtype)
@@ -917,7 +911,7 @@ def generate_setter(cl: ClassIR, attr: str, rtype: RType, emitter: Emitter) -> N
         emitter.emit_line("if (value == NULL) {")
         emitter.emit_line("PyErr_SetString(PyExc_AttributeError,")
         emitter.emit_line(
-            '    "{} object attribute {} cannot be deleted");'.format(repr(cl.name), repr(attr))
+            f'    "{repr(cl.name)} object attribute {repr(attr)} cannot be deleted");'
         )
         emitter.emit_line("return -1;")
         emitter.emit_line("}")
@@ -931,7 +925,7 @@ def generate_setter(cl: ClassIR, attr: str, rtype: RType, emitter: Emitter) -> N
         attr_expr = f"self->{attr_field}"
         if not always_defined:
             emitter.emit_undefined_attr_check(rtype, attr_expr, "!=")
-        emitter.emit_dec_ref("self->{}".format(attr_field), rtype)
+        emitter.emit_dec_ref(f"self->{attr_field}", rtype)
         if not always_defined:
             emitter.emit_line("}")
 
@@ -949,9 +943,7 @@ def generate_setter(cl: ClassIR, attr: str, rtype: RType, emitter: Emitter) -> N
     emitter.emit_line(f"self->{attr_field} = tmp;")
     if deletable:
         emitter.emit_line("} else")
-        emitter.emit_line(
-            "    self->{} = {};".format(attr_field, emitter.c_undefined_value(rtype))
-        )
+        emitter.emit_line(f"    self->{attr_field} = {emitter.c_undefined_value(rtype)};")
     emitter.emit_line("return 0;")
     emitter.emit_line("}")
 
@@ -976,7 +968,7 @@ def generate_readonly_getter(
         emitter.emit_line("return retbox;")
     else:
         emitter.emit_line(
-            "return {}{}((PyObject *) self);".format(NATIVE_PREFIX, func_ir.cname(emitter.names))
+            f"return {NATIVE_PREFIX}{func_ir.cname(emitter.names)}((PyObject *) self);"
         )
     emitter.emit_line("}")
 
@@ -995,11 +987,11 @@ def generate_property_setter(
     if arg_type.is_unboxed:
         emitter.emit_unbox("value", "tmp", arg_type, error=ReturnHandler("-1"), declare_dest=True)
         emitter.emit_line(
-            "{}{}((PyObject *) self, tmp);".format(NATIVE_PREFIX, func_ir.cname(emitter.names))
+            f"{NATIVE_PREFIX}{func_ir.cname(emitter.names)}((PyObject *) self, tmp);"
         )
     else:
         emitter.emit_line(
-            "{}{}((PyObject *) self, value);".format(NATIVE_PREFIX, func_ir.cname(emitter.names))
+            f"{NATIVE_PREFIX}{func_ir.cname(emitter.names)}((PyObject *) self, value);"
         )
     emitter.emit_line("return 0;")
     emitter.emit_line("}")

mypyc/codegen/emitfunc.py

@@ -174,7 +174,7 @@ def visit_branch(self, op: Branch) -> None:
             if op2.class_type.class_ir.is_always_defined(op2.attr):
                 # Getting an always defined attribute never fails, so the branch can be omitted.
                 if false is not self.next_block:
-                    self.emit_line("goto {};".format(self.label(false)))
+                    self.emit_line(f"goto {self.label(false)};")
                 return
         negated = op.negated
         negated_rare = False
@@ -198,7 +198,7 @@ def visit_branch(self, op: Branch) -> None:
                     typ, self.reg(op.value), self.c_error_value, compare
                 )
             else:
-                cond = "{} {} {}".format(self.reg(op.value), compare, self.c_error_value(typ))
+                cond = f"{self.reg(op.value)} {compare} {self.c_error_value(typ)}"
         else:
             assert False, "Invalid branch"
 
@@ -273,7 +273,7 @@ def visit_load_error_value(self, op: LoadErrorValue) -> None:
             self.emit_line("{} {} = {{ {} }};".format(self.ctype(op.type), tmp, ", ".join(values)))
             self.emit_line(f"{self.reg(op)} = {tmp};")
         else:
-            self.emit_line("{} = {};".format(self.reg(op), self.c_error_value(op.type)))
+            self.emit_line(f"{self.reg(op)} = {self.c_error_value(op.type)};")
 
     def visit_load_literal(self, op: LoadLiteral) -> None:
         index = self.literals.literal_index(op.value)
@@ -321,7 +321,7 @@ def get_attr_expr(self, obj: str, op: Union[GetAttr, SetAttr], decl_cl: ClassIR)
             if op.class_type.class_ir.is_trait:
                 assert not decl_cl.is_trait
                 cast = f"({decl_cl.struct_name(self.emitter.names)} *)"
-            return "({}{})->{}".format(cast, obj, self.emitter.attr(op.attr))
+            return f"({cast}{obj})->{self.emitter.attr(op.attr)}"
 
     def visit_get_attr(self, op: GetAttr) -> None:
         dest = self.reg(op)
@@ -518,9 +518,7 @@ def visit_method_call(self, op: MethodCall) -> None:
         if is_direct:
             # Directly call method, without going through the vtable.
             lib = self.emitter.get_group_prefix(method.decl)
-            self.emit_line(
-                "{}{}{}{}({});".format(dest, lib, NATIVE_PREFIX, method.cname(self.names), args)
-            )
+            self.emit_line(f"{dest}{lib}{NATIVE_PREFIX}{method.cname(self.names)}({args});")
         else:
             # Call using vtable.
             method_idx = rtype.method_index(name)
@@ -619,7 +617,7 @@ def visit_extend(self, op: Extend) -> None:
             src_cast = self.emit_signed_int_cast(op.src.type)
         else:
             src_cast = self.emit_unsigned_int_cast(op.src.type)
-        self.emit_line("{} = {}{};".format(dest, src_cast, value))
+        self.emit_line(f"{dest} = {src_cast}{value};")
 
     def visit_load_global(self, op: LoadGlobal) -> None:
         dest = self.reg(op)
@@ -660,9 +658,7 @@ def visit_comparison_op(self, op: ComparisonOp) -> None:
         elif isinstance(op.rhs, Integer) and op.rhs.value < 0:
             # Force signed ==/!= with negative operand
             lhs_cast = self.emit_signed_int_cast(op.lhs.type)
-        self.emit_line(
-            "{} = {}{} {} {}{};".format(dest, lhs_cast, lhs, op.op_str[op.op], rhs_cast, rhs)
-        )
+        self.emit_line(f"{dest} = {lhs_cast}{lhs} {op.op_str[op.op]} {rhs_cast}{rhs};")
 
     def visit_load_mem(self, op: LoadMem) -> None:
         dest = self.reg(op)

mypyc/codegen/emitmodule.py

@@ -911,7 +911,7 @@ def generate_module_def(self, emitter: Emitter, module_name: str, module: Module
             "    goto fail;",
         )
         emitter.emit_line(
-            'modname = PyObject_GetAttrString((PyObject *){}, "__name__");'.format(module_static)
+            f'modname = PyObject_GetAttrString((PyObject *){module_static}, "__name__");'
         )
 
         module_globals = emitter.static_name("globals", module_name)

mypyc/codegen/emitwrapper.py

@@ -447,9 +447,7 @@ def generate_get_wrapper(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
         )
     )
     emitter.emit_line("instance = instance ? instance : Py_None;")
-    emitter.emit_line(
-        "return {}{}(self, instance, owner);".format(NATIVE_PREFIX, fn.cname(emitter.names))
-    )
+    emitter.emit_line(f"return {NATIVE_PREFIX}{fn.cname(emitter.names)}(self, instance, owner);")
     emitter.emit_line("}")
 
     return name
@@ -458,7 +456,7 @@ def generate_get_wrapper(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
 def generate_hash_wrapper(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
     """Generates a wrapper for native __hash__ methods."""
     name = f"{DUNDER_PREFIX}{fn.name}{cl.name_prefix(emitter.names)}"
-    emitter.emit_line("static Py_ssize_t {name}(PyObject *self) {{".format(name=name))
+    emitter.emit_line(f"static Py_ssize_t {name}(PyObject *self) {{")
     emitter.emit_line(
         "{}retval = {}{}{}(self);".format(
             emitter.ctype_spaced(fn.ret_type),
@@ -485,7 +483,7 @@ def generate_hash_wrapper(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
 def generate_len_wrapper(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
     """Generates a wrapper for native __len__ methods."""
     name = f"{DUNDER_PREFIX}{fn.name}{cl.name_prefix(emitter.names)}"
-    emitter.emit_line("static Py_ssize_t {name}(PyObject *self) {{".format(name=name))
+    emitter.emit_line(f"static Py_ssize_t {name}(PyObject *self) {{")
     emitter.emit_line(
         "{}retval = {}{}{}(self);".format(
             emitter.ctype_spaced(fn.ret_type),
@@ -510,7 +508,7 @@ def generate_len_wrapper(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
 def generate_bool_wrapper(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
     """Generates a wrapper for native __bool__ methods."""
     name = f"{DUNDER_PREFIX}{fn.name}{cl.name_prefix(emitter.names)}"
-    emitter.emit_line("static int {name}(PyObject *self) {{".format(name=name))
+    emitter.emit_line(f"static int {name}(PyObject *self) {{")
     emitter.emit_line(
         "{}val = {}{}(self);".format(
             emitter.ctype_spaced(fn.ret_type), NATIVE_PREFIX, fn.cname(emitter.names)
@@ -534,9 +532,7 @@ def generate_del_item_wrapper(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
     """
     name = "{}{}{}".format(DUNDER_PREFIX, "__delitem__", cl.name_prefix(emitter.names))
     input_args = ", ".join(f"PyObject *obj_{arg.name}" for arg in fn.args)
-    emitter.emit_line(
-        "static int {name}({input_args}) {{".format(name=name, input_args=input_args)
-    )
+    emitter.emit_line(f"static int {name}({input_args}) {{")
     generate_set_del_item_wrapper_inner(fn, emitter, fn.args)
     return name
 
@@ -564,17 +560,13 @@ def generate_set_del_item_wrapper(cl: ClassIR, fn: FuncIR, emitter: Emitter) ->
 
     name = "{}{}{}".format(DUNDER_PREFIX, "__setitem__", cl.name_prefix(emitter.names))
     input_args = ", ".join(f"PyObject *obj_{arg.name}" for arg in args)
-    emitter.emit_line(
-        "static int {name}({input_args}) {{".format(name=name, input_args=input_args)
-    )
+    emitter.emit_line(f"static int {name}({input_args}) {{")
 
     # First check if this is __delitem__
     emitter.emit_line(f"if (obj_{args[2].name} == NULL) {{")
     if del_name is not None:
         # We have a native implementation, so call it
-        emitter.emit_line(
-            "return {}(obj_{}, obj_{});".format(del_name, args[0].name, args[1].name)
-        )
+        emitter.emit_line(f"return {del_name}(obj_{args[0].name}, obj_{args[1].name});")
     else:
         # Try to call superclass method instead
         emitter.emit_line(f"PyObject *super = CPy_Super(CPyModule_builtins, obj_{args[0].name});")
@@ -637,7 +629,7 @@ def generate_set_del_item_wrapper_inner(
 def generate_contains_wrapper(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
     """Generates a wrapper for a native __contains__ method."""
     name = f"{DUNDER_PREFIX}{fn.name}{cl.name_prefix(emitter.names)}"
-    emitter.emit_line("static int {name}(PyObject *self, PyObject *obj_item) {{".format(name=name))
+    emitter.emit_line(f"static int {name}(PyObject *self, PyObject *obj_item) {{")
     generate_arg_check("item", fn.args[1].type, emitter, ReturnHandler("-1"))
     emitter.emit_line(
         "{}val = {}{}(self, arg_item);".format(
@@ -835,9 +827,7 @@ def emit_call(self, not_implemented_handler: str = "") -> None:
                     "return retbox;",
                 )
             else:
-                emitter.emit_line(
-                    "return {}{}({});".format(NATIVE_PREFIX, self.target_cname, native_args)
-                )
+                emitter.emit_line(f"return {NATIVE_PREFIX}{self.target_cname}({native_args});")
             # TODO: Tracebacks?
 
     def error(self) -> ErrorHandler: