mojo-bindgen 0.3.2__tar.gz → 0.3.3__tar.gz

{mojo_bindgen-0.3.2 → mojo_bindgen-0.3.3}/CHANGELOG.md

@@ -2,10 +2,27 @@
 
 All notable changes to this project are documented in this file.
 
+## [0.3.3] - 2026-06-27
+
+### Changed
+
+- Add `mojo-bindgen --version` so scripts and users can inspect the installed
+  package version directly from the CLI.
+- Make `mojo-bindgen` with no arguments print the help message instead of
+  failing on the missing header argument.
+
 ## [0.3.2] - 2026-06-23
 
 ### Changed
 
+- Split struct trait inference from register-passability inference so generated
+  records now derive `Copyable` and `Movable` recursively through named types,
+  fixed arrays, and `UnsafeUnion` arms, keep atomics and flexible-tail records
+  non-copyable/non-movable, and document opaque-storage transfer traits as an
+  experimental default.
+- Preserve typedef-backed integer bitfields such as `uint32_t flags:3` during
+  record lowering, keep their typedef surface names in generated accessors, and
+  stop silently dropping them before bitfield layout/codegen.
 - Simplify and clarify the CLI surface: keep `--public-header` and
   `--clang-arg`, add conventional `-o`, `-I`, `-D`, and `-U` forms, make
   layout-test output explicit with `--layout-tests PATH`, and hide maintainer

{mojo_bindgen-0.3.2 → mojo_bindgen-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mojo-bindgen
-Version: 0.3.2
+Version: 0.3.3
 Summary: Generate Mojo FFI bindings from C headers using libclang
 Project-URL: Homepage, https://github.com/MoSafi2/mojo_bindgen
 Project-URL: Repository, https://github.com/MoSafi2/mojo_bindgen

{mojo_bindgen-0.3.2 → mojo_bindgen-0.3.3}/mojo_bindgen/analysis/mojo/record_policies.py

@@ -27,6 +27,7 @@ from mojo_bindgen.ir import (
     StructMember,
     StructTraits,
     Type,
+    TypeArg,
 )
 
 
@@ -34,6 +35,14 @@ class AssignRecordPoliciesError(ValueError):
     """Raised when late record policy derivation cannot complete safely."""
 
 
+@dataclass(frozen=True)
+class TransferTraits:
+    """Copy and move capability inferred separately from register passability."""
+
+    copyable: bool
+    movable: bool
+
+
 _TRIVIAL_BUILTINS = frozenset(
     builtin for builtin in MojoBuiltin if builtin != MojoBuiltin.UNSUPPORTED
 )
@@ -68,8 +77,10 @@ class PolicyInferencePass:
     def run(self, module: MojoModule) -> MojoModule:
         self._structs = {decl.name: decl for decl in module.decls if isinstance(decl, StructDecl)}
         self._aliases = {decl.name: decl for decl in module.decls if isinstance(decl, AliasDecl)}
-        self._cache: dict[str, MojoPassability] = {}
-        self._computing: set[str] = set()
+        self._passability_cache: dict[str, MojoPassability] = {}
+        self._passability_computing: set[str] = set()
+        self._transfer_cache: dict[str, TransferTraits] = {}
+        self._transfer_computing: set[str] = set()
 
         return replace(
             module,
@@ -80,7 +91,8 @@ class PolicyInferencePass:
         if not isinstance(decl, StructDecl):
             return decl
         passability = self._record_passability(decl.name)
-        if self._has_representable_atomic_storage(decl):
+        transfer_traits = self._record_transfer_traits(decl.name)
+        if self._has_representable_atomic_storage(decl) or decl.flexible_tail is not None:
             return replace(
                 decl,
                 passability=passability,
@@ -91,7 +103,7 @@ class PolicyInferencePass:
         return replace(
             decl,
             passability=passability,
-            traits=self._traits_for_passability(passability),
+            traits=self._traits_for_decl(decl, passability, transfer_traits),
             fieldwise_init=self._is_fieldwise_init_eligible(decl),
         )
 
@@ -109,27 +121,27 @@ class PolicyInferencePass:
         return True
 
     def _record_passability(self, name: str) -> MojoPassability:
-        if name in self._cache:
-            return self._cache[name]
-        if name in self._computing:
+        if name in self._passability_cache:
+            return self._passability_cache[name]
+        if name in self._passability_computing:
             return MojoPassability.MEMORY_ONLY
 
         decl = self._structs.get(name)
         if decl is None or decl.kind != StructKind.PLAIN:
-            self._cache[name] = MojoPassability.MEMORY_ONLY
+            self._passability_cache[name] = MojoPassability.MEMORY_ONLY
             return MojoPassability.MEMORY_ONLY
         if decl.flexible_tail is not None:
-            self._cache[name] = MojoPassability.MEMORY_ONLY
+            self._passability_cache[name] = MojoPassability.MEMORY_ONLY
             return MojoPassability.MEMORY_ONLY
         if self._has_representable_atomic_storage(decl):
-            self._cache[name] = MojoPassability.MEMORY_ONLY
+            self._passability_cache[name] = MojoPassability.MEMORY_ONLY
             return MojoPassability.MEMORY_ONLY
 
-        self._computing.add(name)
+        self._passability_computing.add(name)
         try:
             member_passabilities = [self._member_passability(member) for member in decl.members]
         finally:
-            self._computing.remove(name)
+            self._passability_computing.remove(name)
 
         if all(
             passability == MojoPassability.TRIVIAL_REGISTER_PASSABLE
@@ -148,7 +160,46 @@ class PolicyInferencePass:
         else:
             result = MojoPassability.MEMORY_ONLY
 
-        self._cache[name] = result
+        self._passability_cache[name] = result
+        return result
+
+    def _record_transfer_traits(self, name: str) -> TransferTraits:
+        if name in self._transfer_cache:
+            return self._transfer_cache[name]
+        if name in self._transfer_computing:
+            return TransferTraits(copyable=True, movable=True)
+
+        decl = self._structs.get(name)
+        if decl is None:
+            return TransferTraits(copyable=False, movable=False)
+        if decl.flexible_tail is not None or self._has_representable_atomic_storage(decl):
+            result = TransferTraits(copyable=False, movable=False)
+            self._transfer_cache[name] = result
+            return result
+        if decl.kind != StructKind.PLAIN:
+            result = TransferTraits(copyable=True, movable=True)
+            self._transfer_cache[name] = result
+            return result
+
+        if self._has_opaque_storage(decl):
+            # Experimental default: byte-backed fallback storage stays movable/copyable
+            # so generated wrappers remain usable while opaque record semantics are still
+            # being validated across real headers.
+            result = TransferTraits(copyable=True, movable=True)
+            self._transfer_cache[name] = result
+            return result
+
+        self._transfer_computing.add(name)
+        try:
+            member_traits = [self._member_transfer_traits(member) for member in decl.members]
+        finally:
+            self._transfer_computing.remove(name)
+
+        result = TransferTraits(
+            copyable=all(traits.copyable for traits in member_traits),
+            movable=all(traits.movable for traits in member_traits),
+        )
+        self._transfer_cache[name] = result
         return result
 
     def _member_passability(self, member: StructMember) -> MojoPassability:
@@ -164,6 +215,19 @@ class PolicyInferencePass:
             f"unsupported StructMember for passability: {type(member).__name__!r}"
         )
 
+    def _member_transfer_traits(self, member: StructMember) -> TransferTraits:
+        if isinstance(member, StoredMember):
+            return self._type_transfer_traits(member.type)
+        if isinstance(member, BitfieldGroupMember):
+            return self._type_transfer_traits(member.storage_type)
+        if isinstance(member, PaddingMember):
+            return TransferTraits(copyable=True, movable=True)
+        if isinstance(member, OpaqueStorageMember):
+            return TransferTraits(copyable=True, movable=True)
+        raise AssignRecordPoliciesError(
+            f"unsupported StructMember for transfer traits: {type(member).__name__!r}"
+        )
+
     def _type_passability(self, t: Type) -> MojoPassability:
         if isinstance(t, BuiltinType):
             if t.name in _TRIVIAL_BUILTINS:
@@ -202,12 +266,77 @@ class PolicyInferencePass:
         raise AssignRecordPoliciesError(f"unsupported Type for passability: {type(t).__name__!r}")
 
     @staticmethod
-    def _traits_for_passability(passability: MojoPassability) -> list[StructTraits]:
+    def _passability_traits(passability: MojoPassability) -> list[StructTraits]:
         if passability == MojoPassability.TRIVIAL_REGISTER_PASSABLE:
             return [StructTraits.TRIVIAL_REGISTER_PASSABLE]
         if passability == MojoPassability.REGISTER_PASSABLE:
             return [StructTraits.REGISTER_PASSABLE]
-        return [StructTraits.COPYABLE, StructTraits.MOVABLE]
+        return []
+
+    def _type_transfer_traits(self, t: Type) -> TransferTraits:
+        if isinstance(t, BuiltinType):
+            supported = t.name in _TRIVIAL_BUILTINS
+            return TransferTraits(copyable=supported, movable=supported)
+        if isinstance(t, FunctionPtr):
+            return TransferTraits(copyable=True, movable=True)
+        if isinstance(t, Pointer):
+            return TransferTraits(copyable=True, movable=True)
+        if isinstance(t, Array):
+            if t.array_kind != "fixed" or t.size is None:
+                return TransferTraits(copyable=False, movable=False)
+            return self._type_transfer_traits(t.element)
+        if isinstance(t, ParametricType):
+            if t.base == ParametricBase.ATOMIC:
+                return TransferTraits(copyable=False, movable=False)
+            if t.base in (ParametricBase.SIMD, ParametricBase.COMPLEX_SIMD):
+                return TransferTraits(copyable=True, movable=True)
+            if t.base == ParametricBase.UNSAFE_UNION:
+                arg_traits = [self._transfer_traits_for_parametric_arg(arg) for arg in t.args]
+                return TransferTraits(
+                    copyable=all(traits.copyable for traits in arg_traits),
+                    movable=all(traits.movable for traits in arg_traits),
+                )
+            return TransferTraits(copyable=False, movable=False)
+        if isinstance(t, NamedType):
+            if t.name in _TRIVIAL_NAMED_TYPES:
+                return TransferTraits(copyable=True, movable=True)
+
+            struct_decl = self._structs.get(t.name)
+            if struct_decl is not None:
+                return self._record_transfer_traits(struct_decl.name)
+
+            alias_decl = self._aliases.get(t.name)
+            if alias_decl is None:
+                return TransferTraits(copyable=False, movable=False)
+            if alias_decl.kind == AliasKind.CALLBACK_SIGNATURE:
+                return TransferTraits(copyable=True, movable=True)
+            if alias_decl.kind in (AliasKind.TYPE_ALIAS, AliasKind.UNION_LAYOUT):
+                if alias_decl.type_value is None:
+                    return TransferTraits(copyable=False, movable=False)
+                return self._type_transfer_traits(alias_decl.type_value)
+            return TransferTraits(copyable=False, movable=False)
+        raise AssignRecordPoliciesError(
+            f"unsupported Type for transfer traits: {type(t).__name__!r}"
+        )
+
+    def _transfer_traits_for_parametric_arg(self, arg) -> TransferTraits:
+        if isinstance(arg, TypeArg):
+            return self._type_transfer_traits(arg.type)
+        return TransferTraits(copyable=True, movable=True)
+
+    def _traits_for_decl(
+        self,
+        decl: StructDecl,
+        passability: MojoPassability,
+        transfer_traits: TransferTraits,
+    ) -> list[StructTraits]:
+        traits = list(self._passability_traits(passability))
+        if decl.flexible_tail is None and not self._has_representable_atomic_storage(decl):
+            if transfer_traits.copyable:
+                traits.append(StructTraits.COPYABLE)
+            if transfer_traits.movable:
+                traits.append(StructTraits.MOVABLE)
+        return traits
 
     @staticmethod
     def _has_opaque_storage(decl: StructDecl) -> bool:

{mojo_bindgen-0.3.2 → mojo_bindgen-0.3.3}/mojo_bindgen/cli.py

@@ -10,6 +10,7 @@ from typing import Annotated, Literal
 import typer
 from rich.console import Console
 
+from mojo_bindgen import __version__
 from mojo_bindgen.orchestrator import BindgenOptions, BindgenOrchestrator
 from mojo_bindgen.parsing.frontend import ClangOptions
 from mojo_bindgen.parsing.parser import ParseError
@@ -20,6 +21,12 @@ LinkModeOption = Literal["external-call", "owned-dl-handle"]
 DiagnosticsMode = Literal["text", "json", "silent"]
 
 
+def _version_callback(value: bool) -> None:
+    if value:
+        sys.stdout.write(f"mojo-bindgen {__version__}\n")
+        raise typer.Exit()
+
+
 def run(
     header: Annotated[
         Path,
@@ -237,6 +244,15 @@ def run(
             rich_help_panel="Output",
         ),
     ] = False,
+    version: Annotated[
+        bool,
+        typer.Option(
+            "--version",
+            callback=_version_callback,
+            is_eager=True,
+            help="Show the mojo-bindgen version and exit.",
+        ),
+    ] = False,
 ) -> int:
     """Generate Mojo FFI from a C header using libclang.
 
@@ -373,6 +389,8 @@ def _format_diagnostic(d) -> str:
 
 def main(argv: list[str] | None = None) -> int:
     cli_args = argv if argv is not None else sys.argv[1:]
+    if not cli_args:
+        cli_args = ["--help"]
     previous_argv = sys.argv[:]
     sys.argv = ["mojo-bindgen", *cli_args]
     try:

{mojo_bindgen-0.3.2 → mojo_bindgen-0.3.3}/mojo_bindgen/parsing/lowering/record_lowering.py

@@ -12,7 +12,18 @@ from typing import cast
 
 import clang.cindex as cx
 
-from mojo_bindgen.ir import Array, FamPattern, Field, IntType, Struct, StructRef, Type
+from mojo_bindgen.ir import (
+    Array,
+    AtomicType,
+    FamPattern,
+    Field,
+    IntType,
+    QualifiedType,
+    Struct,
+    StructRef,
+    Type,
+    TypeRef,
+)
 from mojo_bindgen.parsing.diagnostics import ParserDiagnosticSink
 from mojo_bindgen.parsing.doc_comments import cursor_doc_comment
 from mojo_bindgen.parsing.lowering.type_lowering import TypeContext, TypeLowerer
@@ -307,7 +318,14 @@ class RecordLowerer:
         """Lower one normalized field site into one IR field."""
         if site.is_bitfield:
             backing = self.type_lowerer.lower(site.field_type, TypeContext.FIELD)
-            if not isinstance(backing, IntType):
+            integer_backing = self._peel_bitfield_backing(backing)
+            if integer_backing is None:
+                if site.field_cursor is not None:
+                    self.diagnostics.add_cursor_diag(
+                        "warning",
+                        site.field_cursor,
+                        "bitfield backing type is not an integer after typedef/cv/atomic peeling; field skipped",
+                    )
                 return None
             return Field(
                 name=site.name,
@@ -353,6 +371,22 @@ class RecordLowerer:
             ),
         )
 
+    @staticmethod
+    def _peel_bitfield_backing(field_type: Type) -> IntType | None:
+        """Unwrap layout-transparent wrappers to find the integer bitfield backing type."""
+        while True:
+            if isinstance(field_type, TypeRef):
+                field_type = field_type.canonical
+                continue
+            if isinstance(field_type, QualifiedType):
+                field_type = field_type.unqualified
+                continue
+            if isinstance(field_type, AtomicType):
+                field_type = field_type.value_type
+                continue
+            break
+        return field_type if isinstance(field_type, IntType) else None
+
     def _lower_field_site_type(self, site: FieldSite) -> Type:
         """Lower the type of one normalized field site."""
         if site.attached_record is not None:

{mojo_bindgen-0.3.2 → mojo_bindgen-0.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mojo-bindgen"
-version = "0.3.2"
+version = "0.3.3"
 description = "Generate Mojo FFI bindings from C headers using libclang"
 readme = "README.md"
 license = "MIT"