Add naming transformer & remove source_path

Introduce NamingConfig and NameTransformer to support configurable naming conventions for files, types, enums, enum values, functions, methods, classes, fields, params, constants and aliases. Add a new codegen/naming.py with style helpers (snake/camel/pascal/kebab/screaming) and integrate the transformer into TypeMapper and generator (including output filename computation and Jinja context). Remove the obsolete source_path field from IR model, serializer, and mapped objects and switch normalizer to use a unified items list (and sort items by name) instead of maintaining separate per-kind buckets. Update example config and templates to demonstrate naming settings and minor template whitespace fixes.

Author: lijy91

tools/bindgen/codegen/context.py

@@ -19,6 +19,7 @@
     IRStruct,
     IRType,
 )
+from .naming import NameTransformer
 
 
 @dataclass
@@ -56,7 +57,6 @@ class MappedField:
 
     name: str
     type: MappedType
-    source_path: Optional[str] = None
     raw: Optional[IRField] = None
 
 
@@ -79,20 +79,26 @@ class MappedStruct:
     name: str = ""
     fields: List[MappedField] = field(default_factory=list)
     qualified_name: Optional[str] = None
-    source_path: Optional[str] = None
     raw: Optional[IRStruct] = None
 
 
+@dataclass
+class MappedEnumValue:
+    """An enum value."""
+
+    name: str = ""
+    value: int = 0
+
+
 @dataclass
 class MappedEnum:
     """An enum (no type mapping needed, but consistent interface)."""
 
     kind: str = "enum"
     name: str = ""
-    values: List[Dict[str, Any]] = field(default_factory=list)
+    values: List[MappedEnumValue] = field(default_factory=list)
     scoped: bool = False
     qualified_name: Optional[str] = None
-    source_path: Optional[str] = None
     raw: Optional[IREnum] = None
 
 
@@ -103,7 +109,6 @@ class MappedAlias:
     kind: str = "alias"
     name: str = ""
     target: Optional[MappedType] = None
-    source_path: Optional[str] = None
     raw: Optional[IRAlias] = None
 
 
@@ -118,7 +123,6 @@ class MappedFunction:
     callconv: Optional[str] = None
     variadic: bool = False
     qualified_name: Optional[str] = None
-    source_path: Optional[str] = None
     raw: Optional[IRFunction] = None
 
 
@@ -134,7 +138,6 @@ class MappedMethod:
     const: bool = False
     access: Optional[str] = None
     variadic: bool = False
-    source_path: Optional[str] = None
     raw: Optional[IRMethod] = None
 
 
@@ -148,7 +151,6 @@ class MappedClass:
     methods: List[MappedMethod] = field(default_factory=list)
     bases: List[str] = field(default_factory=list)
     qualified_name: Optional[str] = None
-    source_path: Optional[str] = None
     raw: Optional[IRClass] = None
 
 
@@ -160,7 +162,6 @@ class MappedConstant:
     name: str = ""
     type: Optional[MappedType] = None
     value: Any = 0
-    source_path: Optional[str] = None
     raw: Optional[IRConstant] = None
 
 
@@ -213,6 +214,7 @@ class TypeMapper:
 
     def __init__(self, config: MappingConfig):
         self.config = config
+        self.namer = NameTransformer(config.naming)
 
     def map_type(self, ir_type: Optional[IRType]) -> MappedType:
         """Map an IRType to a MappedType."""
@@ -402,16 +404,15 @@ def _lookup_type(self, type_name: str, is_const: bool = False) -> str:
     def map_field(self, ir_field: IRField) -> MappedField:
         """Map an IRField to a MappedField."""
         return MappedField(
-            name=ir_field.name,
+            name=self.namer.field_name(ir_field.name),
             type=self.map_type(ir_field.type),
-            source_path=ir_field.source_path,
             raw=ir_field,
         )
 
     def map_param(self, ir_param: IRParam) -> MappedParam:
         """Map an IRParam to a MappedParam."""
         return MappedParam(
-            name=ir_param.name,
+            name=self.namer.param_name(ir_param.name),
             type=self.map_type(ir_param.type),
             nullable=ir_param.nullable,
             direction=ir_param.direction,
@@ -422,85 +423,84 @@ def map_struct(self, ir_struct: IRStruct) -> MappedStruct:
         """Map an IRStruct to a MappedStruct."""
         return MappedStruct(
             kind="struct",
-            name=ir_struct.name,
+            name=self.namer.type_name(ir_struct.name),
             fields=[self.map_field(f) for f in ir_struct.fields],
             qualified_name=ir_struct.qualified_name,
-            source_path=ir_struct.source_path,
             raw=ir_struct,
         )
 
     def map_enum(self, ir_enum: IREnum) -> MappedEnum:
         """Map an IREnum to a MappedEnum."""
         return MappedEnum(
             kind="enum",
-            name=ir_enum.name,
-            values=[{"name": v.name, "value": v.value} for v in ir_enum.values],
+            name=self.namer.enum_name(ir_enum.name),
+            values=[
+                MappedEnumValue(
+                    name=self.namer.enum_value_name(v.name),
+                    value=v.value,
+                )
+                for v in ir_enum.values
+            ],
             scoped=ir_enum.scoped,
             qualified_name=ir_enum.qualified_name,
-            source_path=ir_enum.source_path,
             raw=ir_enum,
         )
 
     def map_alias(self, ir_alias: IRAlias) -> MappedAlias:
         """Map an IRAlias to a MappedAlias."""
         return MappedAlias(
             kind="alias",
-            name=ir_alias.name,
+            name=self.namer.alias_name(ir_alias.name),
             target=self.map_type(ir_alias.target),
-            source_path=ir_alias.source_path,
             raw=ir_alias,
         )
 
     def map_function(self, ir_func: IRFunction) -> MappedFunction:
         """Map an IRFunction to a MappedFunction."""
         return MappedFunction(
             kind="function",
-            name=ir_func.name,
+            name=self.namer.function_name(ir_func.name),
             return_type=self.map_type(ir_func.return_type),
             params=[self.map_param(p) for p in ir_func.params],
             callconv=ir_func.callconv,
             variadic=ir_func.variadic,
             qualified_name=ir_func.qualified_name,
-            source_path=ir_func.source_path,
             raw=ir_func,
         )
 
     def map_method(self, ir_method: IRMethod) -> MappedMethod:
         """Map an IRMethod to a MappedMethod."""
         return MappedMethod(
-            name=ir_method.name,
+            name=self.namer.method_name(ir_method.name),
             return_type=self.map_type(ir_method.return_type),
             params=[self.map_param(p) for p in ir_method.params],
             method_kind=ir_method.kind,
             static=ir_method.static,
             const=ir_method.const,
             access=ir_method.access,
             variadic=ir_method.variadic,
-            source_path=ir_method.source_path,
             raw=ir_method,
         )
 
     def map_class(self, ir_class: IRClass) -> MappedClass:
         """Map an IRClass to a MappedClass."""
         return MappedClass(
             kind="class",
-            name=ir_class.name,
+            name=self.namer.class_name(ir_class.name),
             fields=[self.map_field(f) for f in ir_class.fields],
             methods=[self.map_method(m) for m in ir_class.methods],
             bases=ir_class.bases,
             qualified_name=ir_class.qualified_name,
-            source_path=ir_class.source_path,
             raw=ir_class,
         )
 
     def map_constant(self, ir_const: IRConstant) -> MappedConstant:
         """Map an IRConstant to a MappedConstant."""
         return MappedConstant(
             kind="constant",
-            name=ir_const.name,
+            name=self.namer.constant_name(ir_const.name),
             type=self.map_type(ir_const.type),
             value=ir_const.value,
-            source_path=ir_const.source_path,
             raw=ir_const,
         )
 
@@ -535,12 +535,14 @@ def build_context(module: IRModule, mapping: MappingConfig) -> Dict[str, Any]:
 
     The context provides:
     - Mapped data with types already converted to target language
+    - Names transformed according to naming config
     - Items in declaration order (via 'items' list)
     - Filtered accessors (types, enums, functions, etc.)
     - Raw IR data accessible via .raw attribute on each item
     - Global raw module accessible via 'raw' key
     """
     mapper = TypeMapper(mapping)
+    namer = NameTransformer(mapping.naming)
 
     files = module.files
     sorted_paths = sorted(files.keys())
@@ -583,6 +585,8 @@ def build_context(module: IRModule, mapping: MappingConfig) -> Dict[str, Any]:
         "constants": constants,
         "aliases": aliases,
         "mapping": mapping,
+        # Name transformer for custom transformations in templates
+        "namer": namer,
         # Raw IR data for direct access
         "raw": module,
     }

tools/bindgen/codegen/generator.py

@@ -4,8 +4,9 @@
 from typing import Any, Dict
 
 from ..config import BindgenConfig
-from ..ir.model import IRFile, IRModule
+from ..ir.model import IRModule
 from .context import MappedFile, build_context
+from .naming import NameTransformer
 
 
 def _load_jinja():
@@ -34,8 +35,10 @@ def _build_file_context(
         "files": global_context["files"],
         "file_paths": global_context["file_paths"],
         "mapping": global_context["mapping"],
+        "namer": global_context["namer"],
         "raw": global_context["raw"],
         # All items (for cross-referencing)
+        "all_items": global_context["items"],
         "all_types": global_context["types"],
         "all_enums": global_context["enums"],
         "all_functions": global_context["functions"],
@@ -49,21 +52,15 @@ def _build_file_context(
         "file_name": p.name,
         "file_stem": p.stem,
         "file_ext": p.suffix,
+        "items": mapped_file.items,
         "types": mapped_file.types,
         "enums": mapped_file.enums,
         "functions": mapped_file.functions,
         "classes": mapped_file.classes,
         "constants": mapped_file.constants,
         "aliases": mapped_file.aliases,
         # Convenience flags
-        "is_empty": (
-            not mapped_file.types
-            and not mapped_file.enums
-            and not mapped_file.functions
-            and not mapped_file.classes
-            and not mapped_file.constants
-            and not mapped_file.aliases
-        ),
+        "is_empty": not mapped_file.items,
         "has_types": bool(mapped_file.types),
         "has_enums": bool(mapped_file.enums),
         "has_functions": bool(mapped_file.functions),
@@ -77,6 +74,7 @@ def _compute_output_path(
     ir_file_path: str,
     template_name: str,
     out_dir: Path,
+    namer: NameTransformer,
 ) -> Path:
     """
     Compute output path from IR file path and template name.
@@ -85,15 +83,20 @@ def _compute_output_path(
     - IR path: src/foundation/geometry.h
     - Template: file/dart.j2 -> out/src/foundation/geometry.dart
     - Template: file/rs.j2 -> out/src/foundation/geometry.rs
+
+    File name is transformed according to naming config.
     """
     from pathlib import PurePosixPath
 
     ir_path = PurePosixPath(ir_file_path)
     # Template stem becomes the new extension
     template_stem = Path(template_name).stem  # e.g., "dart" from "dart.j2"
 
-    # Build output path: out_dir / ir_dir / ir_stem.template_stem
-    output_name = f"{ir_path.stem}.{template_stem}"
+    # Apply naming transformation to the file stem
+    transformed_stem = namer.file_name(ir_path.stem)
+
+    # Build output path: out_dir / ir_dir / transformed_stem.template_stem
+    output_name = f"{transformed_stem}.{template_stem}"
     output_path = out_dir / ir_path.parent / output_name
 
     return output_path
@@ -129,6 +132,7 @@ def generate_bindings(
 
     # Build context with preprocessed (mapped) data
     global_context = build_context(module, cfg.mapping)
+    namer = global_context["namer"]
 
     # 1. Render global templates (template/*.j2)
     for template_path in config_template_root.glob("*.j2"):
@@ -151,7 +155,7 @@ def generate_bindings(
             for template_path in file_templates:
                 template = env.get_template(f"file/{template_path.name}")
                 output_path = _compute_output_path(
-                    ir_file_path, template_path.name, out_dir
+                    ir_file_path, template_path.name, out_dir, namer
                 )
 
                 # Create output directory if needed