cpyte 3.3.0__tar.gz → 3.3.2__tar.gz

{cpyte-3.3.0/source/cpyte.egg-info → cpyte-3.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cpyte
-Version: 3.3.0
+Version: 3.3.2
 Summary: The Cpyte programming language compiler
 Author: Hoang Duy Tung
 License: MIT
@@ -16,7 +16,7 @@ Check out the official documentation [here](https://gitea.5gnew.io.vn/Cpyte-Proj
 Cpyte supports a package extension system that allows packages to extend the compiler with custom keywords, operators, and compiler hooks. Packages can provide:
 
 - **Custom Keywords**: Add new language keywords via `package.json`
-- **Custom Operators**: Define new operators for syntax extensions  
+- **Custom Operators**: Define new operators for syntax extensions
 - **Compiler Hooks**: Extend lexing, parsing, semantic analysis, and code generation
 - **Runtime Extensions**: Add runtime code and libraries
 
@@ -83,3 +83,17 @@ Cpyte is experimental software. The compiler is continuously tested with fuzzing
 Cpyte uses a **concurrent tri-color garbage collector** for automatic memory management. Heap-allocated objects (via `new`) are managed automatically — no manual `free` needed.
 
 **Note:** The collector adds a small runtime overhead (~5-10%) compared to manual `malloc/free`. For performance-critical ecosystem projects or embedded use cases, this trade-off may be significant. The GC is required for safety but will slow down programs that do heavy heap allocation.
+
+## Cross-Platform Runtime
+
+The compiler is fully cross-platform. On every target OS (macOS, Linux, Windows) the C runtime (`runtime.c`), the GC runtime (`gc_runtime.c`), and any embedded `ccode:` blocks are **compiled from source** at JIT/AOT time for the host platform, rather than linking pre-built, OS-specific bitcode. This keeps native helpers and the garbage collector correct on each system:
+
+- Portable threading: `pthread` on POSIX; native Windows threads + `CRITICAL_SECTION` on Windows.
+- Portable stack scanning for the GC that works on macOS, Linux, and Windows.
+- A portable sleep/yield helper replaces the POSIX-only `nanosleep`.
+
+The compiler auto-discovers a C compiler (`clang` → `cc` → `gcc`) and system linker on the current platform, so `cpy`, `cpy build`, and `cpy --aot` all work without per-OS configuration.
+
+## Continuous Integration
+
+GitHub Actions (see `.github/workflows/code_quality.yml`) builds and runs a curated, cross-platform regression corpus on Ubuntu (x86_64 + arm64), macOS (x86_64 + arm64), and Windows. `ci_test.py` AOT-compiles each program with the system linker and executes the result to exercise the full pipeline — lexer, parser, semantic analysis, LLVM codegen, the C and GC runtimes, and linking.

{cpyte-3.3.0 → cpyte-3.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cpyte"
-version = "3.3.0"
+version = "3.3.2"
 description = "The Cpyte programming language compiler"
 readme = "readme.md"
 requires-python = ">=3.11"

{cpyte-3.3.0 → cpyte-3.3.2}/readme.md

@@ -5,7 +5,7 @@ Check out the official documentation [here](https://gitea.5gnew.io.vn/Cpyte-Proj
 Cpyte supports a package extension system that allows packages to extend the compiler with custom keywords, operators, and compiler hooks. Packages can provide:
 
 - **Custom Keywords**: Add new language keywords via `package.json`
-- **Custom Operators**: Define new operators for syntax extensions  
+- **Custom Operators**: Define new operators for syntax extensions
 - **Compiler Hooks**: Extend lexing, parsing, semantic analysis, and code generation
 - **Runtime Extensions**: Add runtime code and libraries
 
@@ -71,4 +71,18 @@ Cpyte is experimental software. The compiler is continuously tested with fuzzing
 
 Cpyte uses a **concurrent tri-color garbage collector** for automatic memory management. Heap-allocated objects (via `new`) are managed automatically — no manual `free` needed.
 
-**Note:** The collector adds a small runtime overhead (~5-10%) compared to manual `malloc/free`. For performance-critical ecosystem projects or embedded use cases, this trade-off may be significant. The GC is required for safety but will slow down programs that do heavy heap allocation.
+**Note:** The collector adds a small runtime overhead (~5-10%) compared to manual `malloc/free`. For performance-critical ecosystem projects or embedded use cases, this trade-off may be significant. The GC is required for safety but will slow down programs that do heavy heap allocation.
+
+## Cross-Platform Runtime
+
+The compiler is fully cross-platform. On every target OS (macOS, Linux, Windows) the C runtime (`runtime.c`), the GC runtime (`gc_runtime.c`), and any embedded `ccode:` blocks are **compiled from source** at JIT/AOT time for the host platform, rather than linking pre-built, OS-specific bitcode. This keeps native helpers and the garbage collector correct on each system:
+
+- Portable threading: `pthread` on POSIX; native Windows threads + `CRITICAL_SECTION` on Windows.
+- Portable stack scanning for the GC that works on macOS, Linux, and Windows.
+- A portable sleep/yield helper replaces the POSIX-only `nanosleep`.
+
+The compiler auto-discovers a C compiler (`clang` → `cc` → `gcc`) and system linker on the current platform, so `cpy`, `cpy build`, and `cpy --aot` all work without per-OS configuration.
+
+## Continuous Integration
+
+GitHub Actions (see `.github/workflows/code_quality.yml`) builds and runs a curated, cross-platform regression corpus on Ubuntu (x86_64 + arm64), macOS (x86_64 + arm64), and Windows. `ci_test.py` AOT-compiles each program with the system linker and executes the result to exercise the full pipeline — lexer, parser, semantic analysis, LLVM codegen, the C and GC runtimes, and linking.

cpyte-3.3.2/source/cpyte/__init__.py

@@ -0,0 +1 @@
+__version__ = "3.3.2"

{cpyte-3.3.0 → cpyte-3.3.2}/source/cpyte/astparse.py

@@ -4,6 +4,31 @@ from .lexar import Lexer, Token, TokenType, _unescape_run
 
 _parser_hooks: list[Any] = []
 
+# User-declared type names (structs, type aliases, classes) collected in a
+# pre-scan so bare-name casts like `(MyInt)x` are recognized as casts at parse
+# time. Reset per parse_file().
+_user_type_names: set[str] = set()
+
+
+def _pre_scan_user_types(tokens):
+    """Collect identifiers declared as struct/type/class so the parser can
+    recognize casts to user-defined types even without a pointer suffix."""
+    global _user_type_names
+    names = set()
+    i = 0
+    n = len(tokens)
+    while i < n:
+        t = tokens[i]
+        if t.type == TokenType.KEYWORD and t.value in ("struct", "type", "class"):
+            j = i + 1
+            if j < n and tokens[j].type == TokenType.IDENTIFIER:
+                names.add(tokens[j].value)
+                i = j + 1
+                continue
+        i += 1
+    _user_type_names = names
+    return names
+
 
 def register_parser_hook(hook: Any) -> None:
     _parser_hooks.append(hook)
@@ -21,10 +46,10 @@ def _get_all_parser_hooks(enable_extensions: bool) -> list[Any]:
         return []
     hooks = list(_parser_hooks)
     try:
-        from .extension_hooks import get_global_hook_registry
+        from .extension_hooks import HookStage, ParserHook, get_global_hook_registry
         registry = get_global_hook_registry()
-        for hook in registry.get_parser_hooks():
-            if hook not in hooks:
+        for hook in registry.get(HookStage.PARSER):
+            if isinstance(hook, ParserHook) and hook not in hooks:
                 hooks.append(hook)
     except ImportError:
         pass
@@ -296,36 +321,75 @@ def _parse_unary(tokens: list[Token], pos: int):
 
 def _try_parse_cast_type(tokens, pos):
     """Try to parse a type name for a C-style cast like (int), (size_t*), (float[]).
+    Also accepts user-defined types (structs / type aliases / classes) as cast
+    targets, e.g. ``(Point*)p`` or ``(MyInt)x``.
 
     Returns (type_string, new_pos) on success, or (None, original_pos) if not a cast.
+    The returned type string retains pointer/array/ref suffixes, so ``(int*)x``
+    decodes to a pointer cast rather than silently degrading to ``int``.
     """
     if pos >= len(tokens) or tokens[pos].type != TokenType.IDENTIFIER:
         return None, pos
     name = tokens[pos].value
-    if name not in _TYPE_NAMES:
-        return None, pos
+    base = name
     pos += 1
+    has_suffix = False
     while pos < len(tokens):
         t = tokens[pos].type
         if t == TokenType.STAR:
+            base = _type_to_str(base) + "*"
+            has_suffix = True
             pos += 1
         elif t == TokenType.POW:
+            base = _type_to_str(base) + "**"
+            has_suffix = True
             pos += 1
         elif t == TokenType.LBRACKET:
             if pos + 1 < len(tokens) and tokens[pos + 1].type == TokenType.RBRACKET:
+                base = _type_to_str(base) + "[]"
+                has_suffix = True
                 pos += 2
             else:
                 break
         elif t == TokenType.AMPERSAND:
+            base = _type_to_str(base) + "&"
+            has_suffix = True
             pos += 1
         else:
             break
-    return name, pos
+    # A bare (no-suffix) name is accepted as a cast target only when it is a
+    # known builtin type or a user-declared type. Otherwise leave it to the
+    # normal parenthesized-expression/call path to avoid ambiguity.
+    if not has_suffix and name not in _TYPE_NAMES and name not in _user_type_names:
+        return None, pos
+    return base, pos
 
 
 def _parse_atom(tokens: list[Token], pos: int):
     tok = tokens[pos]
 
+    if tok.type == TokenType.KEYWORD and tok.value == 'borrow':
+        pos += 1
+        mutable = False
+        if (
+            pos < len(tokens)
+            and tokens[pos].type == TokenType.KEYWORD
+            and tokens[pos].value == 'mut'
+        ):
+            mutable = True
+            pos += 1
+        if pos >= len(tokens):
+            raise ParseError('Expected expression after `borrow`', tok)
+        operand, pos = parse_expression(tokens, pos)
+        return BorrowExpr(operand, mutable=mutable, token=tok), pos
+
+    if tok.type == TokenType.KEYWORD and tok.value == 'move':
+        pos += 1
+        if pos >= len(tokens):
+            raise ParseError('Expected expression after `move`', tok)
+        operand, pos = parse_expression(tokens, pos)
+        return MoveExpr(operand, token=tok), pos
+
     if tok.type == TokenType.NUMBER and tok.value == '67':
         pos += 1
         if pos < len(tokens) and tokens[pos].type == TokenType.LPAREN:
@@ -815,6 +879,7 @@ def _parse_expr_iterative(tokens: list[Token], pos: int, min_prec: int):
 
 
 def parse_file(tokens: list[Token], pos: int = 0, enable_extensions: bool = True):
+    _pre_scan_user_types(tokens)
     nodes = []
     while pos < len(tokens) and tokens[pos].type not in (TokenType.EOF, TokenType.DEDENT):
         while pos < len(tokens) and tokens[pos].type == TokenType.NEWLINE:
@@ -827,11 +892,12 @@ def parse_file(tokens: list[Token], pos: int = 0, enable_extensions: bool = True
 
         all_hooks = _get_all_parser_hooks(enable_extensions)
         if all_hooks:
+            ctx = _make_parser_ctx(tokens, pos)
             handled = False
             for hook in all_hooks:
                 try:
                     if hasattr(hook, 'should_handle_statement') and hook.should_handle_statement(tokens, pos):
-                        node, pos = hook.parse_statement(tokens, pos, {'tokens': tokens, 'pos': pos})
+                        node, pos = hook.parse_statement(tokens, pos, ctx)
                         nodes.append(node)
                         handled = True
                         break
@@ -847,6 +913,25 @@ def parse_file(tokens: list[Token], pos: int = 0, enable_extensions: bool = True
     return nodes, pos
 
 
+_parser_ctx = None
+
+
+def _make_parser_ctx(tokens, pos):
+    """Build a lazily-cached CompilerContext for parser hooks."""
+    global _parser_ctx
+    if _parser_ctx is None:
+        from .extension_hooks import CompilerContext
+        _parser_ctx = CompilerContext(data={"astparse": _get_module_ref()})
+    _parser_ctx.data["tokens"] = tokens
+    _parser_ctx.data["pos"] = pos
+    return _parser_ctx
+
+
+def _get_module_ref():
+    import sys
+    return sys.modules.get(__name__)
+
+
 def _parse_standard_statement(tokens: list[Token], pos: int):
     """Parse a statement using standard grammar (non-hooked)."""
     tok = tokens[pos]
@@ -1430,6 +1515,53 @@ class CastExpr(Node):
         return f'CastExpr({self.type_expr}, {self.expr})'
 
 
+class BorrowExpr(Node):
+    """`borrow x` or `borrow mut x` — create a reference to x.
+
+    `borrow x` is an immutable borrow (x must not be mutated while borrowed);
+    `borrow mut x` is a mutable borrow. Both lower to taking x's address, but
+    the semantic/ownership pass enforces borrow rules.
+    """
+    __slots__ = ('_token', 'operand', 'mutable', 'inferred_type')
+    def __init__(self, operand, mutable: bool = False, token=None):
+        self.operand = operand
+        self.mutable = mutable
+        self._token = token
+        self.inferred_type = None
+    def __repr__(self):
+        return f'BorrowExpr(mut={self.mutable}, {self.operand})'
+
+
+class MoveExpr(Node):
+    """`move x` — transfer ownership of x (heap/owned value) to the mover.
+
+    After a move, x is no longer valid to use; the ownership pass errors if x is
+    used afterward unless it is reassigned.
+    """
+    __slots__ = ('_token', 'operand', 'inferred_type')
+    def __init__(self, operand, token=None):
+        self.operand = operand
+        self._token = token
+        self.inferred_type = None
+    def __repr__(self):
+        return f'MoveExpr({self.operand})'
+
+
+class DeferStmt(Node):
+    """`defer <stmt>` — run <stmt> when the enclosing function returns (LIFO).
+
+    Deferred statements are collected per function and emitted (in reverse
+    order) just before every function exit point: return statements and the
+    implicit end-of-function return.
+    """
+    __slots__ = ('_token', 'body')
+    def __init__(self, body, token=None):
+        self.body = body
+        self._token = token
+    def __repr__(self):
+        return f'DeferStmt({self.body!r})'
+
+
 class StructDef(Node):
     __slots__ = ('_token', 'fields', 'generic_params', 'name')
     def __init__(self, name: str, fields: list, generic_params: list | None = None, token=None):
@@ -1780,6 +1912,17 @@ def parse_var_decl(tokens: list[Token], pos: int):
     return VarDecl(name, var_type_str, init, is_const=is_const, token=tok), pos
 
 
+def parse_defer(tokens: list[Token], pos: int):
+    tok = tokens[pos]  # 'defer'
+    pos += 1
+    if pos >= len(tokens):
+        raise ParseError('Expected a statement after `defer`', tok)
+    stmt, pos = parse_statement(tokens, pos)
+    if stmt is None:
+        stmt = parse_expr_stmt(tokens, pos)
+    return DeferStmt(stmt, token=tok), pos
+
+
 def parse_statement(tokens: list[Token], pos: int):
     if pos >= len(tokens):
         return None, pos
@@ -1835,6 +1978,9 @@ def parse_statement(tokens: list[Token], pos: int):
     if tok.type == TokenType.KEYWORD and tok.value == 'unsafe':
         return parse_llvm(tokens, pos, unsafe=True)
 
+    if tok.type == TokenType.KEYWORD and tok.value == 'defer':
+        return parse_defer(tokens, pos)
+
     if tok.type == TokenType.IDENTIFIER:
         if tok.value in _TYPE_NAMES or _looks_like_type(tokens, pos):
             try:

{cpyte-3.3.0 → cpyte-3.3.2}/source/cpyte/bytecoding.py

@@ -7,7 +7,14 @@ from llvmlite import binding, ir
 from llvmlite.ir import instructions
 
 from .astparse import *
-from .extension_hooks import HookLoadError, get_global_hook_registry
+from .extension_hooks import (
+    CodegenHook,
+    CompilerContext,
+    HookLoadError,
+    HookStage,
+    RuntimeHook,
+    get_global_hook_registry,
+)
 from .lexar import TokenType
 from .ui import *
 
@@ -321,6 +328,17 @@ class LLVM:
         q = abs(a) // abs(b)
         return -q if (a < 0) != (b < 0) else q
 
+    def _hook_context(self, data: dict | None = None) -> CompilerContext:
+        """Build a CompilerContext exposing this codegen instance to hooks."""
+        ctx = CompilerContext(llvm_module=self.module)
+        ctx.data["llvm"] = self
+        ctx.data["module"] = self.module
+        if getattr(self, "builder", None) is not None:
+            ctx.data["builder"] = self.builder
+        if data:
+            ctx.data.update(data)
+        return ctx
+
     def _emit_int_divmod(self, left, right, is_rem):
         """Signed int division/remainder that stays well-defined in LLVM IR.
 
@@ -469,6 +487,7 @@ class LLVM:
         self.ssa_values = {}
         self.ssa_types = {}  # Track types of SSA values
         self.scope_stack = []
+        self._deferred: list = []  # statements collected by `defer`, run LIFO on function exit
         self.structs = {}
         self.struct_fields = {}
         self.import_src_files = []
@@ -1007,9 +1026,17 @@ class LLVM:
             import os
             import tempfile
 
-            for hook in self._hook_registry.get_runtime_hooks():
+            context = self._hook_context()
+            for hook in self._hook_registry.get(HookStage.RUNTIME):
+                if not isinstance(hook, RuntimeHook):
+                    continue
                 try:
-                    runtime_code = hook.get_runtime_code()
+                    for rel_file in hook.get_runtime_files(context):
+                        base = os.path.dirname(hook.hook_path) if hook.hook_path else ""
+                        abs_path = os.path.join(base, rel_file)
+                        if os.path.isfile(abs_path):
+                            self.import_src_files.append(abs_path)
+                    runtime_code = hook.get_runtime_code(context)
                     if runtime_code:
                         fd, tmp_path = tempfile.mkstemp(
                             suffix=".c", prefix="hook_runtime_"
@@ -1157,7 +1184,9 @@ class LLVM:
         left_len = self.builder.call(strlen_fn, [left])
         right_len = self.builder.call(strlen_fn, [right])
         total_len = self.builder.add(left_len, right_len)
-        plus_one = self.builder.add(total_len, ir.Constant(_i32, 1))
+        plus_one = self.builder.add(
+            total_len, ir.Constant(total_len.type, 1)
+        )
         new_str = self.builder.call(malloc_fn, [self.builder.zext(plus_one, _i64)])
         self.builder.call(memcpy_fn, [new_str, left, left_len])
         dest_plus = self.builder.gep(new_str, [left_len], inbounds=True)
@@ -1170,6 +1199,13 @@ class LLVM:
     def emit_exprstmt(self, node):
         return self.emit(node.expr)
 
+    @register_emitter(DeferStmt)
+    def emit_deferstmt(self, node: DeferStmt):
+        # Collect the deferred statement; it is emitted (in reverse order) at
+        # the function's exit points, both explicit `return` and implicit end.
+        self._deferred.append(node.body)
+        return None
+
     def emit(self, node: Node | dict) -> _IRValue:
         key = id(node)
         if key in self._emit_memo:
@@ -1425,17 +1461,15 @@ class LLVM:
     def _emit_recursive(self, node: Node | dict) -> _IRValue:
         # Try codegen hooks if extensions are enabled
         if self.enable_extensions:
-            for hook in self._hook_registry.get_codegen_hooks():
+            for hook in self._hook_registry.get(HookStage.CODEGEN):
+                if not isinstance(hook, CodegenHook):
+                    continue
                 try:
                     if hook.should_emit_node(node):
                         return hook.emit_node(
                             node,
                             self.builder,
-                            {
-                                "llvm": self,
-                                "module": self.module,
-                                "builder": self.builder,
-                            },
+                            self._hook_context(data={"node": node}),
                         )
                 except Exception as e:
                     raise HookLoadError(
@@ -1798,6 +1832,18 @@ class LLVM:
             raise Exception(f"Undefined variable '{name}'")
         raise Exception("Address-of requires a variable")
 
+    @register_emitter(BorrowExpr)
+    def emit_borrow(self, node: BorrowExpr):
+        # `borrow x` / `borrow mut x` lowers to taking x's address, exactly like
+        # `&x`. Mutable vs immutable is enforced at the semantic stage.
+        return self.emit_addrof(AddrOf(node.operand))
+
+    @register_emitter(MoveExpr)
+    def emit_move(self, node: MoveExpr):
+        # `move x` is a compile-time ownership transfer; at runtime it just
+        # yields the value of x (no copy is made).
+        return self.emit(node.operand)
+
     @register_emitter(SizeOf)
     def emit_sizeof(self, node: SizeOf):
         ty = self.llvm_type(node.type_expr)
@@ -2086,11 +2132,13 @@ class LLVM:
         old_ssa = self.ssa_values
         old_ssa_types = self.ssa_types
         old_scope_stack = self.scope_stack
+        old_deferred = self._deferred
         self.locals = {}
         self.local_types = {}
         self.ssa_values = {}
         self.ssa_types = {}
         self.scope_stack = [{}]
+        self._deferred = []
         for llvm_arg, (name, ptype) in zip(func.args, node.params.items()):
             if isinstance(llvm_arg.type, ir.VoidType):
                 self._codegen_error(
@@ -2108,6 +2156,7 @@ class LLVM:
                 self.emit(stmt)
 
         if not self._block_terminated():
+            self._run_deferred()
             # Shutdown GC before main returns
             if node.name == "main" and not self.no_gc:
                 gc_shutdown_fn = self.functions.get("gc_shutdown")
@@ -2133,6 +2182,7 @@ class LLVM:
         self.ssa_values = old_ssa
         self.ssa_types = old_ssa_types
         self.scope_stack = old_scope_stack
+        self._deferred = old_deferred
 
     def _emit_decorated_funcdef(self, node: FuncDef):
         """Emit a decorated function: original as __name, trampoline, and wrapper."""
@@ -2247,6 +2297,7 @@ class LLVM:
     def emit_return(self, node: Return):
         if self._block_terminated():
             return
+        self._run_deferred()
         # Shutdown GC before main returns
         fn_name = self.builder.function.name
         if fn_name == "main" and not self.no_gc:
@@ -2503,7 +2554,7 @@ class LLVM:
             return _DYN_STR
         if ty == "big":
             return _DYN_BIG
-        if ty.endswith("*") or ty.endswith("&"):
+        if ty.endswith(("*", "&")):
             return _DYN_PTR
         return _DYN_INT
 
@@ -2554,7 +2605,7 @@ class LLVM:
             return self.builder.bitcast(bits, _double)
         if ty in ("str", "big", "void*"):
             return self.builder.inttoptr(bits, _i8ptr)
-        if ty.endswith("*") or ty.endswith("&"):
+        if ty.endswith(("*", "&")):
             ptr_ty = self.llvm_type(ty)
             if isinstance(ptr_ty, ir.PointerType):
                 return self.builder.inttoptr(bits, ptr_ty)
@@ -2567,9 +2618,7 @@ class LLVM:
         """True when a node carries a runtime-typed (dynamic) value."""
         if getattr(node, "inferred_type", None) == "dynamic":
             return True
-        if isinstance(node, Variable) and getattr(node, "dynamic", False):
-            return True
-        return False
+        return bool(isinstance(node, Variable) and getattr(node, "dynamic", False))
 
     def _dyn_local_ptr(self, name):
         """Return (creating if needed) the {i32,i64} slot that backs a dynamic local."""
@@ -2665,6 +2714,25 @@ class LLVM:
             return True
         return block.is_terminated
 
+    def _run_deferred(self):
+        """Emit all accumulated deferred statements in LIFO order.
+
+        Called at every function exit point (explicit `return` statements and the
+        implicit end-of-function return). It does NOT clear the accumulated list,
+        so every static exit site of the function emits the full set of defers;
+        at runtime only the exit that is actually reached executes them. The list
+        is reset when the function's own emission completes (emit_funcdef restores
+        the outer value).
+        """
+        if not self._deferred:
+            return
+        for stmt in reversed(self._deferred):
+            if self._block_terminated():
+                break
+            self.emit(stmt)
+            if self._block_terminated():
+                break
+
     @register_emitter(BinOp)
     def emit_binop(self, node):
         if node.op == TokenType.PLUS and self._is_string_concat(node):
@@ -2673,27 +2741,26 @@ class LLVM:
         # Runtime dispatch when either operand is dynamically typed.
         if not self.no_userspace and (
             self._is_dynamic_expr(node.left) or self._is_dynamic_expr(node.right)
+        ) and node.op in (
+            TokenType.PLUS,
+            TokenType.MINUS,
+            TokenType.STAR,
+            TokenType.SLASH,
+            TokenType.SLASH_SLASH,
+            TokenType.PERCENT,
+            TokenType.EQ_EQ,
+            TokenType.NOT_EQ,
+            TokenType.LESS,
+            TokenType.GREATER,
+            TokenType.LESS_EQ,
+            TokenType.GREATER_EQ,
+            TokenType.AMPERSAND,
+            TokenType.PIPE,
+            TokenType.CARET,
+            TokenType.SHL,
+            TokenType.SHR,
         ):
-            if node.op in (
-                TokenType.PLUS,
-                TokenType.MINUS,
-                TokenType.STAR,
-                TokenType.SLASH,
-                TokenType.SLASH_SLASH,
-                TokenType.PERCENT,
-                TokenType.EQ_EQ,
-                TokenType.NOT_EQ,
-                TokenType.LESS,
-                TokenType.GREATER,
-                TokenType.LESS_EQ,
-                TokenType.GREATER_EQ,
-                TokenType.AMPERSAND,
-                TokenType.PIPE,
-                TokenType.CARET,
-                TokenType.SHL,
-                TokenType.SHR,
-            ):
-                return self._emit_dyn_binop(node)
+            return self._emit_dyn_binop(node)
 
         match node.op:
             case TokenType.AND:
@@ -2939,12 +3006,7 @@ class LLVM:
             and self.local_types.get(node.left.name) == "str"
         ):
             return True
-        if (
-            isinstance(node.right, Variable)
-            and self.local_types.get(node.right.name) == "str"
-        ):
-            return True
-        return False
+        return bool(isinstance(node.right, Variable) and self.local_types.get(node.right.name) == "str")
 
     def _emit_dyn_binop(self, node):
         dynop_map = {
@@ -2987,7 +3049,8 @@ class LLVM:
             if f.name == "strlen":
                 self._strlen_fn = f
                 return f
-        fnty = ir.FunctionType(_i32, [_i8ptr])
+        # strlen returns size_t (i64 on every cpyte target), not int.
+        fnty = ir.FunctionType(_i64, [_i8ptr])
         fn = ir.Function(self.module, fnty, "strlen")
         self._strlen_fn = fn
         return fn
@@ -3000,7 +3063,8 @@ class LLVM:
             if f.name == "memcpy":
                 self._memcpy_fn = f
                 return f
-        fnty = ir.FunctionType(_i8ptr, [_i8ptr, _i8ptr, _i32])
+        # n is size_t (i64 on every cpyte target).
+        fnty = ir.FunctionType(_i8ptr, [_i8ptr, _i8ptr, _i64])
         fn = ir.Function(self.module, fnty, "memcpy")
         self._memcpy_fn = fn
         return fn
@@ -3927,6 +3991,8 @@ class LLVM:
 
         len_fn = self._get_strlen_fn()
         length = self.builder.call(len_fn, [iter_ptr])
+        if length.type.width != 32:
+            length = self.builder.trunc(length, _i32)
 
         idx_ptr = self._alloca(_i32, name=f"{var_name}.idx")
         self.builder.store(ir.Constant(_i32, 0), idx_ptr)