Polish

Author: JukkaL

mypyc/irbuild/expression.py

@@ -364,18 +364,20 @@ def transform_call_expr(builder: IRBuilder, expr: CallExpr) -> Value:
         ):
             item_type = builder.type_to_rtype(analyzed.types[0])
             vec_type = RVec(item_type)
-            cap = _get_vec_cap(builder, expr)
+            capacity = _get_vec_capacity(builder, expr)
             if len(expr.args) == 0 or (len(expr.args) == 1 and expr.arg_kinds == [ARG_NAMED]):
-                # vec[T]() or vec[T](cap=N)
-                return vec_create(builder.builder, vec_type, 0, expr.line, cap=cap)
+                # vec[T]() or vec[T](capacity=N)
+                return vec_create(builder.builder, vec_type, 0, expr.line, capacity=capacity)
             elif (
                 len(expr.args) == 1
                 and expr.arg_kinds == [ARG_POS]
                 or len(expr.args) == 2
                 and expr.arg_kinds == [ARG_POS, ARG_NAMED]
             ):
-                # vec[T](items) or vec[T](items, cap=N)
-                return translate_vec_create_from_iterable(builder, vec_type, expr.args[0], cap=cap)
+                # vec[T](items) or vec[T](items, capacity=N)
+                return translate_vec_create_from_iterable(
+                    builder, vec_type, expr.args[0], capacity=capacity
+                )
         callee = analyzed.expr  # Unwrap type application
 
     if isinstance(callee, MemberExpr):
@@ -569,7 +571,7 @@ def translate_super_method_call(builder: IRBuilder, expr: CallExpr, callee: Supe
     return builder.builder.call(decl, arg_values, arg_kinds, arg_names, expr.line)
 
 
-def _get_vec_cap(builder: IRBuilder, expr: CallExpr) -> Value | None:
+def _get_vec_capacity(builder: IRBuilder, expr: CallExpr) -> Value | None:
     """Extract the 'capacity' keyword argument value from a vec() call, or None."""
     for i, (kind, name) in enumerate(zip(expr.arg_kinds, expr.arg_names)):
         if kind == ARG_NAMED and name == "capacity":
@@ -578,7 +580,7 @@ def _get_vec_cap(builder: IRBuilder, expr: CallExpr) -> Value | None:
 
 
 def translate_vec_create_from_iterable(
-    builder: IRBuilder, vec_type: RVec, arg: Expression, *, cap: Value | None = None
+    builder: IRBuilder, vec_type: RVec, arg: Expression, *, capacity: Value | None = None
 ) -> Value:
     line = arg.line
     item_type = vec_type.item_type
@@ -597,17 +599,19 @@ def translate_vec_create_from_iterable(
         if is_int64_rprimitive(other_type) or is_int_rprimitive(other_type):
             length = builder.accept(other)
             init = builder.accept(lst.items[0])
-            return vec_create_initialized(builder.builder, vec_type, length, init, line, cap=cap)
+            return vec_create_initialized(
+                builder.builder, vec_type, length, init, line, capacity=capacity
+            )
         assert False, other_type
     if isinstance(arg, ListExpr):
         items = []
         for item in arg.items:
             value = builder.accept(item)
             items.append(builder.coerce(value, item_type, line))
-        return vec_create_from_values(builder.builder, vec_type, items, line, cap=cap)
+        return vec_create_from_values(builder.builder, vec_type, items, line, capacity=capacity)
     if isinstance(arg, ListComprehension):
-        return translate_vec_comprehension(builder, vec_type, arg.generator, cap=cap)
-    return vec_from_iterable(builder, vec_type, arg, line, cap=cap)
+        return translate_vec_comprehension(builder, vec_type, arg.generator, capacity=capacity)
+    return vec_from_iterable(builder, vec_type, arg, line, capacity=capacity)
 
 
 def vec_from_iterable(
@@ -616,14 +620,14 @@ def vec_from_iterable(
     iterable: Expression,
     line: int,
     *,
-    cap: Value | None = None,
+    capacity: Value | None = None,
 ) -> Value:
     """Construct a vec from an arbitrary iterable."""
     # Translate it as a vec comprehension vec[t]([<name> for <name> in
     # iterable]). This way we can use various special casing supported
     # by for loops and comprehensions.
     vec = Register(vec_type)
-    builder.assign(vec, vec_create(builder.builder, vec_type, 0, line, cap=cap), line)
+    builder.assign(vec, vec_create(builder.builder, vec_type, 0, line, capacity=capacity), line)
     name = f"___tmp_{line}"
     var = Var(name)
     reg = builder.add_local(var, vec_type.item_type)

mypyc/irbuild/for_helpers.py

@@ -364,7 +364,7 @@ def gen_inner_stmts() -> None:
 
 
 def translate_vec_comprehension(
-    builder: IRBuilder, vec_type: RVec, gen: GeneratorExpr, *, cap: Value | None = None
+    builder: IRBuilder, vec_type: RVec, gen: GeneratorExpr, *, capacity: Value | None = None
 ) -> Value:
     def set_item(x: Value, y: Value, z: Value, line: int) -> None:
         vec_init_item_unsafe(builder.builder, x, y, z, line)
@@ -374,15 +374,17 @@ def set_item(x: Value, y: Value, z: Value, line: int) -> None:
         builder,
         gen,
         empty_op_llbuilder=lambda length, line: vec_create(
-            builder.builder, vec_type, length, line, cap=cap
+            builder.builder, vec_type, length, line, capacity=capacity
         ),
         set_item_op=set_item,
     )
     if val is not None:
         return val
 
     vec = Register(vec_type)
-    builder.assign(vec, vec_create(builder.builder, vec_type, 0, gen.line, cap=cap), gen.line)
+    builder.assign(
+        vec, vec_create(builder.builder, vec_type, 0, gen.line, capacity=capacity), gen.line
+    )
     loop_params = list(zip(gen.indices, gen.sequences, gen.condlists, gen.is_async))
 
     def gen_inner_stmts() -> None:

mypyc/irbuild/vec.py

@@ -80,22 +80,22 @@ def vec_create(
     length: int | Value,
     line: int,
     *,
-    cap: Value | None = None,
+    capacity: Value | None = None,
 ) -> Value:
     if isinstance(length, int):
         length = Integer(length, c_pyssize_t_rprimitive)
     length = as_platform_int(builder, length, line)
-    if cap is not None:
-        cap = as_platform_int(builder, cap, line)
+    if capacity is not None:
+        capacity = as_platform_int(builder, capacity, line)
     else:
-        cap = length
+        capacity = length
 
     item_type = vtype.item_type
     api_name = vec_api_by_item_type.get(item_type)
     if api_name is not None:
         call = CallC(
             f"{api_name}.alloc",
-            [length, cap],
+            [length, capacity],
             vtype,
             False,
             False,
@@ -121,7 +121,7 @@ def vec_create(
         if depth == 0:
             call = CallC(
                 "VecTApi.alloc",
-                [length, cap, typeval],
+                [length, capacity, typeval],
                 vtype,
                 False,
                 False,
@@ -132,7 +132,7 @@ def vec_create(
         else:
             call = CallC(
                 "VecNestedApi.alloc",
-                [length, cap, typeval, Integer(depth, int32_rprimitive)],
+                [length, capacity, typeval, Integer(depth, int32_rprimitive)],
                 vtype,
                 False,
                 False,
@@ -151,7 +151,7 @@ def vec_create_initialized(
     init: Value,
     line: int,
     *,
-    cap: Value | None = None,
+    capacity: Value | None = None,
 ) -> Value:
     """Create vec with items initialized to the given value."""
     if isinstance(length, int):
@@ -160,7 +160,7 @@ def vec_create_initialized(
 
     item_type = vtype.item_type
     init = builder.coerce(init, item_type, line)
-    vec = vec_create(builder, vtype, length, line, cap=cap)
+    vec = vec_create(builder, vtype, length, line, capacity=capacity)
 
     items_start = vec_items(builder, vec)
     step = step_size(item_type)
@@ -182,9 +182,9 @@ def vec_create_from_values(
     values: list[Value],
     line: int,
     *,
-    cap: Value | None = None,
+    capacity: Value | None = None,
 ) -> Value:
-    vec = vec_create(builder, vtype, len(values), line, cap=cap)
+    vec = vec_create(builder, vtype, len(values), line, capacity=capacity)
     ptr = vec_items(builder, vec)
     item_type = vtype.item_type
     step = step_size(item_type)