修复了大量存在的问题，增加了假鸭子类型等等机制

lib/StubGen/Converter.py

@@ -1,7 +1,10 @@
 """StubGen 转换器模块 - 将 Python 文件转换为存根格式"""
+from __future__ import annotations
 import ast
 import re
+import fnmatch
 from typing import List, Dict, Optional, Tuple
+from lib.core.SymbolUtils import IsListAnnotation
 
 
 class PythonToStubConverter:
@@ -17,24 +20,23 @@ class PythonToStubConverter:
     MacroExcludeList: List[str] = []
 
     @classmethod
-    def SetIncludeAliasMap(cls, alias_map: Dict[str, str]):
+    def SetIncludeAliasMap(cls, alias_map: Dict[str, str]) -> None:
         """设置 __include 别名映射表"""
         cls.IncludeAliasMap = alias_map
 
     @classmethod
-    def SetVarExcludeList(cls, exclude_list: List[str]):
+    def SetVarExcludeList(cls, exclude_list: List[str]) -> None:
         """设置变量排除列表"""
         cls.VarExcludeList = exclude_list
 
     @classmethod
-    def SetMacroExcludeList(cls, exclude_list: List[str]):
+    def SetMacroExcludeList(cls, exclude_list: List[str]) -> None:
         """设置宏排除列表"""
         cls.MacroExcludeList = exclude_list
 
     @classmethod
     def _ShouldExcludeVar(cls, VarName: str) -> bool:
         """检查变量是否应该被排除"""
-        import fnmatch
         for pattern in cls.VarExcludeList:
             if fnmatch.fnmatch(VarName, pattern):
                 return True
@@ -43,7 +45,6 @@ class PythonToStubConverter:
     @classmethod
     def _ShouldExcludeMacro(cls, MacroName: str) -> bool:
         """检查宏是否应该被排除"""
-        import fnmatch
         for pattern in cls.MacroExcludeList:
             if fnmatch.fnmatch(MacroName, pattern):
                 return True
@@ -52,8 +53,8 @@ class PythonToStubConverter:
     @staticmethod
     def convert(PyContent: str, ModuleName: str) -> str:
         """将 Python 代码转换为存根格式"""
-        lines = PyContent.split('\n')
-        StubLines = []
+        lines: list[str] = PyContent.split('\n')
+        StubLines: list[str] = []
 
         # 添加文件头
         StubLines.append('"""')
@@ -63,11 +64,10 @@ class PythonToStubConverter:
         StubLines.append('')
 
         # 解析 Python 代码，检查是否已经导入了 t 和 c
-        import ast
-        HasImportT = False
-        HasImportC = False
+        HasImportT: bool = False
+        HasImportC: bool = False
         try:
-            tree = ast.parse(PyContent)
+            tree: ast.Module = ast.parse(PyContent)
             for node in tree.body:
                 if isinstance(node, ast.Import):
                     for alias in node.names:
@@ -103,24 +103,24 @@ class PythonToStubConverter:
             tree = ast.parse(PyContent)
 
             # 第一遍扫描：收集 Postdefinition 变量
-            PostdefVars = {}  # {ClassName: [(VarName, TypeStr, node), ...]}
+            PostdefVars: dict[str, list[tuple[str, str, ast.AnnAssign]]] = {}  # {ClassName: [(VarName, TypeStr, node), ...]}
             for node in tree.body:
                 if isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name):
-                    TypeStr = PythonToStubConverter._GetTypeString(node.annotation)
+                    TypeStr: str = PythonToStubConverter._GetTypeString(node.annotation)
                     # 检查是否是 Postdefinition 类型
                     if 't.Postdefinition' in TypeStr:
                         # 提取引用的类名
-                        ClassName = PythonToStubConverter._ExtractPostdefClass(node.annotation)
+                        ClassName: str | None = PythonToStubConverter._ExtractPostdefClass(node.annotation)
                         if ClassName:
                             if ClassName not in PostdefVars:
                                 PostdefVars[ClassName] = []
                             PostdefVars[ClassName].append((node.target.id, TypeStr, node))
 
             # 按原始顺序处理节点，保持代码的原始顺序
-            PrevType = None  # 记录前一个节点的类型
+            PrevType: str | None = None  # 记录前一个节点的类型
 
             for node in tree.body:
-                CurrentType = None
+                CurrentType: str | None = None
 
                 if isinstance(node, ast.ClassDef):
                     CurrentType = 'class'
@@ -128,8 +128,8 @@ class PythonToStubConverter:
                     if PrevType is not None and PrevType != 'class':
                         StubLines.append('')
                     # 检查是否有对应的 Postdefinition 变量
-                    ClassPostdefs = PostdefVars.get(node.name, [])
-                    ClassLines = PythonToStubConverter._ConvertClass(
+                    ClassPostdefs: list[tuple[str, str, ast.AnnAssign]] = PostdefVars.get(node.name, [])
+                    ClassLines: list[str] = PythonToStubConverter._ConvertClass(
                         node, SourceLines=lines, PostdefVars=ClassPostdefs
                     )
                     StubLines.extend(ClassLines)
@@ -138,7 +138,7 @@ class PythonToStubConverter:
                     # 如果前一个是类或者是第一个函数，添加空行分隔
                     if PrevType == 'class' or (PrevType is not None and PrevType != 'function'):
                         StubLines.append('')
-                    FuncLines = PythonToStubConverter._ConvertFunction(node, SourceLines=lines)
+                    FuncLines: list[str] = PythonToStubConverter._ConvertFunction(node, SourceLines=lines)
                     StubLines.extend(FuncLines)
                     StubLines.append('')  # 函数后空行
                 elif isinstance(node, ast.AnnAssign):
@@ -148,11 +148,11 @@ class PythonToStubConverter:
                     if 't.Postdefinition' in TypeStr:
                         continue
                     # 检查是否带有 t.CStatic 标志，如果有则不排除
-                    HasStatic = 't.CStatic' in TypeStr
+                    HasStatic: bool = 't.CStatic' in TypeStr
                     # 检查变量是否应该被排除
-                    ShouldExclude = False
+                    ShouldExclude: bool = False
                     if isinstance(node.target, ast.Name) and not HasStatic:
-                        VarName = node.target.id
+                        VarName: str = node.target.id
                         if PythonToStubConverter._ShouldExcludeVar(VarName):
                             ShouldExclude = True
                     if ShouldExclude:
@@ -160,14 +160,14 @@ class PythonToStubConverter:
                     # 如果前一个不是变量，添加空行分隔
                     if PrevType is not None and PrevType != 'variable':
                         StubLines.append('')
-                    VarLines = PythonToStubConverter._ConvertVariable(node, SourceLines=lines)
+                    VarLines: list[str] = PythonToStubConverter._ConvertVariable(node, SourceLines=lines)
                     # 移除多余的空行
                     VarLines = [line for line in VarLines if line.strip()]
                     StubLines.extend(VarLines)
                 elif isinstance(node, ast.Import):
                     # 处理导入语句
                     CurrentType = 'import'
-                    ImportStr = PythonToStubConverter._GetImportString(node, SourceLines=lines)
+                    ImportStr: str = PythonToStubConverter._GetImportString(node, SourceLines=lines)
                     if ImportStr:
                         if PrevType is not None and PrevType != 'import':
                             StubLines.append('')
@@ -177,7 +177,7 @@ class PythonToStubConverter:
                     # 处理模块级别的全局变量（无类型标注）
                     if PrevType is not None and PrevType != 'variable':
                         StubLines.append('')
-                    AssignLines = PythonToStubConverter._ConvertGlobalAssign(node)
+                    AssignLines: list[str] = PythonToStubConverter._ConvertGlobalAssign(node)
                     StubLines.extend(AssignLines)
                 elif isinstance(node, ast.ImportFrom):
                     # 处理 from ... import ... 语句
@@ -189,14 +189,14 @@ class PythonToStubConverter:
                         StubLines.append(ImportStr)
                 elif isinstance(node, ast.Expr):
                     # 处理模块级别的宏调用，如 c.CIf(...), c.CEndif()
-                    ExprStr = PythonToStubConverter._GetExprString(node.value)
+                    ExprStr: str = PythonToStubConverter._GetExprString(node.value)
                     if ExprStr:
                         CurrentType = 'macro'
                         StubLines.append(ExprStr)
                         StubLines.append('')  # 宏后空行
                 elif isinstance(node, ast.If):
                     # 处理模块级别的 if 宏条件，如 if c.CIf(FF_MULTI_PARTITION):
-                    IfStr = PythonToStubConverter._GetModuleIfMacroString(node)
+                    IfStr: str = PythonToStubConverter._GetModuleIfMacroString(node)
                     if IfStr:
                         CurrentType = 'macro'
                         StubLines.append(IfStr)
@@ -220,7 +220,7 @@ class PythonToStubConverter:
         return '\n'.join(StubLines)
 
     @staticmethod
-    def _ConvertClass(node: ast.ClassDef, SourceLines: List[str] = None, PostdefVars: List[Tuple[str, str, ast.AnnAssign]] = None, indent: int = 0) -> List[str]:
+    def _ConvertClass(node: ast.ClassDef, SourceLines: list[str] | None = None, PostdefVars: list[tuple[str, str, ast.AnnAssign]] | None = None, indent: int = 0) -> list[str]:
         """转换类定义
 
         Args:
@@ -229,24 +229,24 @@ class PythonToStubConverter:
             PostdefVars: Postdefinition 变量列表 [(VarName, TypeStr, node), ...]
             indent: 缩进级别（用于嵌套类）
         """
-        lines = []
+        lines: list[str] = []
         PostdefVars = PostdefVars or []
-        IndentStr = '    ' * indent
+        IndentStr: str = '    ' * indent
 
         # 处理类装饰器
         for decorator in node.decorator_list:
-            DecoratorStr = PythonToStubConverter._GetDecoratorString(decorator)
+            DecoratorStr: str = PythonToStubConverter._GetDecoratorString(decorator)
             if DecoratorStr:
                 lines.append(f'{IndentStr}@{DecoratorStr}')
 
         # 检查是否是结构体、联合体或枚举
-        BaseNames = [base.attr if isinstance(base, ast.Attribute) else base.id
+        BaseNames: list[str] = [base.attr if isinstance(base, ast.Attribute) else base.id
                       for base in node.bases
                       if isinstance(base, (ast.Name, ast.Attribute))]
 
         # 保留原始基类
         if node.bases:
-            BaseStrs = []
+            BaseStrs: list[str] = []
             for base in node.bases:
                 if isinstance(base, ast.Name):
                     BaseStrs.append(base.id)
@@ -255,9 +255,9 @@ class PythonToStubConverter:
                 elif isinstance(base, ast.Subscript):
                     # 处理泛型类型，如 memory_block_t[MAX_ORDER + 1]
                     BaseStrs.append(PythonToStubConverter._GetTypeString(base))
-            ClassTypeParamStr = ''
+            ClassTypeParamStr: str = ''
             if hasattr(node, 'type_params') and node.type_params:
-                param_names = [tp.name for tp in node.type_params]
+                param_names: list[str] = [tp.name for tp in node.type_params]
                 ClassTypeParamStr = f'[{", ".join(param_names)}]'
             if BaseStrs:
                 lines.append(f'{IndentStr}class {node.name}{ClassTypeParamStr}({", ".join(BaseStrs)}):')
@@ -271,12 +271,12 @@ class PythonToStubConverter:
             lines.append(f'{IndentStr}class {node.name}{ClassTypeParamStr}:')
 
         # 处理类成员
-        HasMembers = False
-        seen_member_names = set()
+        HasMembers: bool = False
+        seen_member_names: set[str] = set()
         for item in node.body:
             if isinstance(item, ast.AnnAssign) and isinstance(item.target, ast.Name):
                 seen_member_names.add(item.target.id)
-        init_members = []
+        init_members: list[ast.AnnAssign] = []
         for item in node.body:
             if isinstance(item, ast.FunctionDef) and item.name == '__init__':
                 for stmt in item.body:
@@ -285,7 +285,7 @@ class PythonToStubConverter:
                         and isinstance(stmt.target.value, ast.Name)
                         and stmt.target.value.id == 'self'):
                         init_members.append(stmt)
-        untyped_self_members = []
+        untyped_self_members: list[ast.Assign] = []
         for m_name in [m.target.attr for m in init_members if isinstance(m.target, ast.Attribute)]:
             seen_member_names.add(m_name)
         for item in node.body:
@@ -296,7 +296,7 @@ class PythonToStubConverter:
                         and isinstance(stmt.targets[0], ast.Attribute)
                         and isinstance(stmt.targets[0].value, ast.Name)
                         and stmt.targets[0].value.id == 'self'):
-                        attr_name = stmt.targets[0].attr
+                        attr_name: str = stmt.targets[0].attr
                         if attr_name not in seen_member_names:
                             seen_member_names.add(attr_name)
                             untyped_self_members.append(stmt)
@@ -307,11 +307,11 @@ class PythonToStubConverter:
                     and isinstance(item.targets[0].value, ast.Name)
                     and item.targets[0].value.id == 'self'):
                     HasMembers = True
-                    MemberIndent = IndentStr + '    '
+                    MemberIndent: str = IndentStr + '    '
                     attr_name = item.targets[0].attr
                     if attr_name in seen_member_names:
                         continue
-                    InferredType = 'int'
+                    InferredType: str = 'int'
                     if item.value and isinstance(item.value, ast.Constant):
                         if isinstance(item.value.value, float):
                             InferredType = 'float'
@@ -324,86 +324,95 @@ class PythonToStubConverter:
                     HasMembers = True
                     MemberIndent = IndentStr + '    '
                     if SourceLines and hasattr(item, 'lineno'):
-                        StartLine = item.lineno - 1
-                        EndLine = item.EndLineno if hasattr(item, 'EndLineno') and item.EndLineno else StartLine + 1
+                        StartLine: int = item.lineno - 1
+                        EndLine: int = item.end_lineno if hasattr(item, 'end_lineno') and item.end_lineno else StartLine + 1
                         for i in range(StartLine, min(EndLine, len(SourceLines))):
                             lines.append(MemberIndent + SourceLines[i].lstrip())
             elif isinstance(item, ast.AnnAssign):
                 HasMembers = True
-                TypeStr = PythonToStubConverter._GetTypeString(item.annotation)
+                TypeStr: str = PythonToStubConverter._GetTypeString(item.annotation)
                 MemberIndent = IndentStr + '    '
+                # __provides__/__requires__/__require_must__ 元数据：保留值以便跨模块加载
+                if isinstance(item.target, ast.Name) and item.target.id in ('__provides__', '__requires__', '__require_must__'):
+                    if item.value is not None:
+                        try:
+                            value_str: str = ast.unparse(item.value)
+                        except Exception:
+                            value_str = ''
+                        lines.append(f'{MemberIndent}{item.target.id}: {TypeStr} = {value_str}')
+                    else:
+                        lines.append(f'{MemberIndent}{item.target.id}: {TypeStr}')
+                    continue
                 # 检查是否是宏变量（类型包含 t.CDefine）
                 if 't.CDefine' in TypeStr:
                     # 检查宏变量是否应该被排除
                     if isinstance(item.target, ast.Name):
-                        MacroName = item.target.id
+                        MacroName: str = item.target.id
                         if PythonToStubConverter._ShouldExcludeMacro(MacroName):
                             continue  # 跳过该宏
                     # 宏变量保持原样（包括赋值）
                     if SourceLines and hasattr(item, 'lineno'):
                         StartLine = item.lineno - 1
-                        EndLine = item.EndLineno if hasattr(item, 'EndLineno') and item.EndLineno else StartLine + 1
+                        EndLine = item.end_lineno if hasattr(item, 'end_lineno') and item.end_lineno else StartLine + 1
                         for i in range(StartLine, min(EndLine, len(SourceLines))):
                             lines.append(MemberIndent + SourceLines[i].lstrip())
                     else:
                         lines.append(f'{MemberIndent}{item.target.id}: {TypeStr}')
                 else:
                     if isinstance(item.target, ast.Attribute):
-                        MemberName = item.target.attr
+                        MemberName: str = item.target.attr
                     else:
                         MemberName = item.target.id
-                    FinalTypeStr = TypeStr
-                    if (isinstance(item.annotation, ast.Subscript)
-                        and isinstance(item.annotation.value, ast.Name)
-                        and item.annotation.value.id == 'list'):
-                        slice_node = item.annotation.slice
-                        has_size = False
+                    FinalTypeStr: str = TypeStr
+                    if IsListAnnotation(item.annotation):
+                        slice_node: ast.AST = item.annotation.slice
+                        has_size: bool = False
                         if isinstance(slice_node, ast.Tuple) and len(slice_node.elts) == 2:
-                            count_node = slice_node.elts[1]
+                            count_node: ast.AST = slice_node.elts[1]
                             if isinstance(count_node, ast.Constant) and isinstance(count_node.value, int) and count_node.value > 0:
                                 has_size = True
                             else:
                                 try:
-                                    count_expr = ast.unparse(count_node)
+                                    count_expr: str = ast.unparse(count_node)
                                 except Exception:
                                     count_expr = ''
                                 if count_expr and count_expr != 'None':
                                     has_size = True
-                                    elem_type_str = PythonToStubConverter._GetTypeString(slice_node.elts[0])
-                                    FinalTypeStr = f'list[{elem_type_str}, {count_expr}]'
+                                    elem_type_str: str = PythonToStubConverter._GetTypeString(slice_node.elts[0])
+                                    FinalTypeStr = f't.CArray[{elem_type_str}, {count_expr}]'
                         if not has_size:
                             elem_type_str = PythonToStubConverter._GetTypeString(slice_node if not isinstance(slice_node, ast.Tuple) else slice_node.elts[0])
-                            init_len = 0
+                            init_len: int = 0
                             if item.value is not None:
                                 if isinstance(item.value, ast.List):
                                     init_len = len(item.value.elts)
                                 elif isinstance(item.value, ast.Constant) and isinstance(item.value.value, str):
                                     init_len = len(item.value.value) + 1
                             if init_len > 0:
-                                FinalTypeStr = f'list[{elem_type_str}, {init_len}]'
+                                FinalTypeStr = f't.CArray[{elem_type_str}, {init_len}]'
                             else:
-                                FinalTypeStr = f'list[{elem_type_str}, None]'
+                                FinalTypeStr = f't.CArray[{elem_type_str}, None]'
                     lines.append(f'{MemberIndent}{MemberName}: {FinalTypeStr}')
             elif isinstance(item, ast.FunctionDef):
                 HasMembers = True
-                FuncStub = PythonToStubConverter._ConvertFunction(item, indent=indent+1, SourceLines=SourceLines, class_name=node.name)
+                FuncStub: list[str] = PythonToStubConverter._ConvertFunction(item, indent=indent+1, SourceLines=SourceLines, class_name=node.name)
                 lines.extend(FuncStub)
             elif isinstance(item, ast.Expr):
                 # 处理宏调用，如 c.CIf(...), c.CEndif(), c.CElif(), c.CElse()
-                ExprStr = PythonToStubConverter._GetExprString(item.value)
+                ExprStr: str = PythonToStubConverter._GetExprString(item.value)
                 if ExprStr:
                     lines.append(f'{IndentStr}    {ExprStr}')
             elif isinstance(item, ast.If):
                 # 处理 if c.CIf(...): 形式的宏条件
-                IfStr = PythonToStubConverter._get_if_macro_string(item, indent=indent+1)
+                IfStr: str = PythonToStubConverter._get_if_macro_string(item, indent=indent+1)
                 if IfStr:
                     lines.append(IfStr)
             elif isinstance(item, ast.ClassDef):
                 # 处理嵌套类
                 HasMembers = True
-                NestedClassLines = PythonToStubConverter._ConvertClass(item, SourceLines=SourceLines, PostdefVars=[], indent=indent+1)
+                NestedClassLines: list[str] = PythonToStubConverter._ConvertClass(item, SourceLines=SourceLines, PostdefVars=[], indent=indent+1)
                 # 移除嵌套类的宏守卫（因为已经在父类的宏守卫内）
-                FilteredLines = []
+                FilteredLines: list[str] = []
                 for line in NestedClassLines:
                     # 跳过宏守卫相关行
                     if line.strip().startswith('c.CIfndef(') or line.strip().startswith('c.CEndif()'):
@@ -425,15 +434,15 @@ class PythonToStubConverter:
         return lines
 
     @staticmethod
-    def _ConvertFunction(node: ast.FunctionDef, indent: int = 0, SourceLines: List[str] = None, class_name: str = None) -> List[str]:
+    def _ConvertFunction(node: ast.FunctionDef, indent: int = 0, SourceLines: list[str] | None = None, class_name: str | None = None) -> list[str]:
         """转换函数定义"""
-        lines = []
-        IndentStr = '    ' * indent
+        lines: list[str] = []
+        IndentStr: str = '    ' * indent
 
         # 检查是否是宏函数（返回类型包含 t.CDefine）
-        is_macro_func = False
+        is_macro_func: bool = False
         if node.returns:
-            ReturnType = PythonToStubConverter._GetTypeString(node.returns)
+            ReturnType: str = PythonToStubConverter._GetTypeString(node.returns)
             if 't.CDefine' in ReturnType:
                 is_macro_func = True
 
@@ -444,8 +453,8 @@ class PythonToStubConverter:
 
             # 保持原样（包括代码块）
             if SourceLines:
-                StartLine = node.lineno - 1
-                EndLine = node.EndLineno if hasattr(node, 'EndLineno') and node.EndLineno else StartLine + 1
+                StartLine: int = node.lineno - 1
+                EndLine: int = node.end_lineno if hasattr(node, 'end_lineno') and node.end_lineno else StartLine + 1
                 for i in range(StartLine, min(EndLine, len(SourceLines))):
                     lines.append(SourceLines[i])
                 if lines and lines[-1].strip() and not lines[-1].rstrip().endswith(':'):
@@ -456,16 +465,16 @@ class PythonToStubConverter:
 
         # 处理函数装饰器
         for decorator in node.decorator_list:
-            DecoratorStr = PythonToStubConverter._GetDecoratorString(decorator)
+            DecoratorStr: str = PythonToStubConverter._GetDecoratorString(decorator)
             if DecoratorStr:
                 lines.append(f'{IndentStr}@{DecoratorStr}')
 
         # 构建参数列表
-        params = []
+        params: list[str] = []
         for arg_idx, arg in enumerate(node.args.args):
-            ArgName = arg.arg
+            ArgName: str = arg.arg
             if arg.annotation:
-                TypeStr = PythonToStubConverter._GetTypeString(arg.annotation)
+                TypeStr: str = PythonToStubConverter._GetTypeString(arg.annotation)
                 params.append(f'{ArgName}: {TypeStr}')
             elif class_name and arg_idx == 0 and ArgName == 'self':
                 params.append(f'self: {class_name}')
@@ -490,7 +499,7 @@ class PythonToStubConverter:
             else:
                 params.append(f'**{ArgName}')
 
-        ParamStr = ', '.join(params)
+        ParamStr: str = ', '.join(params)
 
         # 返回类型 - 保持原始类型（不添加t.State）
         if node.returns:
@@ -498,21 +507,21 @@ class PythonToStubConverter:
         else:
             ReturnType = 't.CInt'
 
-        TypeParamStr = ''
+        TypeParamStr: str = ''
         if hasattr(node, 'type_params') and node.type_params:
-            param_names = [tp.name for tp in node.type_params]
+            param_names: list[str] = [tp.name for tp in node.type_params]
             TypeParamStr = f'[{", ".join(param_names)}]'
 
         lines.append(f'{IndentStr}def {node.name}{TypeParamStr}({ParamStr}) -> {ReturnType}: pass')
         return lines
 
     @staticmethod
-    def _ConvertVariable(node: ast.AnnAssign, SourceLines: List[str] = None) -> List[str]:
+    def _ConvertVariable(node: ast.AnnAssign, SourceLines: list[str] | None = None) -> list[str]:
         """转换变量定义"""
-        lines = []
+        lines: list[str] = []
         if isinstance(node.target, ast.Name):
-            VarName = node.target.id
-            TypeStr = PythonToStubConverter._GetTypeString(node.annotation)
+            VarName: str = node.target.id
+            TypeStr: str = PythonToStubConverter._GetTypeString(node.annotation)
             # 检查是否是宏变量（类型包含 t.CDefine）
             if 't.CDefine' in TypeStr:
                 # 检查宏变量是否应该被排除
@@ -520,8 +529,8 @@ class PythonToStubConverter:
                     return lines  # 返回空列表，排除该宏
                 # 宏变量保持原样（包括赋值）
                 if SourceLines and hasattr(node, 'lineno'):
-                    StartLine = node.lineno - 1
-                    EndLine = node.EndLineno if hasattr(node, 'EndLineno') and node.EndLineno else StartLine + 1
+                    StartLine: int = node.lineno - 1
+                    EndLine: int = node.end_lineno if hasattr(node, 'end_lineno') and node.end_lineno else StartLine + 1
                     for i in range(StartLine, min(EndLine, len(SourceLines))):
                         lines.append(SourceLines[i])
                 else:
@@ -529,9 +538,9 @@ class PythonToStubConverter:
                 return lines
             # 非宏变量：不加 t.State
             # 含有 typedef 的变量不加 extern，普通变量需要加 extern
-            has_typedef = 't.CTypedef' in TypeStr or 'CTypedef' in TypeStr
+            has_typedef: bool = 't.CTypedef' in TypeStr or 'CTypedef' in TypeStr
             if has_typedef and node.value is not None:
-                ValueTypeStr = PythonToStubConverter._GetTypeString(node.value)
+                ValueTypeStr: str = PythonToStubConverter._GetTypeString(node.value)
                 lines.append(f'{VarName}: {TypeStr} = {ValueTypeStr}')
             else:
                 if not has_typedef and 't.CExtern' not in TypeStr and 't.CStatic' not in TypeStr:
@@ -540,20 +549,20 @@ class PythonToStubConverter:
         return lines
 
     @staticmethod
-    def _ConvertGlobalAssign(node: ast.Assign) -> List[str]:
+    def _ConvertGlobalAssign(node: ast.Assign) -> list[str]:
         """转换模块级别的全局变量（无类型标注）"""
-        lines = []
+        lines: list[str] = []
         if not node.targets or not isinstance(node.targets[0], ast.Name):
             return lines
 
-        VarName = node.targets[0].id
+        VarName: str = node.targets[0].id
 
         # 跳过私有变量（以下划线开头）
         if VarName.startswith('_'):
             return lines
 
         # 从值推断类型
-        inferred_type = PythonToStubConverter._InferTypeFromValue(node.value)
+        inferred_type: str | None = PythonToStubConverter._InferTypeFromValue(node.value)
         if inferred_type:
             lines.append(f'{VarName}: {inferred_type}')
         else:
@@ -562,7 +571,7 @@ class PythonToStubConverter:
         return lines
 
     @staticmethod
-    def _InferTypeFromValue(value: ast.AST) -> str:
+    def _InferTypeFromValue(value: ast.AST) -> str | None:
         """从值推断 C 类型"""
         if isinstance(value, ast.Constant):
             if isinstance(value.value, int):
@@ -580,14 +589,14 @@ class PythonToStubConverter:
         elif isinstance(value, ast.Name):
             return 't.CInt'
         elif isinstance(value, ast.BinOp):
-            left_type = PythonToStubConverter._InferTypeFromValue(value.left)
+            left_type: str | None = PythonToStubConverter._InferTypeFromValue(value.left)
             if left_type:
                 return left_type
             return 't.CInt'
         elif isinstance(value, ast.Call):
             # 函数调用返回值，假设为指针类型
             if isinstance(value.func, ast.Name):
-                func_name = value.func.id
+                func_name: str = value.func.id
                 if func_name == 'malloc':
                     return 't.CVoidPtr'
                 elif func_name in ('ctypes.cast', 'cast'):
@@ -605,26 +614,26 @@ class PythonToStubConverter:
                 return f'{annotation.value.id}.{annotation.attr}'
             else:
                 # 处理嵌套属性访问，如 t.attr.packed
-                ParentStr = PythonToStubConverter._GetTypeString(annotation.value)
+                ParentStr: str = PythonToStubConverter._GetTypeString(annotation.value)
                 return f'{ParentStr}.{annotation.attr}'
         elif isinstance(annotation, ast.Subscript):
-            base = PythonToStubConverter._GetTypeString(annotation.value)
+            base: str = PythonToStubConverter._GetTypeString(annotation.value)
             if isinstance(annotation.slice, ast.Tuple):
-                slice_strs = [PythonToStubConverter._GetTypeString(e) for e in annotation.slice.elts]
-                SliceStr = ', '.join(slice_strs)
+                slice_strs: list[str] = [PythonToStubConverter._GetTypeString(e) for e in annotation.slice.elts]
+                SliceStr: str = ', '.join(slice_strs)
             else:
                 SliceStr = PythonToStubConverter._GetTypeString(annotation.slice)
             return f'{base}[{SliceStr}]'
         elif isinstance(annotation, ast.BinOp):
             # 处理 BinOp，如 t.CExtern | fd_table.__set_default__(...)
-            left = annotation.left
-            right = annotation.right
+            left: ast.AST = annotation.left
+            right: ast.AST = annotation.right
 
             # 检查右侧是否是 __set_default__ 调用
             if isinstance(right, ast.Call) and isinstance(right.func, ast.Attribute) and right.func.attr in ('__set_default__', '__set_default'):
                 # 去除 __set_default__，保留左侧，右侧替换为函数名部分
-                LeftStr = PythonToStubConverter._GetTypeString(left)
-                RightStr = PythonToStubConverter._GetTypeString(right.func.value)
+                LeftStr: str = PythonToStubConverter._GetTypeString(left)
+                RightStr: str = PythonToStubConverter._GetTypeString(right.func.value)
                 if isinstance(annotation.op, ast.BitOr):
                     return f'{LeftStr} | {RightStr}'
 
@@ -644,7 +653,7 @@ class PythonToStubConverter:
                 return f'{LeftStr} % {RightStr}'
         elif isinstance(annotation, ast.UnaryOp):
             if isinstance(annotation.op, ast.Not):
-                operand = PythonToStubConverter._GetTypeString(annotation.operand)
+                operand: str = PythonToStubConverter._GetTypeString(annotation.operand)
                 return f'not {operand}'
             elif isinstance(annotation.op, ast.Invert):
                 operand = PythonToStubConverter._GetTypeString(annotation.operand)
@@ -654,9 +663,9 @@ class PythonToStubConverter:
                 return f'-{operand}'
         elif isinstance(annotation, ast.Compare):
             # 处理比较操作，如 FF_MAX_SS != FF_MIN_SS
-            left = PythonToStubConverter._GetTypeString(annotation.left)
-            comparators = [PythonToStubConverter._GetTypeString(c) for c in annotation.comparators]
-            ops = []
+            left: str = PythonToStubConverter._GetTypeString(annotation.left)
+            comparators: list[str] = [PythonToStubConverter._GetTypeString(c) for c in annotation.comparators]
+            ops: list[str] = []
             for op in annotation.ops:
                 if isinstance(op, ast.Eq):
                     ops.append('==')
@@ -672,7 +681,7 @@ class PythonToStubConverter:
                     ops.append('>=')
                 else:
                     ops.append('?')
-            result = left
+            result: str = left
             for i, op in enumerate(ops):
                 result += f' {op} {comparators[i]}'
             return result
@@ -682,7 +691,7 @@ class PythonToStubConverter:
             return PythonToStubConverter._GetTypeString(annotation.value)
         elif isinstance(annotation, ast.List):
             # 处理列表，如 [MAX_FILE_DESCRIPTORS]
-            elements = [PythonToStubConverter._GetTypeString(elem) for elem in annotation.elts]
+            elements: list[str] = [PythonToStubConverter._GetTypeString(elem) for elem in annotation.elts]
             return f'[{", ".join(elements)}]'
         elif isinstance(annotation, ast.Call):
             # 处理函数调用形式的类型注解，如 t.Postdefinition(xxa) 或 callable(t.CVoid, app_id = t.CInt)
@@ -690,10 +699,10 @@ class PythonToStubConverter:
             if isinstance(annotation.func, ast.Attribute) and annotation.func.attr in ('__set_default__', '__set_default'):
                 return PythonToStubConverter._GetTypeString(annotation.func.value)
 
-            FuncStr = PythonToStubConverter._GetTypeString(annotation.func)
-            ArgsStr = ', '.join([PythonToStubConverter._GetTypeString(arg) for arg in annotation.args])
+            FuncStr: str = PythonToStubConverter._GetTypeString(annotation.func)
+            ArgsStr: str = ', '.join([PythonToStubConverter._GetTypeString(arg) for arg in annotation.args])
             # 处理关键字参数
-            keywords_str = ', '.join([f'{kw.arg} = {PythonToStubConverter._GetTypeString(kw.value)}' for kw in annotation.keywords])
+            keywords_str: str = ', '.join([f'{kw.arg} = {PythonToStubConverter._GetTypeString(kw.value)}' for kw in annotation.keywords])
             # 合并位置参数和关键字参数
             if ArgsStr and keywords_str:
                 return f'{FuncStr}({ArgsStr}, {keywords_str})'
@@ -704,7 +713,7 @@ class PythonToStubConverter:
         return 't.CVoid'
 
     @staticmethod
-    def _ExtractPostdefClass(annotation: ast.AST) -> Optional[str]:
+    def _ExtractPostdefClass(annotation: ast.AST) -> str | None:
         """从 Postdefinition 类型注解中提取类名
 
         例如：t.Postdefinition(__buddy_system) -> '__buddy_system'
@@ -713,21 +722,21 @@ class PythonToStubConverter:
         # 处理 BinOp (如: t.Postdefinition(xxx) | t.CTypedef)
         if isinstance(annotation, ast.BinOp):
             # 递归检查左操作数
-            left_result = PythonToStubConverter._ExtractPostdefClass(annotation.left)
+            left_result: str | None = PythonToStubConverter._ExtractPostdefClass(annotation.left)
             if left_result:
                 return left_result
             # 递归检查右操作数
-            right_result = PythonToStubConverter._ExtractPostdefClass(annotation.right)
+            right_result: str | None = PythonToStubConverter._ExtractPostdefClass(annotation.right)
             if right_result:
                 return right_result
             return None
 
         # 处理函数调用 (如: t.Postdefinition(__buddy_system))
         if isinstance(annotation, ast.Call):
-            FuncStr = PythonToStubConverter._GetTypeString(annotation.func)
+            FuncStr: str = PythonToStubConverter._GetTypeString(annotation.func)
             if FuncStr == 't.Postdefinition' and annotation.args:
                 # 提取第一个参数
-                first_arg = annotation.args[0]
+                first_arg: ast.AST = annotation.args[0]
                 if isinstance(first_arg, ast.Name):
                     return first_arg.id
                 elif isinstance(first_arg, ast.Attribute):
@@ -736,20 +745,20 @@ class PythonToStubConverter:
         return None
 
     @staticmethod
-    def _GetImportString(node: ast.Import, SourceLines: List[str] = None) -> str:
+    def _GetImportString(node: ast.Import, SourceLines: list[str] | None = None) -> str:
         """获取导入语句字符串"""
-        parts = []
-        IncludeAliasMap = PythonToStubConverter.IncludeAliasMap
+        parts: list[str] = []
+        IncludeAliasMap: dict[str, str] = PythonToStubConverter.IncludeAliasMap
 
         for alias in node.names:
-            ModuleName = alias.name
+            ModuleName: str = alias.name
             # 检查是否是 __include.xxx 格式的导入
             if ModuleName.startswith('__include.'):
                 # 提取别名（xxx 部分）
-                SubModule = ModuleName[len('__include.'):]
+                SubModule: str = ModuleName[len('__include.'):]
                 if SubModule in IncludeAliasMap:
                     # 替换为实际模块路径
-                    RealModule = IncludeAliasMap[SubModule]
+                    RealModule: str = IncludeAliasMap[SubModule]
                     if alias.asname:
                         parts.append(f'{RealModule} as {alias.asname}')
                     else:
@@ -766,31 +775,31 @@ class PythonToStubConverter:
                 else:
                     parts.append(alias.name)
 
-        result = f'import {", ".join(parts)}'
+        result: str = f'import {", ".join(parts)}'
 
         # 提取并保留注释
         if SourceLines and hasattr(node, 'lineno'):
-            LineIdx = node.lineno - 1
+            LineIdx: int = node.lineno - 1
             if 0 <= LineIdx < len(SourceLines):
-                line = SourceLines[LineIdx]
-                CommentMatch = re.search(r'#.*$', line)
+                line: str = SourceLines[LineIdx]
+                CommentMatch: re.Match | None = re.search(r'#.*$', line)
                 if CommentMatch:
                     result += ' ' + CommentMatch.group(0)
 
         return result
 
     @staticmethod
-    def _GetImportFromString(node: ast.ImportFrom, SourceLines: List[str] = None) -> str:
+    def _GetImportFromString(node: ast.ImportFrom, SourceLines: list[str] | None = None) -> str:
         """获取 from ... import ... 语句字符串"""
-        module = node.module or ''
-        parts = []
-        IncludeAliasMap = PythonToStubConverter.IncludeAliasMap
+        module: str = node.module or ''
+        parts: list[str] = []
+        IncludeAliasMap: dict[str, str] = PythonToStubConverter.IncludeAliasMap
 
         # 处理相对导入 (from . import xxx 或 from ..package import xxx)
         if node.level > 0:
             if module:
                 if node.level == 1:
-                    full_module = f'.{module}'
+                    full_module: str = f'.{module}'
                 else:
                     full_module = '.' * node.level + module
             else:
@@ -803,22 +812,22 @@ class PythonToStubConverter:
             return f'from {full_module} import {", ".join(parts)}'
 
         # 提取注释（在生成结果前获取）
-        comment = ''
+        comment: str = ''
         if SourceLines and hasattr(node, 'lineno'):
             LineIdx = node.lineno - 1
             if 0 <= LineIdx < len(SourceLines):
                 line = SourceLines[LineIdx]
-                CommentMatch = re.search(r'#.*$', line)
+                CommentMatch: re.Match | None = re.search(r'#.*$', line)
                 if CommentMatch:
                     comment = ' ' + CommentMatch.group(0)
 
         # 检查是否是 from __include import xxx 格式
         if module == '__include':
             for alias in node.names:
-                name = alias.name
+                name: str = alias.name
                 if name in IncludeAliasMap:
                     # 替换为实际模块路径
-                    RealModule = IncludeAliasMap[name]
+                    RealModule: str = IncludeAliasMap[name]
                     if alias.asname:
                         parts.append(f'import {RealModule} as {alias.asname}{comment}')
                     else:
@@ -850,8 +859,8 @@ class PythonToStubConverter:
             return decorator.attr
         elif isinstance(decorator, ast.Call):
             # 处理带参数的装饰器，如 @c.Attribute(t.attr.packed)
-            FuncStr = PythonToStubConverter._GetDecoratorString(decorator.func)
-            ArgsStr = ', '.join([PythonToStubConverter._GetTypeString(arg) for arg in decorator.args])
+            FuncStr: str = PythonToStubConverter._GetDecoratorString(decorator.func)
+            ArgsStr: str = ', '.join([PythonToStubConverter._GetTypeString(arg) for arg in decorator.args])
             return f'{FuncStr}({ArgsStr})'
         return ''
 
@@ -860,30 +869,30 @@ class PythonToStubConverter:
         """获取表达式字符串（用于宏调用）"""
         if isinstance(expr, ast.Call):
             # 处理函数调用，如 c.CIf(...), c.CEndif(), c.CUndef(...), c.CPragma(...)
-            FuncStr = PythonToStubConverter._GetDecoratorString(expr.func)
+            FuncStr: str = PythonToStubConverter._GetDecoratorString(expr.func)
             if FuncStr and ('CIf' in FuncStr or 'CEndif' in FuncStr or 'CElif' in FuncStr or 'CElse' in FuncStr or 'CUndef' in FuncStr or 'CPragma' in FuncStr):
-                ArgsStr = ', '.join([PythonToStubConverter._GetTypeString(arg) for arg in expr.args])
+                ArgsStr: str = ', '.join([PythonToStubConverter._GetTypeString(arg) for arg in expr.args])
                 return f'{FuncStr}({ArgsStr})' if ArgsStr else f'{FuncStr}()'
         return ''
 
     @staticmethod
     def _get_if_macro_string(node: ast.If, indent: int = 1) -> str:
         """获取类内部的 if 宏字符串（如 if c.CIf(...):）"""
-        IndentStr = '    ' * indent
-        InnerIndent = '    ' * (indent + 1)
+        IndentStr: str = '    ' * indent
+        InnerIndent: str = '    ' * (indent + 1)
         # 检查条件是否是宏调用
         if isinstance(node.test, ast.Call):
-            FuncStr = PythonToStubConverter._GetDecoratorString(node.test.func)
+            FuncStr: str = PythonToStubConverter._GetDecoratorString(node.test.func)
             if FuncStr and 'CIf' in FuncStr:
-                ArgsStr = ', '.join([PythonToStubConverter._GetTypeString(arg) for arg in node.test.args])
-                result = [f'{IndentStr}if {FuncStr}({ArgsStr}):' if ArgsStr else f'{IndentStr}if {FuncStr}():']
+                ArgsStr: str = ', '.join([PythonToStubConverter._GetTypeString(arg) for arg in node.test.args])
+                result: list[str] = [f'{IndentStr}if {FuncStr}({ArgsStr}):' if ArgsStr else f'{IndentStr}if {FuncStr}():']
                 # 处理 if 体内的语句
                 for item in node.body:
                     if isinstance(item, ast.AnnAssign):
-                        TypeStr = PythonToStubConverter._GetTypeString(item.annotation)
+                        TypeStr: str = PythonToStubConverter._GetTypeString(item.annotation)
                         result.append(f'{InnerIndent}{item.target.id}: {TypeStr}')
                     elif isinstance(item, ast.Expr):
-                        ExprStr = PythonToStubConverter._GetExprString(item.value)
+                        ExprStr: str = PythonToStubConverter._GetExprString(item.value)
                         if ExprStr:
                             result.append(f'{InnerIndent}{ExprStr}')
                 return '\n'.join(result)
@@ -897,28 +906,28 @@ class PythonToStubConverter:
     @staticmethod
     def _ProcessIfMacro(node: ast.If, indent: int = 0) -> str:
         """处理 if 宏节点，支持 elif 和 else"""
-        IndentStr = '    ' * indent
+        IndentStr: str = '    ' * indent
 
         # 检查条件是否是宏调用
         if isinstance(node.test, ast.Call):
-            FuncStr = PythonToStubConverter._GetDecoratorString(node.test.func)
+            FuncStr: str = PythonToStubConverter._GetDecoratorString(node.test.func)
             if FuncStr and 'CIf' in FuncStr:
-                ArgsStr = ', '.join([PythonToStubConverter._GetTypeString(arg) for arg in node.test.args])
-                result = [f'{IndentStr}if {FuncStr}({ArgsStr}):' if ArgsStr else f'{IndentStr}if {FuncStr}():']
+                ArgsStr: str = ', '.join([PythonToStubConverter._GetTypeString(arg) for arg in node.test.args])
+                result: list[str] = [f'{IndentStr}if {FuncStr}({ArgsStr}):' if ArgsStr else f'{IndentStr}if {FuncStr}():']
                 # 处理 if 体内的语句
                 for item in node.body:
                     result.extend(PythonToStubConverter._ProcessMacroBodyItem(item, indent + 1))
 
                 # 处理 elif 和 else
-                current = node
+                current: ast.If = node
                 while current.orelse:
                     if len(current.orelse) == 1 and isinstance(current.orelse[0], ast.If):
                         # elif 情况
-                        elif_node = current.orelse[0]
+                        elif_node: ast.If = current.orelse[0]
                         if isinstance(elif_node.test, ast.Call):
-                            ElifFuncStr = PythonToStubConverter._GetDecoratorString(elif_node.test.func)
+                            ElifFuncStr: str = PythonToStubConverter._GetDecoratorString(elif_node.test.func)
                             if ElifFuncStr and 'CIf' in ElifFuncStr:
-                                ElifArgsStr = ', '.join([PythonToStubConverter._GetTypeString(arg) for arg in elif_node.test.args])
+                                ElifArgsStr: str = ', '.join([PythonToStubConverter._GetTypeString(arg) for arg in elif_node.test.args])
                                 result.append(f'{IndentStr}elif {ElifFuncStr}({ElifArgsStr}):' if ElifArgsStr else f'{IndentStr}elif {ElifFuncStr}():')
                                 for item in elif_node.body:
                                     result.extend(PythonToStubConverter._ProcessMacroBodyItem(item, indent + 1))
@@ -936,32 +945,32 @@ class PythonToStubConverter:
         return ''
 
     @staticmethod
-    def _ProcessMacroBodyItem(item: ast.AST, indent: int = 0) -> list:
+    def _ProcessMacroBodyItem(item: ast.AST, indent: int = 0) -> list[str]:
         """处理宏体内的单个语句"""
-        IndentStr = '    ' * indent
-        result = []
+        IndentStr: str = '    ' * indent
+        result: list[str] = []
 
         if isinstance(item, ast.ClassDef):
-            class_stub = PythonToStubConverter._ConvertClass(item)
+            class_stub: list[str] = PythonToStubConverter._ConvertClass(item)
             for line in class_stub:
                 if line.strip():
                     result.append(f'{IndentStr}{line}')
                 else:
                     result.append(line)
         elif isinstance(item, ast.FunctionDef):
-            FuncStub = PythonToStubConverter._ConvertFunction(item, indent=indent)
+            FuncStub: list[str] = PythonToStubConverter._ConvertFunction(item, indent=indent)
             result.extend(FuncStub)
         elif isinstance(item, ast.AnnAssign):
-            TypeStr = PythonToStubConverter._GetTypeString(item.annotation)
+            TypeStr: str = PythonToStubConverter._GetTypeString(item.annotation)
             result.append(f'{IndentStr}{item.target.id}: {TypeStr}')
         elif isinstance(item, ast.Expr):
-            ExprStr = PythonToStubConverter._GetExprString(item.value)
+            ExprStr: str = PythonToStubConverter._GetExprString(item.value)
             if ExprStr:
                 result.append(f'{IndentStr}{ExprStr}')
         elif isinstance(item, ast.If):
             # 处理嵌套的 if 宏
-            NestedIf = PythonToStubConverter._ProcessIfMacro(item, indent=indent)
+            NestedIf: str = PythonToStubConverter._ProcessIfMacro(item, indent=indent)
             if NestedIf:
                 result.append(NestedIf)
 
-        return result
+        return result