vcode-analysis 0.1.0__py3-none-any.whl

parsers/kotlin/models.py

@@ -0,0 +1,274 @@
+"""Kotlin 解析数据模型
+
+定义 Kotlin 代码解析结果的数据结构。
+"""
+
+from dataclasses import dataclass, field
+from typing import Optional, Literal
+
+
+# ==================== 基础类型 ====================
+
+@dataclass
+class KotlinFunctionInfo:
+    """Kotlin 函数信息"""
+    name: str
+    line_start: int
+    line_end: int
+    return_type: Optional[str]
+    parameters: list[dict]  # {name, type, default_value}
+    modifiers: list[str]  # public, private, suspend, inline, etc.
+    type_params: list[str]  # 泛型参数
+    receiver_type: Optional[str] = None  # 扩展函数接收者
+    is_operator: bool = False
+    is_infix: bool = False
+    is_tailrec: bool = False
+
+
+@dataclass
+class KotlinPropertyInfo:
+    """Kotlin 属性信息"""
+    name: str
+    type: str
+    line: int
+    is_val: bool  # val vs var
+    modifiers: list[str]
+    is_delegate: bool = False  # 委托属性
+
+
+@dataclass
+class KotlinClassInfo:
+    """Kotlin 类信息"""
+    name: str
+    line_start: int
+    line_end: int
+    class_type: str  # class, interface, object, enum class, sealed class, data class
+    type_params: list[str]  # 泛型参数
+    primary_constructor_params: list[dict]
+    extends: Optional[str]
+    implements: list[str]
+    modifiers: list[str]
+    annotations: list[str]
+    functions: list[KotlinFunctionInfo]
+    properties: list[KotlinPropertyInfo]
+
+
+@dataclass
+class KotlinImportInfo:
+    """Kotlin 导入信息"""
+    path: str
+    alias: Optional[str]  # as alias
+    line: int
+
+
+# ==================== Sealed 类层次结构 ====================
+
+@dataclass
+class KotlinSealedClassInfo(KotlinClassInfo):
+    """Sealed 类信息"""
+    is_sealed: bool = True
+    permitted_subclasses: list[str] = field(default_factory=list)  # 允许的子类列表
+    when_expressions: list['KotlinWhenExpression'] = field(default_factory=list)
+
+
+@dataclass
+class KotlinWhenExpression:
+    """When 表达式信息"""
+    subject_type: Optional[str]  # 被检查的类型
+    subject_variable: Optional[str]  # 被检查的变量名
+    branches: list[dict]  # [{pattern: str, is_else: bool, line: int}]
+    is_exhaustive: Optional[bool] = None  # 是否穷尽（需要类型推断）
+    line_start: int = 0
+    line_end: int = 0
+
+
+# ==================== 协程与 Flow ====================
+
+@dataclass
+class KotlinCoroutineInfo:
+    """协程信息"""
+    function_name: str
+    is_suspend: bool
+    coroutine_scope: Optional[str] = None  # CoroutineScope, lifecycleScope 等
+    flow_type: Optional[str] = None  # Flow, StateFlow, SharedFlow
+    dispatcher: Optional[str] = None  # IO, Default, Main, Unconfined
+    builder_type: Optional[str] = None  # launch, async, runBlocking
+    line: int = 0
+
+
+@dataclass
+class KotlinFlowOperator:
+    """Flow 操作符信息"""
+    name: str  # map, filter, collect 等
+    input_type: Optional[str] = None
+    output_type: Optional[str] = None
+    is_terminal: bool = False  # 是否为终端操作符 (collect, first, single 等)
+    line: int = 0
+
+
+# Flow 终端操作符列表
+TERMINAL_FLOW_OPERATORS = {
+    'collect', 'collectLatest', 'collectIndexed', 'collectWhile',
+    'first', 'firstOrNull', 'last', 'lastOrNull',
+    'single', 'singleOrNull', 'toList', 'toSet', 'count',
+    'reduce', 'fold', 'launchIn', 'onEach'
+}
+
+
+# ==================== 类型系统特性 ====================
+
+@dataclass
+class KotlinTypeAlias:
+    """类型别名"""
+    name: str
+    underlying_type: str
+    type_params: list[str] = field(default_factory=list)
+    line: int = 0
+
+
+@dataclass
+class KotlinValueClass:
+    """值类（内联类）"""
+    name: str
+    wrapped_type: str
+    type_params: list[str] = field(default_factory=list)
+    line: int = 0
+
+
+@dataclass
+class KotlinGenericType:
+    """泛型信息"""
+    name: str
+    variance: Literal['in', 'out', 'none'] = 'none'
+    bounds: list[str] = field(default_factory=list)  # 类型上界
+    is_reified: bool = False
+
+
+# ==================== 属性委托 ====================
+
+@dataclass
+class KotlinDelegatedProperty:
+    """委托属性"""
+    name: str
+    delegate_type: str  # lazy, observable, vetoable, custom
+    delegate_expression: Optional[str] = None
+    is_val: bool = True
+    line: int = 0
+
+
+@dataclass
+class KotlinPropertyDelegate:
+    """属性委托类型"""
+    name: str  # lazy, observable, vetoable, by viewModels() 等
+    is_standard: bool = True  # 是否为标准库委托
+    provides_getter: bool = True
+    provides_setter: bool = False
+
+
+# 标准委托类型
+STANDARD_DELEGATES = {
+    'lazy': KotlinPropertyDelegate('lazy', True, True, False),
+    'observable': KotlinPropertyDelegate('observable', True, True, True),
+    'vetoable': KotlinPropertyDelegate('vetoable', True, True, True),
+    'notNull': KotlinPropertyDelegate('notNull', True, True, True),
+    'lateinit': KotlinPropertyDelegate('lateinit', False, True, True),
+}
+
+
+# ==================== 扩展函数和属性 ====================
+
+@dataclass
+class KotlinExtensionFunction(KotlinFunctionInfo):
+    """扩展函数信息"""
+    receiver_type: str = ""  # 扩展接收者类型
+    dispatch_receiver: Optional[str] = None  # 分发接收者（如果在类内）
+
+
+@dataclass
+class KotlinExtensionProperty:
+    """扩展属性信息"""
+    name: str
+    receiver_type: str
+    property_type: str
+    is_val: bool
+    line: int
+
+
+# ==================== 其他 Kotlin 特性 ====================
+
+@dataclass
+class KotlinObjectDeclaration:
+    """Object 声明（单例）"""
+    name: str
+    extends: Optional[str]
+    implements: list[str]
+    is_companion: bool
+    line_start: int
+    line_end: int
+
+
+@dataclass
+class KotlinEnumClassInfo(KotlinClassInfo):
+    """枚举类信息"""
+    entries: list[dict] = field(default_factory=list)  # [{name, params, line}]
+
+
+@dataclass
+class KotlinDataClassInfo(KotlinClassInfo):
+    """数据类信息"""
+    component_functions: list[str] = field(default_factory=list)  # component1, component2...
+    copy_function_params: list[dict] = field(default_factory=list)
+
+
+# ==================== 解析结果 ====================
+
+@dataclass
+class KotlinASTResult:
+    """Kotlin AST 解析结果"""
+    file_path: str
+    success: bool
+    error: Optional[str] = None
+    parse_mode: str = "fast"  # fast, precise, auto
+
+    # 基础结构信息
+    package: Optional[str] = None
+    imports: list[KotlinImportInfo] = field(default_factory=list)
+    classes: list[KotlinClassInfo] = field(default_factory=list)
+    functions: list[KotlinFunctionInfo] = field(default_factory=list)
+    properties: list[KotlinPropertyInfo] = field(default_factory=list)
+
+    # Kotlin 特有结构
+    sealed_classes: list[KotlinSealedClassInfo] = field(default_factory=list)
+    when_expressions: list[KotlinWhenExpression] = field(default_factory=list)
+    coroutines: list[KotlinCoroutineInfo] = field(default_factory=list)
+    flow_operators: list[KotlinFlowOperator] = field(default_factory=list)
+    type_aliases: list[KotlinTypeAlias] = field(default_factory=list)
+    value_classes: list[KotlinValueClass] = field(default_factory=list)
+    delegated_properties: list[KotlinDelegatedProperty] = field(default_factory=list)
+    extension_functions: list[KotlinExtensionFunction] = field(default_factory=list)
+    extension_properties: list[KotlinExtensionProperty] = field(default_factory=list)
+    object_declarations: list[KotlinObjectDeclaration] = field(default_factory=list)
+    enum_classes: list[KotlinEnumClassInfo] = field(default_factory=list)
+    data_classes: list[KotlinDataClassInfo] = field(default_factory=list)
+
+    # 统计信息
+    total_lines: int = 0
+
+    def merge_from(self, other: 'KotlinASTResult'):
+        """合并另一个解析结果（用于增量解析）"""
+        self.imports.extend(other.imports)
+        self.classes.extend(other.classes)
+        self.functions.extend(other.functions)
+        self.properties.extend(other.properties)
+        self.sealed_classes.extend(other.sealed_classes)
+        self.when_expressions.extend(other.when_expressions)
+        self.coroutines.extend(other.coroutines)
+        self.flow_operators.extend(other.flow_operators)
+        self.type_aliases.extend(other.type_aliases)
+        self.value_classes.extend(other.value_classes)
+        self.delegated_properties.extend(other.delegated_properties)
+        self.extension_functions.extend(other.extension_functions)
+        self.extension_properties.extend(other.extension_properties)
+        self.object_declarations.extend(other.object_declarations)
+        self.enum_classes.extend(other.enum_classes)
+        self.data_classes.extend(other.data_classes)

parsers/kotlin/patterns.py

@@ -0,0 +1,146 @@
+"""Kotlin 正则表达式模式定义
+
+定义用于快速解析 Kotlin 代码的正则表达式模式。
+"""
+
+# 基础模式
+KOTLIN_PATTERNS = {
+    # 包声明
+    "package": r'^package\s+([\w.]+)',
+
+    # 导入
+    "import": r'^import\s+([\w.]+)(?:\s+as\s+(\w+))?',
+
+    # 类声明（基础）
+    "class": r'(?:(public|private|protected|internal|open|abstract|final|sealed|data|enum|annotation|inner|companion)\s+)*'
+             r'(class|interface|object)\s+(\w+)(?:<([^>]+)>)?(?:\s*\(([^)]*)\))?(?:\s*:\s*([^{]+?))?(?:\s*\{|$)',
+
+    # 函数声明
+    "function": r'(?:(public|private|protected|internal|open|abstract|final|suspend|inline|tailrec|operator|infix)\s+)*'
+                r'fun\s+(?:<([^>]+)>\s+)?(?:([^\s.]+)\.)?(\w+)\s*\(([^)]*)\)(?:\s*:\s*([^{=\n]+))?',
+
+    # 属性声明
+    "property": r'(?:(public|private|protected|internal|open|override|lateinit|const)\s+)*'
+                r'(val|var)\s+(\w+)\s*(?::\s*([^\s=]+))?(?:\s*=|\s*\{|\s*$)',
+
+    # 注解
+    "annotation": r'@(\w+)(?:\([^)]*\))?',
+}
+
+# Kotlin 特有模式
+KOTLIN_ADVANCED_PATTERNS = {
+    # ==================== Sealed 类 ====================
+
+    # Sealed 类声明
+    "sealed_class": r'(?:sealed\s+class\s+(\w+)(?:<([^>]+)>)?)',
+
+    # Sealed 接口声明 (Kotlin 1.5+)
+    "sealed_interface": r'(?:sealed\s+interface\s+(\w+)(?:<([^>]+)>)?)',
+
+    # When 表达式
+    "when_expression": r'when\s*(?:\(([^)]*)\))?\s*\{',
+
+    # When 分支
+    "when_branch": r'([^\n]->|is\s+\w+|else)\s*->',
+
+    # ==================== 协程与 Flow ====================
+
+    # Suspend 函数
+    "suspend_function": r'suspend\s+fun\s+(\w+)\s*\(([^)]*)\)(?:\s*:\s*([^{=\n]+))?',
+
+    # Flow 类型
+    "flow_type": r'(?:Flow|StateFlow|MutableStateFlow|SharedFlow|MutableSharedFlow)<([^>]+)>',
+
+    # 协程构建器
+    "coroutine_builder": r'(launch|async|runBlocking|withContext|coroutineScope|supervisorScope)\s*(?:\{|<|.)',
+
+    # Flow 操作符
+    "flow_operator": r'\.(map|filter|collect|onEach|onStart|onCompletion|catch|combine|zip|flatMapLatest|flatMapMerge|transform|take|drop|distinctUntilChanged|debounce|throttle|sample|conflate|buffer|flowOn)\s*\(',
+
+    # Dispatcher
+    "dispatcher": r'Dispatchers\.(Default|IO|Main|Unconfined)|Dispatcher\.(Default|IO|Main|Unconfined)',
+
+    # 协程作用域
+    "coroutine_scope": r'(lifecycleScope|viewModelScope|GlobalScope|CoroutineScope|rememberCoroutineScope)',
+
+    # ==================== 类型系统 ====================
+
+    # 类型别名
+    "type_alias": r'typealias\s+(\w+)(?:<([^>]+)>)?\s*=\s*(.+?)(?:\s*$)',
+
+    # 值类 (Value class / 内联类)
+    "value_class": r'(?:value\s+class|inline\s+class)\s+(\w+)(?:\s*\(([^)]*)\))?',
+
+    # 泛型变型
+    "variance": r'(?:class|interface)\s+\w+<(in|out)\s+(\w+)>',
+
+    # 泛型约束
+    "type_constraint": r'where\s+(\w+)\s*:\s*([^,\n]+)',
+
+    # 可空类型
+    "nullable_type": r'(\w+)(?:<[^>]+>)?\?',
+
+    # 平台类型 (Java 互操作)
+    "platform_type": r'(\w+)!!',
+
+    # ==================== 属性委托 ====================
+
+    # 委托属性
+    "delegated_property": r'(val|var)\s+(\w+)\s*(?::\s*([^\s=]+))?\s+by\s+(.+?)(?:\s*$|\s*\n)',
+
+    # 标准委托
+    "standard_delegate": r'(lazy|observable|vetoable|delegates)\s*(?:<[^>]+>)?\s*\{',
+
+    # 属性引用
+    "property_reference": r'::(\w+)',
+
+    # 提供委托
+    "provide_delegate": r'provideDelegate\s*\(',
+
+    # ==================== 其他 Kotlin 特性 ====================
+
+    # 扩展函数
+    "extension_function": r'fun\s+([^\s.]+)\.(\w+)\s*\(([^)]*)\)(?:\s*:\s*([^{=\n]+))?',
+
+    # 扩展属性
+    "extension_property": r'(val|var)\s+([^\s.]+)\.(\w+)',
+
+    # 数据类
+    "data_class": r'data\s+class\s+(\w+)(?:<([^>]+)>)?\s*\(([^)]*)\)',
+
+    # 枚举类
+    "enum_class": r'enum\s+class\s+(\w+)(?:\s*\:(.+?))?',
+
+    # 枚举条目
+    "enum_entry": r'^\s*(\w+)\s*(?:\(([^)]*)\))?(?:,|\s*$)',
+
+    # Object 声明
+    "object_declaration": r'object\s+(\w+)(?:\s*:\s*([^{]+?))?(?:\s*\{|$)',
+
+    # Companion object
+    "companion_object": r'companion\s+object\s*(?::\s*(\w+))?\s*\{',
+
+    # 初始化块
+    "init_block": r'init\s*\{',
+
+    # 尾递归函数
+    "tailrec_function": r'tailrec\s+fun\s+(\w+)',
+
+    # 操作符重载
+    "operator_function": r'operator\s+fun\s+(\w+)',
+
+    # 中缀函数
+    "infix_function": r'infix\s+fun\s+(\w+)',
+
+    # 内联函数
+    "inline_function": r'(?:inline|noinline|crossinline)\s+fun',
+
+    # 具体化类型参数
+    "reified_type": r'inline\s+fun\s+<reified\s+(\w+)>',
+
+    # 契约
+    "contract": r'contract\s*\{',
+}
+
+# 合并所有模式
+ALL_KOTLIN_PATTERNS = {**KOTLIN_PATTERNS, **KOTLIN_ADVANCED_PATTERNS}