apisec-code-bolt 0.1.0__py3-none-any.whl

apisec_code_bolt/parsing/jvm/type_resolver.py

@@ -0,0 +1,422 @@
+"""
+Java type resolver for cross-file type resolution.
+
+Implements the TypeResolver protocol for Java projects.
+Builds a symbol table from parsed Java files and resolves:
+- Simple class names via import declarations
+- Qualified names directly
+- Same-package implicit visibility (no import required)
+- Inheritance chains for model detection
+- Generic type parameters (List<User> → User)
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from pathlib import Path
+
+from ..base import ParsedClass, ParsedFile
+from ..services import ResolvedField, ResolvedType
+
+logger = logging.getLogger(__name__)
+
+# Strip Java generic type parameters: "List<User>" → "List", "Map<K,V>" → "Map"
+_GENERIC_RE = re.compile(r"<[^>]*>")
+
+# Annotations that indicate a class is a "model" (DTO, entity, value object)
+_MODEL_ANNOTATIONS = frozenset(
+    {
+        # JPA / Hibernate
+        "Entity",
+        "Embeddable",
+        "MappedSuperclass",
+        # Lombok
+        "Data",
+        "Value",
+        # Jackson
+        "JsonProperty",
+        # Spring
+        "RequestBody",
+        "ResponseBody",
+        # Generic / custom
+        "DTO",
+        "Record",
+    }
+)
+
+# Annotations that indicate a Spring-managed bean
+_BEAN_ANNOTATIONS = frozenset(
+    {
+        "Component",
+        "Service",
+        "Repository",
+        "Controller",
+        "RestController",
+        "Configuration",
+        "Bean",
+    }
+)
+
+# Built-in Java types that are never in the symbol table
+_JAVA_BUILTINS = frozenset(
+    {
+        "String",
+        "Integer",
+        "Long",
+        "Double",
+        "Float",
+        "Boolean",
+        "Byte",
+        "Short",
+        "Character",
+        "Object",
+        "Number",
+        "Comparable",
+        "Serializable",
+        "Iterable",
+        "Collection",
+        "List",
+        "Set",
+        "Map",
+        "Queue",
+        "Deque",
+        "ArrayList",
+        "LinkedList",
+        "HashMap",
+        "HashSet",
+        "TreeMap",
+        "TreeSet",
+        "Optional",
+        "void",
+        "int",
+        "long",
+        "double",
+        "float",
+        "boolean",
+        "byte",
+        "short",
+        "char",
+        "Enum",
+        "Exception",
+        "RuntimeException",
+        "Throwable",
+        "Error",
+    }
+)
+
+
+def _strip_generics(name: str) -> str:
+    """Strip generic type parameters from a Java type name.
+
+    Examples:
+        "List<User>"          → "User"   (unwrap single-param container)
+        "Map<String, User>"   → "Map"    (ambiguous — return outer type)
+        "ResponseEntity<Dto>" → "Dto"    (unwrap single-param wrapper)
+        "CreateUserRequest"   → "CreateUserRequest"
+    """
+    name = name.strip()
+    if "<" not in name:
+        return name
+
+    # Extract the outer type and the raw inner type (preserve inner generics for recursion)
+    outer = name[: name.index("<")].strip()
+    inner_raw = name[name.index("<") + 1 : name.rindex(">")].strip()
+
+    # Common single-param containers/wrappers — prefer the inner type
+    _WRAPPER_TYPES = frozenset(
+        {
+            "Optional",
+            "List",
+            "Set",
+            "Collection",
+            "Iterable",
+            "ResponseEntity",
+            "HttpEntity",
+            "CompletableFuture",
+            "Future",
+            "Mono",
+            "Flux",  # Project Reactor
+        }
+    )
+    if outer in _WRAPPER_TYPES and "," not in inner_raw and inner_raw:
+        # Recurse so ResponseEntity<List<User>> → List<User> → User
+        return _strip_generics(inner_raw)
+
+    # Multi-param or unknown — return outer (Map<K,V> → Map)
+    return outer
+
+
+class JavaTypeResolver:
+    """
+    Cross-file type resolver for Java projects.
+
+    Implements the TypeResolver protocol.
+
+    Resolution order:
+    1. Direct qualified-name lookup in symbol table
+    2. Generic stripping + retry (List<User> → User)
+    3. File-local explicit import map
+    4. Wildcard package scan (import com.example.*)
+    5. Same-package implicit visibility (no import needed)
+    6. Project-wide simple-name index (unambiguous)
+    """
+
+    def __init__(self, parsed_files: list[ParsedFile]) -> None:
+        # symbol_table: qualified_name → ParsedClass
+        self._symbol_table: dict[str, ParsedClass] = {}
+        # simple_name → list of qualified names (for ambiguous resolution)
+        self._simple_name_index: dict[str, list[str]] = {}
+        # per-file import map: file_path → { simple_name → qualified_name }
+        self._file_imports: dict[Path, dict[str, str]] = {}
+        # per-file wildcard packages: file_path → [ "com.example.dto" ]
+        self._file_wildcards: dict[Path, list[str]] = {}
+        # per-file package: file_path → "com.example.controller"
+        self._file_package: dict[Path, str] = {}
+        # package → list of qualified names of classes in that package
+        self._package_index: dict[str, list[str]] = {}
+        # ancestor cache: avoids repeated O(n) scans per class
+        self._ancestor_cache: dict[str, list[str]] = {}
+
+        self._build(parsed_files)
+
+    # -------------------------------------------------------------------------
+    # Build
+    # -------------------------------------------------------------------------
+
+    def _build(self, parsed_files: list[ParsedFile]) -> None:
+        # Phase 1: build symbol table + package index
+        for pf in parsed_files:
+            if not pf.success:
+                continue
+            for cls in pf.classes:
+                qname = cls.qualified_name.full
+                self._symbol_table[qname] = cls
+                simple = cls.name
+                self._simple_name_index.setdefault(simple, []).append(qname)
+
+                # Track package membership for same-package resolution
+                if "." in qname:
+                    pkg = qname.rsplit(".", 1)[0]
+                    self._package_index.setdefault(pkg, []).append(qname)
+
+        # Phase 2: build per-file import maps + package names
+        for pf in parsed_files:
+            if not pf.success:
+                continue
+            import_map: dict[str, str] = {}
+            wildcards: list[str] = []
+            pkg = ""
+            for imp in pf.imports:
+                if imp.names:
+                    # "import com.example.User" → { "User": "com.example.User" }
+                    for name in imp.names:
+                        qn = f"{imp.module}.{name}" if imp.module else name
+                        import_map[name] = qn
+                else:
+                    # Wildcard: "import com.example.*"
+                    if imp.module:
+                        wildcards.append(imp.module)
+            # Infer package from first class's qualified name
+            for cls in pf.classes:
+                qn = cls.qualified_name.full
+                if "." in qn:
+                    pkg = qn.rsplit(".", 1)[0]
+                    break
+            self._file_imports[pf.path] = import_map
+            self._file_wildcards[pf.path] = wildcards
+            self._file_package[pf.path] = pkg
+
+    # -------------------------------------------------------------------------
+    # TypeResolver protocol
+    # -------------------------------------------------------------------------
+
+    def resolve_type(
+        self,
+        name: str,
+        in_file: Path | None = None,
+    ) -> ResolvedType | None:
+        """Resolve a type name to its definition."""
+        if not name or name in _JAVA_BUILTINS:
+            return None
+
+        # Strip array suffix ("User[]" → "User")
+        name = name.rstrip("[]").strip()
+
+        # 1. Direct qualified name lookup
+        if name in self._symbol_table:
+            return self._to_resolved_type(self._symbol_table[name])
+
+        # 2. Strip generics and retry ("List<User>" → "User", then resolve "User")
+        stripped = _strip_generics(name)
+        if stripped != name:
+            return self.resolve_type(stripped, in_file)
+
+        # 3. File-local import resolution
+        if in_file is not None:
+            import_map = self._file_imports.get(in_file, {})
+            qn = import_map.get(name)
+            if qn and qn in self._symbol_table:
+                return self._to_resolved_type(self._symbol_table[qn])
+
+            # 4. Wildcard package scan ("import com.example.*")
+            for pkg in self._file_wildcards.get(in_file, []):
+                candidate = f"{pkg}.{name}"
+                if candidate in self._symbol_table:
+                    return self._to_resolved_type(self._symbol_table[candidate])
+
+            # 5. Same-package implicit visibility (no import needed in Java)
+            file_pkg = self._file_package.get(in_file, "")
+            if file_pkg:
+                candidate = f"{file_pkg}.{name}"
+                if candidate in self._symbol_table:
+                    return self._to_resolved_type(self._symbol_table[candidate])
+
+        # 6. Project-wide simple name index (unambiguous cross-project lookup)
+        candidates = self._simple_name_index.get(name, [])
+        if len(candidates) == 1:
+            return self._to_resolved_type(self._symbol_table[candidates[0]])
+        if len(candidates) > 1:
+            logger.debug("Ambiguous type '%s': %s", name, candidates)
+            return self._to_resolved_type(self._symbol_table[candidates[0]])
+
+        return None
+
+    def is_model_type(
+        self,
+        name: str,
+        in_file: Path | None = None,
+    ) -> bool:
+        """Check if a type is a data model."""
+        resolved = self.resolve_type(name, in_file)
+        if resolved is None:
+            return False
+        return resolved.is_model
+
+    def get_model_fields(
+        self,
+        model_name: str,
+        in_file: Path | None = None,
+        include_inherited: bool = True,
+    ) -> list[ResolvedField]:
+        """Get all fields for a model, optionally including inherited."""
+        resolved = self.resolve_type(model_name, in_file)
+        if resolved is None:
+            return []
+        if resolved.definition is None:
+            return []
+
+        fields = list(resolved.fields)
+
+        if include_inherited:
+            for base_name in resolved.base_classes:
+                base = self.resolve_type(base_name, in_file)
+                if base and base.fields:
+                    for f in base.fields:
+                        if not any(ef.name == f.name for ef in fields):
+                            fields.append(f)
+
+        return fields
+
+    def is_subclass_of(
+        self,
+        class_name: str,
+        base_name: str,
+        in_file: Path | None = None,
+    ) -> bool:
+        """Check if class_name inherits from base_name."""
+        resolved = self.resolve_type(class_name, in_file)
+        if resolved is None:
+            return False
+        if base_name in resolved.base_classes:
+            return True
+        return base_name in resolved.all_ancestors
+
+    def get_all_models(self) -> dict[str, ResolvedType]:
+        """Return all detected model types."""
+        result: dict[str, ResolvedType] = {}
+        for qname, cls in self._symbol_table.items():
+            rt = self._to_resolved_type(cls)
+            if rt.is_model:
+                result[qname] = rt
+        return result
+
+    # -------------------------------------------------------------------------
+    # Helpers
+    # -------------------------------------------------------------------------
+
+    def _to_resolved_type(self, cls: ParsedClass) -> ResolvedType:
+        """Convert a ParsedClass to a ResolvedType."""
+        qname = cls.qualified_name.full
+        annotation_names = {d.name for d in cls.decorators}
+
+        is_model = bool(annotation_names & _MODEL_ANNOTATIONS) or self._has_model_fields(cls)
+        is_enum = cls.is_enum
+
+        all_ancestors = self._collect_ancestors(cls.base_classes)
+
+        resolved_fields: list[ResolvedField] = [
+            ResolvedField(
+                name=f.name,
+                type_annotation=f.type_annotation,
+                default_value=f.default_value,
+                is_required=f.default_value is None,
+                defined_in_class=qname,
+            )
+            for f in cls.fields
+        ]
+
+        return ResolvedType(
+            name=cls.name,
+            qualified_name=qname,
+            file_path=cls.location.file if cls.location else None,
+            is_class=True,
+            is_model=is_model,
+            is_enum=is_enum,
+            base_classes=list(cls.base_classes),
+            all_ancestors=all_ancestors,
+            fields=resolved_fields,
+            definition=cls,
+        )
+
+    def _has_model_fields(self, cls: ParsedClass) -> bool:
+        """Heuristic: classes with multiple typed fields are likely models."""
+        return len(cls.fields) >= 2
+
+    def _collect_ancestors(self, base_names: list[str]) -> list[str]:
+        """Recursively collect all ancestor class names.
+
+        Uses a cache and direct dict lookup (O(1) per step) rather than
+        the original O(n) linear scan of the symbol table per ancestor.
+        """
+        cache_key = ",".join(sorted(base_names))
+        if cache_key in self._ancestor_cache:
+            return list(self._ancestor_cache[cache_key])
+
+        ancestors: list[str] = []
+        seen: set[str] = set()
+        queue = list(base_names)
+
+        # Build a reverse index: simple_name → qualified_name for fast lookup
+        # (reuse _simple_name_index which is already built)
+        while queue:
+            name = queue.pop(0)
+            if name in seen:
+                continue
+            seen.add(name)
+            ancestors.append(name)
+
+            # Fast lookup: try direct qname first, then simple name index
+            cls = self._symbol_table.get(name)
+            if cls is None:
+                candidates = self._simple_name_index.get(name, [])
+                if candidates:
+                    cls = self._symbol_table.get(candidates[0])
+
+            if cls is not None:
+                for base in cls.base_classes:
+                    if base not in seen:
+                        queue.append(base)
+
+        self._ancestor_cache[cache_key] = ancestors
+        return ancestors

apisec_code_bolt/parsing/python/__init__.py

@@ -0,0 +1,150 @@
+"""Python parsing using LibCST."""
+
+from .cbv_extractor import (
+    CBVClass,
+    CBVExtractor,
+    CBVRoute,
+    extract_cbv_routes,
+)
+from .constant_resolver import (
+    ConfigClass,
+    ConstantResolver,
+    ResolvedConstant,
+    build_constant_resolver,
+)
+from .cross_file_resolver import (
+    CrossFileResolver,
+    ImportGraph,
+    ResolvedImport,
+    ResolvedSymbol,
+    build_cross_file_resolver,
+    detect_src_layout,
+    infer_module_path,
+)
+from .dynamic_route_detector import (
+    DynamicRoute,
+    DynamicRouteDetector,
+    RouteFactory,
+    detect_dynamic_routes,
+)
+from .language_services import (
+    PythonConstantResolverAdapter,
+    PythonLanguageServices,
+    PythonPathResolverAdapter,
+    PythonRouterRegistryAdapter,
+    PythonTypeResolverAdapter,
+    get_python_language_services,
+)
+from .parameter_analyzer import (
+    AnalyzedParameter,
+    DefaultValueAnalyzer,
+    ParameterAnalyzer,
+    TypeAnnotationAnalyzer,
+    extract_path_params,
+)
+from .parser import PythonParser, PythonProjectParser, get_python_parser
+from .path_resolver import (
+    PathResolver,
+    ResolvedPath,
+    TrackedVariable,
+    resolve_route_path,
+)
+from .router_registry import (
+    RouterDefinition,
+    RouterInclusion,
+    RouterRegistry,
+    RouterTree,
+    build_router_registry,
+)
+from .type_resolver import (
+    ResolvedField,
+    ResolvedModel,
+    ResolvedType,
+    SchemaBuilder,
+    TypeAnnotationParser,
+    TypeResolver,
+)
+from .visitors import (
+    ExtractedArgument,
+    ExtractedAssignment,
+    ExtractedCall,
+    ExtractedClass,
+    ExtractedDecorator,
+    ExtractedField,
+    ExtractedFunction,
+    ExtractedImport,
+    ExtractedParameter,
+    PythonExtractor,
+)
+
+__all__ = [
+    # Parser
+    "PythonParser",
+    "PythonProjectParser",
+    "get_python_parser",
+    # Visitor
+    "PythonExtractor",
+    "ExtractedFunction",
+    "ExtractedClass",
+    "ExtractedImport",
+    "ExtractedCall",
+    "ExtractedArgument",
+    "ExtractedAssignment",
+    "ExtractedDecorator",
+    "ExtractedParameter",
+    "ExtractedField",
+    # Type Resolution
+    "TypeResolver",
+    "TypeAnnotationParser",
+    "SchemaBuilder",
+    "ResolvedType",
+    "ResolvedField",
+    "ResolvedModel",
+    # Cross-file Resolution
+    "CrossFileResolver",
+    "build_cross_file_resolver",
+    "ResolvedSymbol",
+    "ResolvedImport",
+    "ImportGraph",
+    "infer_module_path",
+    "detect_src_layout",
+    # Parameter Analysis
+    "ParameterAnalyzer",
+    "AnalyzedParameter",
+    "extract_path_params",
+    "DefaultValueAnalyzer",
+    "TypeAnnotationAnalyzer",
+    # Router Registry
+    "RouterRegistry",
+    "RouterDefinition",
+    "RouterInclusion",
+    "RouterTree",
+    "build_router_registry",
+    # Path Resolution
+    "PathResolver",
+    "ResolvedPath",
+    "TrackedVariable",
+    "resolve_route_path",
+    # Dynamic Route Detection
+    "DynamicRouteDetector",
+    "DynamicRoute",
+    "RouteFactory",
+    "detect_dynamic_routes",
+    # Class-Based Views
+    "CBVExtractor",
+    "CBVClass",
+    "CBVRoute",
+    "extract_cbv_routes",
+    # Constant Resolution
+    "ConstantResolver",
+    "ResolvedConstant",
+    "ConfigClass",
+    "build_constant_resolver",
+    # Language Services
+    "PythonLanguageServices",
+    "PythonTypeResolverAdapter",
+    "PythonConstantResolverAdapter",
+    "PythonPathResolverAdapter",
+    "PythonRouterRegistryAdapter",
+    "get_python_language_services",
+]