wip

Author: pshirshov

pyjopa/ast.py

@@ -85,8 +85,13 @@ class Modifier(ASTNode):
     annotation: Optional[Annotation]
 
 
-class TypeDeclaration(ASTNode):
-    """Base class for type declarations."""
+class ClassBodyDeclaration(ASTNode):
+    """Base for class body declarations."""
+    pass
+
+
+class TypeDeclaration(ClassBodyDeclaration):
+    """Base class for type declarations (can also be nested in classes)."""
     pass
 
 

pyjopa/classfile.py

@@ -624,6 +624,15 @@ def _write_constant_value_attribute(cp: ConstantPool, out: bytearray, const: tup
     out.extend(struct.pack(">H", idx))
 
 
+@dataclass
+class InnerClassInfo:
+    """Represents an entry in the InnerClasses attribute."""
+    inner_class: str  # Internal name like "Outer$Inner"
+    outer_class: Optional[str]  # Internal name like "Outer", None for anonymous/local
+    inner_name: Optional[str]  # Simple name like "Inner", None for anonymous
+    access_flags: int  # Access flags for the inner class
+
+
 class ClassFile:
     """Represents a Java class file."""
 
@@ -641,6 +650,7 @@ def __init__(self, name: str, super_class: str = "java/lang/Object",
         self.cp = ConstantPool()
         self.signature: Optional[str] = None
         self.annotations: list[AnnotationInfo] = []
+        self.inner_classes: list[InnerClassInfo] = []
 
     def add_method(self, method: MethodInfo):
         self.methods.append(method)
@@ -738,6 +748,16 @@ def to_bytes(self) -> bytes:
                     for ann in param_anns:
                         self.cp.add_utf8(ann.type_descriptor)
 
+        # Pre-add "InnerClasses" attribute name and class names
+        if self.inner_classes:
+            self.cp.add_utf8("InnerClasses")
+            for ic in self.inner_classes:
+                self.cp.add_class(ic.inner_class)
+                if ic.outer_class:
+                    self.cp.add_class(ic.outer_class)
+                if ic.inner_name:
+                    self.cp.add_utf8(ic.inner_name)
+
         # Magic number
         out.extend(struct.pack(">I", self.MAGIC))
 
@@ -777,14 +797,41 @@ def to_bytes(self) -> bytes:
             attr_count += 1
         if self.annotations:
             attr_count += 1
+        if self.inner_classes:
+            attr_count += 1
         out.extend(struct.pack(">H", attr_count))
         if self.signature:
             _write_signature_attribute(self.cp, out, self.signature)
         if self.annotations:
             write_annotations_attribute(self.cp, out, "RuntimeVisibleAnnotations", self.annotations)
+        if self.inner_classes:
+            self._write_inner_classes_attribute(self.cp, out)
 
         return bytes(out)
 
+    def _write_inner_classes_attribute(self, cp: ConstantPool, out: bytearray):
+        """Write the InnerClasses attribute."""
+        attr_name_idx = cp.add_utf8("InnerClasses")
+        out.extend(struct.pack(">H", attr_name_idx))
+
+        # Attribute length: 2 (number_of_classes) + 8 * number_of_classes
+        attr_len = 2 + 8 * len(self.inner_classes)
+        out.extend(struct.pack(">I", attr_len))
+
+        # Number of classes
+        out.extend(struct.pack(">H", len(self.inner_classes)))
+
+        # Write each inner class entry
+        for ic in self.inner_classes:
+            inner_class_idx = cp.add_class(ic.inner_class)
+            outer_class_idx = cp.add_class(ic.outer_class) if ic.outer_class else 0
+            inner_name_idx = cp.add_utf8(ic.inner_name) if ic.inner_name else 0
+
+            out.extend(struct.pack(">H", inner_class_idx))
+            out.extend(struct.pack(">H", outer_class_idx))
+            out.extend(struct.pack(">H", inner_name_idx))
+            out.extend(struct.pack(">H", ic.access_flags))
+
     def write(self, path: str):
         with open(path, "wb") as f:
             f.write(self.to_bytes())
@@ -896,6 +943,16 @@ def ldc_string(self, value: str):
             self.code.extend(struct.pack(">H", idx))
         self._push()
 
+    def ldc_class(self, class_name: str):
+        """Load a class constant (Class<?> object) onto the stack."""
+        idx = self.cp.add_class(class_name)
+        if idx <= 255:
+            self._emit(Opcode.LDC, idx)
+        else:
+            self._emit(Opcode.LDC_W)
+            self.code.extend(struct.pack(">H", idx))
+        self._push()
+
     def iload(self, slot: int):
         if slot <= 3:
             self._emit(Opcode.ILOAD_0 + slot)
@@ -1269,6 +1326,13 @@ def instanceof_(self, class_name: str):
         self._pop()
         self._push()
 
+    def checkcast(self, class_name: str):
+        """Cast reference to a class type. Pops reference, pushes same reference (typed)."""
+        idx = self.cp.add_class(class_name)
+        self._emit(Opcode.CHECKCAST)
+        self.code.extend(struct.pack(">H", idx))
+        # Stack stays the same (pop ref, push ref)
+
     def newarray(self, atype: int):
         """Create new primitive array. atype: T_BOOLEAN=4, T_CHAR=5, T_FLOAT=6, T_DOUBLE=7, T_BYTE=8, T_SHORT=9, T_INT=10, T_LONG=11"""
         self._emit(Opcode.NEWARRAY, atype)

pyjopa/cli.py

@@ -28,6 +28,136 @@ def parse_command(args):
             sys.exit(1)
 
 
+def _get_file_dependencies(source_file: Path, parser) -> tuple[str, set[str]]:
+    """Extract package and imported types from a source file.
+    Returns: (package_name, set_of_imported_types)"""
+    ast = parser.parse_file(str(source_file))
+
+    package = ast.package.name if ast.package else ""
+    imported_types = set()
+
+    # Collect imported types (simple names only, from same or imported packages)
+    for imp in ast.imports:
+        if not imp.is_static and not imp.is_wildcard:
+            # Single-type import: java.util.List -> List
+            simple_name = imp.name.split(".")[-1]
+            imported_types.add(simple_name)
+
+    return package, imported_types
+
+
+def _topological_sort(files: list[Path], parser) -> list[Path]:
+    """Sort files in dependency order using topological sort.
+    Files that define types used by other files come first."""
+    from collections import defaultdict, deque
+
+    # Map: package.TypeName -> source file
+    type_to_file = {}
+    # Map: source file -> set of types it depends on
+    file_deps = {}
+
+    # First pass: identify what types each file defines
+    for f in files:
+        ast = parser.parse_file(str(f))
+        package = ast.package.name if ast.package else ""
+
+        for type_decl in ast.types:
+            type_name = type_decl.name
+            full_name = f"{package}.{type_name}" if package else type_name
+            type_to_file[full_name] = f
+
+    # Second pass: identify dependencies
+    for f in files:
+        ast = parser.parse_file(str(f))
+        package = ast.package.name if ast.package else ""
+        deps = set()
+
+        # Add dependencies from imports
+        for imp in ast.imports:
+            if not imp.is_static and not imp.is_wildcard:
+                # Check if this import is for a type in our compilation set
+                imported_type = imp.name
+                if imported_type in type_to_file:
+                    deps.add(imported_type)
+                else:
+                    deps.add(imp.name)
+
+        # For same-package dependencies, check if type names appear in source
+        # This is a heuristic for detecting usage without full semantic analysis
+        source_text = f.read_text()
+        for full_type_name, type_file in type_to_file.items():
+            if type_file != f:  # Don't depend on ourselves
+                simple_name = full_type_name.split(".")[-1]
+                # Check if type name appears in source (crude but effective)
+                if package:
+                    # Same package?
+                    type_package = ".".join(full_type_name.split(".")[:-1])
+                    if type_package == package and simple_name in source_text:
+                        deps.add(full_type_name)
+
+        # Check if types defined in this file extend/implement types in other files
+        for type_decl in ast.types:
+            from pyjopa.ast import ClassDeclaration, InterfaceDeclaration, EnumDeclaration
+
+            # Get superclass and interfaces
+            if isinstance(type_decl, ClassDeclaration) and type_decl.extends:
+                # extends Type -> might be in same package
+                super_name = type_decl.extends.name if hasattr(type_decl.extends, 'name') else str(type_decl.extends)
+                # Try same package first
+                if package:
+                    candidate = f"{package}.{super_name}"
+                    if candidate in type_to_file:
+                        deps.add(candidate)
+                else:
+                    if super_name in type_to_file:
+                        deps.add(super_name)
+
+            if isinstance(type_decl, (ClassDeclaration, EnumDeclaration)):
+                for iface in type_decl.implements:
+                    iface_name = iface.name if hasattr(iface, 'name') else str(iface)
+                    if package:
+                        candidate = f"{package}.{iface_name}"
+                        if candidate in type_to_file:
+                            deps.add(candidate)
+                    else:
+                        if iface_name in type_to_file:
+                            deps.add(iface_name)
+
+        file_deps[f] = deps
+
+    # Build adjacency list: file -> files that depend on it
+    in_degree = {f: 0 for f in files}
+    adj = defaultdict(list)
+
+    for file, deps in file_deps.items():
+        for dep in deps:
+            if dep in type_to_file:
+                dep_file = type_to_file[dep]
+                if dep_file != file:  # Skip self-dependencies
+                    adj[dep_file].append(file)
+                    in_degree[file] += 1
+
+    # Topological sort using Kahn's algorithm
+    queue = deque([f for f in files if in_degree[f] == 0])
+    result = []
+
+    while queue:
+        current = queue.popleft()
+        result.append(current)
+
+        for neighbor in adj[current]:
+            in_degree[neighbor] -= 1
+            if in_degree[neighbor] == 0:
+                queue.append(neighbor)
+
+    # Check for cycles
+    if len(result) != len(files):
+        # Circular dependency detected - return original order
+        return files
+
+    return result
+
+
 def compile_command(args):
     """Compile Java files to .class bytecode."""
     from .parser import Java8Parser
@@ -43,15 +173,36 @@ def compile_command(args):
             classpath.add_rt_jar()
         except FileNotFoundError:
             print("Warning: rt.jar not found, method resolution may be limited", file=sys.stderr)
+    else:
+        classpath = ClassPath()
 
     output_dir = Path(args.output) if args.output else Path(".")
+
+    # Create output directory first
     output_dir.mkdir(parents=True, exist_ok=True)
 
+    # Add custom classpath entries
+    if args.classpath:
+        import os
+        for entry in args.classpath.split(os.pathsep):
+            if entry:
+                classpath.add_path(entry)
+
+    # Add output directory to classpath so previously compiled classes can be found
+    if classpath:
+        classpath.add_path(str(output_dir.absolute()))
+
+    # Sort files in dependency order if multiple files
+    file_paths = [Path(f) for f in args.files]
+    if len(file_paths) > 1:
+        file_paths = _topological_sort(file_paths, parser)
+        if args.verbose:
+            print(f"Compilation order: {[str(f) for f in file_paths]}")
+
     total_classes = 0
-    for source_file in args.files:
-        path = Path(source_file)
+    for path in file_paths:
         if not path.exists():
-            print(f"Error: File not found: {source_file}", file=sys.stderr)
+            print(f"Error: File not found: {path}", file=sys.stderr)
             sys.exit(1)
 
         try:
@@ -61,21 +212,22 @@ def compile_command(args):
 
             for name, bytecode in class_files.items():
                 class_path = output_dir / f"{name}.class"
+                class_path.parent.mkdir(parents=True, exist_ok=True)
                 with open(class_path, "wb") as f:
                     f.write(bytecode)
                 if args.verbose:
                     print(f"Wrote {class_path}")
                 total_classes += 1
 
         except Exception as e:
-            print(f"Error compiling {source_file}: {e}", file=sys.stderr)
+            print(f"Error compiling {path}: {e}", file=sys.stderr)
             sys.exit(1)
 
     if classpath:
         classpath.close()
 
     if not args.quiet:
-        print(f"Compiled {len(args.files)} file(s) to {total_classes} class(es)")
+        print(f"Compiled {len(file_paths)} file(s) to {total_classes} class(es)")
 
 
 def main():
@@ -113,6 +265,10 @@ def main():
         "-o", "--output",
         help="Output directory for .class files (default: current directory)",
     )
+    compile_parser.add_argument(
+        "-cp", "--classpath",
+        help="Additional classpath entries (colon-separated paths to .jar files or directories)",
+    )
     compile_parser.add_argument(
         "--no-rt",
         action="store_true",

pyjopa/codegen/boxing.py

@@ -88,5 +88,30 @@ def emit_conversion(self, source_type: JType, target_type: JType, builder: Bytec
             return self.emit_boxing(source_type, builder)
         elif self.needs_unboxing(source_type, target_type):
             return self.emit_unboxing(source_type, builder)
+        # Box primitive to reference type if needed
+        elif isinstance(source_type, PrimitiveJType) and isinstance(target_type, ClassJType):
+            # Box the primitive to its wrapper
+            boxed_type = self.emit_boxing(source_type, builder)
+            # Then checkcast to target if needed
+            if boxed_type.internal_name() != target_type.internal_name():
+                builder.checkcast(target_type.internal_name())
+                return target_type
+            return boxed_type
+        elif self._needs_checkcast(source_type, target_type):
+            builder.checkcast(target_type.internal_name())
+            return target_type
         return source_type
 
+    def _needs_checkcast(self, source_type: JType, target_type: JType) -> bool:
+        """Check if a checkcast is needed from source to target."""
+        # Skip if same type
+        if source_type == target_type:
+            return False
+        # Skip primitives
+        if not isinstance(source_type, ClassJType) or not isinstance(target_type, ClassJType):
+            return False
+        # Need checkcast if source is Object or a supertype of target
+        # For simplicity, if they're different reference types, we need checkcast
+        # (proper implementation would check the class hierarchy)
+        return True
+