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

Test/TestProject2/temp/067c78e9f121dce3.pyi

@@ -0,0 +1,136 @@
+"""
+Auto-generated Python stub file from w32.win32process.py
+Module: w32.win32process
+"""
+
+import c
+
+
+import t
+from stdint import *
+from w32.win32base import *
+
+PROCESS_TERMINATE: t.CDefine = 0x0001
+PROCESS_CREATE_THREAD: t.CDefine = 0x0002
+PROCESS_VM_OPERATION: t.CDefine = 0x0008
+PROCESS_VM_READ: t.CDefine = 0x0010
+PROCESS_VM_WRITE: t.CDefine = 0x0020
+PROCESS_QUERY_INFORMATION: t.CDefine = 0x0400
+PROCESS_ALL_ACCESS: t.CDefine = 0x001FFFFF
+THREAD_TERMINATE: t.CDefine = 0x0001
+THREAD_SUSPEND_RESUME: t.CDefine = 0x0002
+THREAD_GET_CONTEXT: t.CDefine = 0x0008
+THREAD_SET_CONTEXT: t.CDefine = 0x0010
+THREAD_QUERY_INFORMATION: t.CDefine = 0x0040
+THREAD_ALL_ACCESS: t.CDefine = 0x001FFFFF
+CREATE_SUSPENDED: t.CDefine = 0x00000004
+CREATE_NEW_CONSOLE: t.CDefine = 0x00000010
+CREATE_NEW_PROCESS_GROUP: t.CDefine = 0x00000200
+CREATE_NO_WINDOW: t.CDefine = 0x08000000
+DETACHED_PROCESS: t.CDefine = 0x00000008
+STARTF_USESHOWWINDOW: t.CDefine = 0x00000001
+STARTF_USESTDHANDLES: t.CDefine = 0x00000100
+SW_HIDE: t.CDefine = 0
+SW_SHOW: t.CDefine = 5
+SW_MINIMIZE: t.CDefine = 6
+NORMAL_PRIORITY_CLASS: t.CDefine = 0x00000020
+IDLE_PRIORITY_CLASS: t.CDefine = 0x00000040
+HIGH_PRIORITY_CLASS: t.CDefine = 0x00000080
+REALTIME_PRIORITY_CLASS: t.CDefine = 0x00000100
+BELOW_NORMAL_PRIORITY_CLASS: t.CDefine = 0x00004000
+ABOVE_NORMAL_PRIORITY_CLASS: t.CDefine = 0x00008000
+STILL_ACTIVE: t.CDefine = 259
+
+class STARTUPINFOA:
+    cb: ULONG
+    lpReserved: CHARPTR
+    lpDesktop: CHARPTR
+    lpTitle: CHARPTR
+    dwX: ULONG
+    dwY: ULONG
+    dwXSize: ULONG
+    dwYSize: ULONG
+    dwXCountChars: ULONG
+    dwYCountChars: ULONG
+    dwFillAttribute: ULONG
+    dwFlags: ULONG
+    wShowWindow: WORD
+    cbReserved2: WORD
+    lpReserved2: VOIDPTR
+    hStdInput: HANDLE
+    hStdOutput: HANDLE
+    hStdError: HANDLE
+class STARTUPINFOW:
+    cb: ULONG
+    lpReserved: WCHARPTR
+    lpDesktop: WCHARPTR
+    lpTitle: WCHARPTR
+    dwX: ULONG
+    dwY: ULONG
+    dwXSize: ULONG
+    dwYSize: ULONG
+    dwXCountChars: ULONG
+    dwYCountChars: ULONG
+    dwFillAttribute: ULONG
+    dwFlags: ULONG
+    wShowWindow: WORD
+    cbReserved2: WORD
+    lpReserved2: VOIDPTR
+    hStdInput: HANDLE
+    hStdOutput: HANDLE
+    hStdError: HANDLE
+class PROCESS_INFORMATION:
+    hProcess: HANDLE
+    hThread: HANDLE
+    dwProcessId: ULONG
+    dwThreadId: ULONG
+
+def CreateProcessA(lpApplicationName: LPCSTR, lpCommandLine: CHARPTR, lpProcessAttributes: SECURITY_ATTRIBUTES | t.CPtr, lpThreadAttributes: SECURITY_ATTRIBUTES | t.CPtr, bInheritHandles: BOOL, dwCreationFlags: ULONG, lpEnvironment: VOIDPTR, lpCurrentDirectory: LPCSTR, lpStartupInfo: STARTUPINFOA | t.CPtr, lpProcessInformation: PROCESS_INFORMATION | t.CPtr) -> BOOL | t.State: pass
+
+def CreateProcessW(lpApplicationName: LPCWSTR, lpCommandLine: WCHARPTR, lpProcessAttributes: SECURITY_ATTRIBUTES | t.CPtr, lpThreadAttributes: SECURITY_ATTRIBUTES | t.CPtr, bInheritHandles: BOOL, dwCreationFlags: ULONG, lpEnvironment: VOIDPTR, lpCurrentDirectory: LPCWSTR, lpStartupInfo: STARTUPINFOW | t.CPtr, lpProcessInformation: PROCESS_INFORMATION | t.CPtr) -> BOOL | t.State: pass
+
+def TerminateProcess(hProcess: HANDLE, uExitCode: UINT) -> BOOL | t.State: pass
+
+def GetExitCodeProcess(hProcess: HANDLE, lpExitCode: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def GetExitCodeThread(hThread: HANDLE, lpExitCode: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def OpenProcess(dwDesiredAccess: ULONG, bInheritHandle: BOOL, dwProcessId: ULONG) -> HANDLE | t.State: pass
+
+def GetCurrentProcess() -> HANDLE | t.State: pass
+
+def GetCurrentProcessId() -> ULONG | t.State: pass
+
+def CreateThread(lpThreadAttributes: SECURITY_ATTRIBUTES | t.CPtr, dwStackSize: t.CSizeT, lpStartAddress: VOIDPTR, lpParameter: VOIDPTR, dwCreationFlags: ULONG, lpThreadId: ULONG | t.CPtr) -> HANDLE | t.State: pass
+
+def OpenThread(dwDesiredAccess: ULONG, bInheritHandle: BOOL, dwThreadId: ULONG) -> HANDLE | t.State: pass
+
+def SuspendThread(hThread: HANDLE) -> ULONG | t.State: pass
+
+def ResumeThread(hThread: HANDLE) -> ULONG | t.State: pass
+
+def TerminateThread(hThread: HANDLE, dwExitCode: ULONG) -> BOOL | t.State: pass
+
+def GetCurrentThread() -> HANDLE | t.State: pass
+
+def GetCurrentThreadId() -> ULONG | t.State: pass
+
+def GetThreadId(hThread: HANDLE) -> ULONG | t.State: pass
+
+def GetProcessId(hProcess: HANDLE) -> ULONG | t.State: pass
+
+def SetThreadPriority(hThread: HANDLE, nPriority: INT) -> BOOL | t.State: pass
+
+def GetThreadPriority(hThread: HANDLE) -> INT | t.State: pass
+
+def ExitProcess(uExitCode: UINT) -> VOID | t.State: pass
+
+def ExitThread(dwExitCode: ULONG) -> VOID | t.State: pass
+
+def TlsAlloc() -> ULONG | t.State: pass
+
+def TlsFree(dwTlsIndex: ULONG) -> BOOL | t.State: pass
+
+def TlsGetValue(dwTlsIndex: ULONG) -> VOIDPTR | t.State: pass
+
+def TlsSetValue(dwTlsIndex: ULONG, lpTlsValue: VOIDPTR) -> BOOL | t.State: pass

Test/TestProject2/temp/0991af0d22263577.pyi

@@ -0,0 +1,50 @@
+"""
+Auto-generated Python stub file from mpool.py
+Module: mpool
+"""
+
+
+import t, c
+from stdint import *
+import viperio
+import string
+
+MPOOL_ALIGN: t.CDefine = 8
+MPOOL_TYPE_SLAB: t.CDefine = 0
+MPOOL_TYPE_BUMP: t.CDefine = 1
+
+def _align_up(val: t.CSizeT, align: t.CSizeT) -> t.CSizeT: pass
+
+
+class MPool:
+    mtype: t.CInt
+    mem: t.CVoid | t.CPtr
+    mem_size: t.CSizeT
+    offset: t.CSizeT
+    high_water: t.CSizeT
+    block_size: t.CSizeT
+    block_count: t.CSizeT
+    used_count: t.CSizeT
+    free_list: t.CVoid | t.CPtr
+    alloc_map: t.CUInt8T | t.CPtr
+    alloc_map_size: t.CSizeT
+    def __init__(self: MPool, mem: t.CVoid | t.CPtr, mem_size: t.CSizeT, block_size: t.CSizeT) -> t.CInt: pass
+    def _init_bump(self: MPool, mem: t.CVoid | t.CPtr, mem_size: t.CSizeT) -> t.CInt: pass
+    def _init_slab(self: MPool, mem: t.CVoid | t.CPtr, mem_size: t.CSizeT, block_size: t.CSizeT) -> t.CInt: pass
+    def __enter__(self: MPool) -> 'MPool' | t.CPtr: pass
+    def __exit__(self: MPool) -> t.CInt: pass
+    def _slab_reset(self: MPool) -> t.CInt: pass
+    def alloc(self: MPool, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
+    def alloc_buf(self: MPool, capacity: t.CSizeT) -> viperio.Buf | t.CPtr: pass
+    def free(self: MPool, ptr: t.CVoid | t.CPtr) -> t.CInt: pass
+    def realloc(self: MPool, ptr: t.CVoid | t.CPtr, old_size: t.CSizeT, new_size: t.CSizeT) -> t.CVoid | t.CPtr: pass
+    def reset(self: MPool) -> t.CInt: pass
+    def _bump_alloc(self: MPool, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
+    def _slab_alloc(self: MPool) -> t.CVoid | t.CPtr: pass
+    def _slab_free(self: MPool, ptr: t.CVoid | t.CPtr) -> t.CInt: pass
+
+def bump_create(mem: t.CVoid | t.CPtr, mem_size: t.CSizeT) -> MPool | t.CPtr: pass
+
+def alloc(pool: MPool | t.CPtr, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
+
+def reset(pool: MPool | t.CPtr) -> t.CInt: pass

Test/TestProject2/temp/09ba6d4617920d26.pyi

@@ -1,17 +0,0 @@
-"""
-Auto-generated Python stub file from main.py
-Module: main
-"""
-
-import t
-import c
-
-
-import stdio
-import stdint
-import zc.config as config
-import zc.test as test
-import zc.logic_test as logic
-import zc.class_test as class_test
-
-def main() -> stdint.INT: pass

Test/TestProject2/temp/257e074b935c33b4.pyi

@@ -0,0 +1,45 @@
+"""
+Auto-generated Python stub file from binascii.py
+Module: binascii
+"""
+
+
+import t, c
+
+HEX_CHARS: t.CExtern | t.CArray[t.CChar, None]
+HEX_VALS: t.CExtern | t.CArray[t.CInt, 256]
+B64_CHARS: t.CExtern | t.CArray[t.CChar, None]
+B64_VALS: t.CExtern | t.CArray[t.CInt, 256]
+HQX_CHARS: t.CExtern | t.CArray[t.CChar, 64]
+HQX_VALS: t.CExtern | t.CArray[t.CInt, 256]
+UU_CHARS: t.CExtern | t.CArray[t.CChar, None]
+CRC32_TABLE: t.CExtern | t.CArray[t.CUnsignedInt, 256]
+CRC_HQX_TABLE: t.CExtern | t.CArray[t.CUnsignedShort, 256]
+
+def init_binascii() -> t.CInt: pass
+
+def crc32(data: str, length: t.CInt, crc: t.CUnsignedInt) -> t.CUnsignedInt: pass
+
+def crc_hqx(data: str, length: t.CInt, crc: t.CUnsignedShort) -> t.CUnsignedShort: pass
+
+def hexlify(data: str, length: t.CInt) -> str: pass
+
+def b2a_hex(data: str, length: t.CInt) -> str: pass
+
+def a2b_hex(hexstr: str, length: t.CInt) -> str: pass
+
+def unhexlify(data: str, length: t.CInt) -> t.CInt: pass
+
+def b2a_base64(data: str, length: t.CInt) -> str: pass
+
+def a2b_base64(data: str, length: t.CInt) -> str: pass
+
+def b2a_uu(data: str, length: t.CInt) -> str: pass
+
+def a2b_uu(data: str) -> str: pass
+
+def b2a_hqx(data: str, length: t.CInt, crc: t.CUnsignedShort) -> tuple[str, t.CUnsignedShort]: pass
+
+def a2b_hqx(data: str, crc: t.CUnsignedShort) -> tuple[str, t.CUnsignedShort]: pass
+
+def adler32(data: str, length: t.CInt, adler: t.CUnsignedInt) -> t.CUnsignedInt: pass

Test/TestProject2/temp/29813d57621099a9.pyi

@@ -0,0 +1,85 @@
+"""
+Auto-generated Python stub file from w32.win32sync.py
+Module: w32.win32sync
+"""
+
+import c
+
+
+import t
+from stdint import *
+from w32.win32base import *
+
+class CRITICAL_SECTION:
+    DebugInfo: VOIDPTR
+    LockCount: LONG
+    RecursionCount: LONG
+    OwningThread: HANDLE
+    LockSemaphore: HANDLE
+    SpinCount: QWORD
+
+def InitializeCriticalSection(lpCriticalSection: CRITICAL_SECTION | t.CPtr) -> VOID | t.State: pass
+
+def EnterCriticalSection(lpCriticalSection: CRITICAL_SECTION | t.CPtr) -> VOID | t.State: pass
+
+def LeaveCriticalSection(lpCriticalSection: CRITICAL_SECTION | t.CPtr) -> VOID | t.State: pass
+
+def DeleteCriticalSection(lpCriticalSection: CRITICAL_SECTION | t.CPtr) -> VOID | t.State: pass
+
+def TryEnterCriticalSection(lpCriticalSection: CRITICAL_SECTION | t.CPtr) -> BOOL | t.State: pass
+
+def SetCriticalSectionSpinCount(lpCriticalSection: CRITICAL_SECTION | t.CPtr, dwSpinCount: ULONG) -> ULONG | t.State: pass
+
+def InitializeCriticalSectionAndSpinCount(lpCriticalSection: CRITICAL_SECTION | t.CPtr, dwSpinCount: ULONG) -> BOOL | t.State: pass
+
+def CreateMutexA(lpMutexAttributes: SECURITY_ATTRIBUTES | t.CPtr, bInitialOwner: BOOL, lpName: LPCSTR) -> HANDLE | t.State: pass
+
+def CreateMutexW(lpMutexAttributes: SECURITY_ATTRIBUTES | t.CPtr, bInitialOwner: BOOL, lpName: LPCWSTR) -> HANDLE | t.State: pass
+
+def OpenMutexA(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCSTR) -> HANDLE | t.State: pass
+
+def OpenMutexW(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCWSTR) -> HANDLE | t.State: pass
+
+def ReleaseMutex(hMutex: HANDLE) -> BOOL | t.State: pass
+
+def CreateEventA(lpEventAttributes: SECURITY_ATTRIBUTES | t.CPtr, bManualReset: BOOL, bInitialState: BOOL, lpName: LPCSTR) -> HANDLE | t.State: pass
+
+def CreateEventW(lpEventAttributes: SECURITY_ATTRIBUTES | t.CPtr, bManualReset: BOOL, bInitialState: BOOL, lpName: LPCWSTR) -> HANDLE | t.State: pass
+
+def OpenEventA(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCSTR) -> HANDLE | t.State: pass
+
+def OpenEventW(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCWSTR) -> HANDLE | t.State: pass
+
+def SetEvent(hEvent: HANDLE) -> BOOL | t.State: pass
+
+def ResetEvent(hEvent: HANDLE) -> BOOL | t.State: pass
+
+def PulseEvent(hEvent: HANDLE) -> BOOL | t.State: pass
+
+def CreateSemaphoreA(lpSemaphoreAttributes: SECURITY_ATTRIBUTES | t.CPtr, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCSTR) -> HANDLE | t.State: pass
+
+def CreateSemaphoreW(lpSemaphoreAttributes: SECURITY_ATTRIBUTES | t.CPtr, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCWSTR) -> HANDLE | t.State: pass
+
+def OpenSemaphoreA(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCSTR) -> HANDLE | t.State: pass
+
+def OpenSemaphoreW(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCWSTR) -> HANDLE | t.State: pass
+
+def ReleaseSemaphore(hSemaphore: HANDLE, lReleaseCount: LONG, lpPreviousCount: LONG | t.CPtr) -> BOOL | t.State: pass
+
+def WaitForSingleObject(hHandle: HANDLE, dwMilliseconds: ULONG) -> ULONG | t.State: pass
+
+def WaitForSingleObjectEx(hHandle: HANDLE, dwMilliseconds: ULONG, bAlertable: BOOL) -> ULONG | t.State: pass
+
+def WaitForMultipleObjects(nCount: ULONG, lpHandles: VOIDPTR, bWaitAll: BOOL, dwMilliseconds: ULONG) -> ULONG | t.State: pass
+
+def WaitForMultipleObjectsEx(nCount: ULONG, lpHandles: VOIDPTR, bWaitAll: BOOL, dwMilliseconds: ULONG, bAlertable: BOOL) -> ULONG | t.State: pass
+
+def InitializeSRWLock(SRWLock: VOIDPTR) -> VOID | t.State: pass
+
+def AcquireSRWLockExclusive(SRWLock: VOIDPTR) -> VOID | t.State: pass
+
+def AcquireSRWLockShared(SRWLock: VOIDPTR) -> VOID | t.State: pass
+
+def ReleaseSRWLockExclusive(SRWLock: VOIDPTR) -> VOID | t.State: pass
+
+def ReleaseSRWLockShared(SRWLock: VOIDPTR) -> VOID | t.State: pass

Test/TestProject2/temp/49bd8cba55979f76.pyi

@@ -64,4 +64,12 @@ CHAR16: t.CTypedef = t.CChar16T
 CHAR32: t.CTypedef = t.CChar32T
 CHAR8PTR: t.CTypedef = t.CChar8T | t.CPtr
 CHAR16PTR: t.CTypedef = t.CChar16T | t.CPtr
-CHAR32PTR: t.CTypedef = t.CChar32T | t.CPtr
+CHAR32PTR: t.CTypedef = t.CChar32T | t.CPtr
+i8: t.CTypedef = t.CInt8T
+i16: t.CTypedef = t.CInt16T
+i32: t.CTypedef = t.CInt32T
+i64: t.CTypedef = t.CInt64T
+u8: t.CTypedef = t.CUInt8T
+u16: t.CTypedef = t.CUInt16T
+u32: t.CTypedef = t.CUInt32T
+u64: t.CTypedef = t.CUInt64T

Test/TestProject2/temp/541a1ed9b8be53c8.pyi

@@ -0,0 +1,16 @@
+"""
+Auto-generated Python stub file from main.py
+Module: main
+"""
+
+
+from stdint import *
+import w32.win32console
+import config
+import hashlib
+import binascii
+import zlib.pyzlib as zp
+import t, c
+import testcheck
+
+def main() -> t.CInt | t.CExport: pass

Test/TestProject2/temp/59d33b6ab0c70953.pyi

@@ -0,0 +1,52 @@
+"""
+Auto-generated Python stub file from zlib.zinflate.py
+Module: zlib.zinflate
+"""
+
+
+from stdint import *
+import zlib.zchecksum as zchecksum
+import zlib.zdef as zdef
+import zlib.zhuff as zhuff
+import string
+import mpool
+import t, c
+
+@t.Object
+class zinflate_stream:
+    pool: mpool.MPool | t.CPtr
+    reader: zdef.zbit_reader
+    window: BYTEPTR
+    window_pos: t.CInt
+    window_size: t.CInt
+    wbits: t.CInt
+    is_finished: t.CInt
+    is_initialized: t.CInt
+    header_parsed: t.CInt
+    is_gzip: t.CInt
+    adler: t.CUInt32T
+    crc: t.CUInt32T
+    output: BYTEPTR
+    output_len: t.CSizeT
+    output_cap: t.CSizeT
+    input_data: t.CConst | BYTEPTR
+    input_len: t.CSizeT
+    input_pos: t.CSizeT
+    max_length: t.CSizeT
+    def __init__(self: zinflate_stream) -> t.CInt: pass
+    def output_byte(self: zinflate_stream, byte: BYTE) -> t.CInt: pass
+    def parse_header(self: zinflate_stream) -> t.CInt: pass
+    def read_bits_from_input(self: zinflate_stream, nbits: t.CInt, out: UINTPTR) -> t.CInt: pass
+    def read_huffman(self: zinflate_stream, dt: zhuff.zhuff_decode_tree | t.CPtr) -> t.CInt: pass
+    def inflate_block_stored(self: zinflate_stream) -> t.CInt: pass
+    def inflate_block_fixed(self: zinflate_stream) -> t.CInt: pass
+    def inflate_block_dynamic(self: zinflate_stream) -> t.CInt: pass
+    def inflate_stream(self: zinflate_stream) -> t.CInt: pass
+    def decompress(self: zinflate_stream, data: UINT8PTR, length: t.CSizeT, max_length: t.CSizeT, out: t.CUInt8T | t.CPtr[t.CPtr], out_len: t.CSizeT | t.CPtr) -> t.CInt: pass
+    def set_dictionary(self: zinflate_stream, dict: UINT8PTR, length: t.CSizeT) -> t.CInt: pass
+    def copy(self: zinflate_stream) -> zinflate_stream | t.CPtr: pass
+    def destroy(self: zinflate_stream) -> t.CInt: pass
+
+def zinflate_one_shot(pool: mpool.MPool | t.CPtr, data: UINT8PTR, length: t.CSizeT, wbits: t.CInt, bufsize: t.CSizeT, out_len: t.CSizeT | t.CPtr) -> t.CUInt8T | t.CPtr: pass
+
+def zinflate_create(pool: mpool.MPool | t.CPtr, wbits: t.CInt) -> zinflate_stream | t.CPtr: pass

Test/TestProject2/temp/5a6a2137958c28c5.pyi

@@ -0,0 +1,98 @@
+"""
+Auto-generated Python stub file from w32.win32base.py
+Module: w32.win32base
+"""
+
+import c
+
+
+import t
+from stdint import *
+
+HANDLE: t.CTypedef = VOIDPTR
+LPCSTR: t.CTypedef = t.CConst | t.CChar | t.CPtr
+LPCWSTR: t.CTypedef = t.CConst | t.CUnsignedShort | t.CPtr
+INVALID_HANDLE_VALUE: t.CDefine = t.CVoid(-1)
+NULL: t.CDefine = 0
+TRUE: t.CDefine = 1
+FALSE: t.CDefine = 0
+INFINITE: t.CDefine = 0xFFFFFFFF
+WAIT_FAILED: t.CDefine = 0xFFFFFFFF
+WAIT_OBJECT_0: t.CDefine = 0
+WAIT_TIMEOUT: t.CDefine = 258
+WAIT_ABANDONED: t.CDefine = 0x80
+MAX_PATH: t.CDefine = 260
+ERROR_SUCCESS: t.CDefine = 0
+ERROR_FILE_NOT_FOUND: t.CDefine = 2
+ERROR_ACCESS_DENIED: t.CDefine = 5
+ERROR_INSUFFICIENT_BUFFER: t.CDefine = 122
+
+class SECURITY_ATTRIBUTES:
+    nLength: ULONG
+    lpSecurityDescriptor: VOIDPTR
+    bInheritHandle: BOOL
+class OVERLAPPED:
+    Internal: ULONGLONG
+    InternalHigh: ULONGLONG
+    Offset: ULONG
+    OffsetHigh: ULONG
+    hEvent: HANDLE
+class FILETIME:
+    dwLowDateTime: DWORD
+    dwHighDateTime: DWORD
+class SYSTEMTIME:
+    wYear: WORD
+    wMonth: WORD
+    wDayOfWeek: WORD
+    wDay: WORD
+    wHour: WORD
+    wMinute: WORD
+    wSecond: WORD
+    wMilliseconds: WORD
+class GUID:
+    Data1: DWORD
+    Data2: WORD
+    Data3: WORD
+    Data4: BYTEPTR
+class LARGE_INTEGER:
+    QuadPart: LONGLONG
+class ULARGE_INTEGER:
+    QuadPart: ULONGLONG
+
+def GetLastError() -> ULONG | t.State: pass
+
+def SetLastError(dwErrCode: ULONG) -> t.State: pass
+
+def CloseHandle(hObject: HANDLE) -> BOOL | t.State: pass
+
+def GetProcAddress(hModule: HANDLE, lpProcName: LPCSTR) -> VOIDPTR | t.State: pass
+
+def GetModuleHandleA(lpModuleName: LPCSTR) -> HANDLE | t.State: pass
+
+def GetModuleHandleW(lpModuleName: LPCWSTR) -> HANDLE | t.State: pass
+
+def LoadLibraryA(lpLibFileName: LPCSTR) -> HANDLE | t.State: pass
+
+def LoadLibraryW(lpLibFileName: LPCWSTR) -> HANDLE | t.State: pass
+
+def FreeLibrary(hLibModule: HANDLE) -> BOOL | t.State: pass
+
+def GetSystemTime(lpSystemTime: SYSTEMTIME | t.CPtr) -> t.State: pass
+
+def GetLocalTime(lpSystemTime: SYSTEMTIME | t.CPtr) -> t.State: pass
+
+def FileTimeToSystemTime(lpFileTime: FILETIME | t.CPtr, lpSystemTime: SYSTEMTIME | t.CPtr) -> BOOL | t.State: pass
+
+def SystemTimeToFileTime(lpSystemTime: SYSTEMTIME | t.CPtr, lpFileTime: FILETIME | t.CPtr) -> BOOL | t.State: pass
+
+def QueryPerformanceCounter(lpPerformanceCount: LARGE_INTEGER | t.CPtr) -> BOOL | t.State: pass
+
+def QueryPerformanceFrequency(lpFrequency: LARGE_INTEGER | t.CPtr) -> BOOL | t.State: pass
+
+def Sleep(dwMilliseconds: ULONG) -> t.State: pass
+
+def SleepEx(dwMilliseconds: ULONG, bAlertable: BOOL) -> ULONG | t.State: pass
+
+def GetTickCount() -> ULONG | t.State: pass
+
+def GetTickCount64() -> ULONGLONG | t.State: pass

Test/TestProject2/temp/6c2029b306556c00.pyi

@@ -0,0 +1,18 @@
+"""
+Auto-generated Python stub file from stdlib.py
+Module: stdlib
+"""
+
+import c
+
+
+from stdint import *
+import t
+
+def malloc(size: t.CSizeT) -> t.CVoid | t.CPtr | t.State | t.CExtern | t.CExport: pass
+
+def calloc(nmemb: t.CSizeT, size: t.CSizeT) -> t.CVoid | t.CPtr | t.State | t.CExtern | t.CExport: pass
+
+def realloc(p: t.CVoid | t.CPtr, size: t.CSizeT) -> t.CVoid | t.CPtr | t.State | t.CExtern | t.CExport: pass
+
+def free(p: t.CVoid | t.CPtr) -> None | t.State | t.CExtern | t.CExport: pass

Test/TestProject2/temp/6ff26590374ae6fc.pyi

@@ -0,0 +1,39 @@
+"""
+Auto-generated Python stub file from hashlib.__sha512.py
+Module: hashlib.__sha512
+"""
+
+
+import t, c
+
+SHA512_BLOCK_LEN:  t.CDefine = 128
+SHA512_DIGEST_LEN: t.CDefine =  64
+
+def sha512_ror(x: t.CUInt64T, n: int) -> t.CUInt64T: pass
+
+def sha512_shr(x: t.CUInt64T, n: int) -> t.CUInt64T: pass
+
+def sha512_Ch(x: t.CUInt64T, y: t.CUInt64T, z: t.CUInt64T) -> t.CUInt64T: pass
+
+def sha512_Maj(x: t.CUInt64T, y: t.CUInt64T, z: t.CUInt64T) -> t.CUInt64T: pass
+
+def sha512_BigSigma0(x: t.CUInt64T) -> t.CUInt64T: pass
+
+def sha512_BigSigma1(x: t.CUInt64T) -> t.CUInt64T: pass
+
+def sha512_Sigma0(x: t.CUInt64T) -> t.CUInt64T: pass
+
+def sha512_Sigma1(x: t.CUInt64T) -> t.CUInt64T: pass
+
+
+sha512_K: t.CExtern | t.CArray[t.CUInt64T, 80]
+
+@t.Object
+class sha512:
+    state: t.CArray[t.CUInt64T, 8]
+    count: t.CArray[t.CUInt64T, 2]
+    buf: t.CArray[t.CUInt8T, SHA512_BLOCK_LEN]
+    def __init__(self: sha512) -> t.CInt: pass
+    def transform(self: sha512, block: t.CArray[t.CUInt8T, SHA512_BLOCK_LEN]) -> t.CInt: pass
+    def update(self: sha512, s: str) -> t.CInt: pass
+    def final(self: sha512, out: t.CArray[t.CUInt8T, SHA512_DIGEST_LEN]) -> t.CInt: pass

Test/TestProject2/temp/72e2d5ccb7cedcf1.pyi

@@ -0,0 +1,91 @@
+"""
+Auto-generated Python stub file from w32.win32memory.py
+Module: w32.win32memory
+"""
+
+import c
+
+
+import t
+from stdint import *
+from w32.win32base import *
+
+MEM_COMMIT: t.CDefine = 0x00001000
+MEM_RESERVE: t.CDefine = 0x00002000
+MEM_DECOMMIT: t.CDefine = 0x00004000
+MEM_RELEASE: t.CDefine = 0x00008000
+MEM_FREE: t.CDefine = 0x00010000
+MEM_RESET: t.CDefine = 0x00080000
+MEM_TOP_DOWN: t.CDefine = 0x00100000
+MEM_WRITE_WATCH: t.CDefine = 0x00200000
+MEM_PHYSICAL: t.CDefine = 0x00400000
+MEM_LARGE_PAGES: t.CDefine = 0x20000000
+PAGE_NOACCESS: t.CDefine = 0x01
+PAGE_READONLY: t.CDefine = 0x02
+PAGE_READWRITE: t.CDefine = 0x04
+PAGE_WRITECOPY: t.CDefine = 0x08
+PAGE_EXECUTE: t.CDefine = 0x10
+PAGE_EXECUTE_READ: t.CDefine = 0x20
+PAGE_EXECUTE_READWRITE: t.CDefine = 0x40
+PAGE_EXECUTE_WRITECOPY: t.CDefine = 0x80
+PAGE_GUARD: t.CDefine = 0x100
+PAGE_NOCACHE: t.CDefine = 0x200
+PAGE_WRITECOMBINE: t.CDefine = 0x400
+HEAP_NO_SERIALIZE: t.CDefine = 0x00000001
+HEAP_GROWABLE: t.CDefine = 0x00000002
+HEAP_GENERATE_EXCEPTIONS: t.CDefine = 0x00000004
+HEAP_ZERO_MEMORY: t.CDefine = 0x00000008
+HEAP_REALLOC_IN_PLACE_ONLY: t.CDefine = 0x00000010
+
+class MEMORY_BASIC_INFORMATION:
+    BaseAddress: VOIDPTR
+    AllocationBase: VOIDPTR
+    AllocationProtect: ULONG
+    RegionSize: t.CSizeT
+    State: ULONG
+    Protect: ULONG
+    Type: ULONG
+
+def VirtualAlloc(lpAddress: VOIDPTR, dwSize: t.CSizeT, flAllocationType: ULONG, flProtect: ULONG) -> VOIDPTR | t.State: pass
+
+def VirtualFree(lpAddress: VOIDPTR, dwSize: t.CSizeT, dwFreeType: ULONG) -> BOOL | t.State: pass
+
+def VirtualProtect(lpAddress: VOIDPTR, dwSize: t.CSizeT, flNewProtect: ULONG, lpflOldProtect: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def VirtualQuery(lpAddress: t.CConst | VOIDPTR, lpBuffer: MEMORY_BASIC_INFORMATION | t.CPtr, dwLength: t.CSizeT) -> t.CSizeT | t.State: pass
+
+def VirtualLock(lpAddress: VOIDPTR, dwSize: t.CSizeT) -> BOOL | t.State: pass
+
+def VirtualUnlock(lpAddress: VOIDPTR, dwSize: t.CSizeT) -> BOOL | t.State: pass
+
+def GetProcessHeap() -> HANDLE | t.State: pass
+
+def HeapCreate(flOptions: ULONG, dwInitialSize: t.CSizeT, dwMaximumSize: t.CSizeT) -> HANDLE | t.State: pass
+
+def HeapDestroy(hHeap: HANDLE) -> BOOL | t.State: pass
+
+def HeapAlloc(hHeap: HANDLE, dwFlags: ULONG, dwBytes: t.CSizeT) -> VOIDPTR | t.State: pass
+
+def HeapReAlloc(hHeap: HANDLE, dwFlags: ULONG, lpMem: VOIDPTR, dwBytes: t.CSizeT) -> VOIDPTR | t.State: pass
+
+def HeapFree(hHeap: HANDLE, dwFlags: ULONG, lpMem: VOIDPTR) -> BOOL | t.State: pass
+
+def HeapSize(hHeap: HANDLE, dwFlags: ULONG, lpMem: t.CConst | VOIDPTR) -> t.CSizeT | t.State: pass
+
+def HeapValidate(hHeap: HANDLE, dwFlags: ULONG, lpMem: t.CConst | VOIDPTR) -> BOOL | t.State: pass
+
+def HeapCompact(hHeap: HANDLE, dwFlags: ULONG) -> t.CSizeT | t.State: pass
+
+def GlobalAlloc(uFlags: UINT, dwBytes: t.CSizeT) -> VOIDPTR | t.State: pass
+
+def GlobalFree(hMem: VOIDPTR) -> VOIDPTR | t.State: pass
+
+def GlobalLock(hMem: VOIDPTR) -> VOIDPTR | t.State: pass
+
+def GlobalUnlock(hMem: VOIDPTR) -> BOOL | t.State: pass
+
+def GlobalSize(hMem: VOIDPTR) -> t.CSizeT | t.State: pass
+
+def LocalAlloc(uFlags: UINT, dwBytes: t.CSizeT) -> VOIDPTR | t.State: pass
+
+def LocalFree(hMem: VOIDPTR) -> VOIDPTR | t.State: pass

Test/TestProject2/temp/73c1586b83e9b5c2.pyi

@@ -0,0 +1,44 @@
+"""
+Auto-generated Python stub file from zlib.zhuff.py
+Module: zlib.zhuff
+"""
+
+
+from stdint import *
+import zlib.zdef as zdef
+import mpool
+import t, c
+
+ZHUFF_MAX_CODES: t.CDefine = 288
+ZHUFF_MAX_BITS:  t.CDefine = 15
+
+class zhuff_code:
+    code: UINT
+    bits: t.CInt
+@t.Object
+class zhuff_tree:
+    pool: mpool.MPool | t.CPtr
+    codes: t.CArray[zhuff_code, ZHUFF_MAX_CODES]
+    count: t.CInt
+    max_bits: t.CInt
+    def __init__(self: zhuff_tree) -> t.CInt: pass
+    def build_codes(self: zhuff_tree, freqs: INTPTR, count: t.CInt, max_bits: t.CInt) -> t.CInt: pass
+    def build_fixed_lit_tree(self: zhuff_tree) -> t.CInt: pass
+    def build_fixed_dist_tree(self: zhuff_tree) -> t.CInt: pass
+    def encode_symbol(self: zhuff_tree, symbol: int, writer: zdef.zbit_writer | t.CPtr) -> t.CInt: pass
+    def build_code_lengths(self: zhuff_tree, lengths: t.CInt | t.CPtr, freqs: t.CInt | t.CPtr, count: t.CInt, max_bits: t.CInt) -> t.CInt: pass
+    def get_fixed_lit_lengths(self: zhuff_tree, lengths: INTPTR) -> t.CInt: pass
+    def get_fixed_dist_lengths(self: zhuff_tree, lengths: INTPTR) -> t.CInt: pass
+    def build_tree_from_lengths(self: zhuff_tree, lengths: INTPTR, count: t.CInt, max_bits: t.CInt) -> t.CInt: pass
+class zhuff_decode_node:
+    children: t.CArray[t.CInt, 2]
+    symbol: t.CInt
+@t.Object
+class zhuff_decode_tree:
+    pool: mpool.MPool | t.CPtr
+    nodes: t.CArray[zhuff_decode_node, 2 * ZHUFF_MAX_CODES]
+    node_count: t.CInt
+    root: t.CInt
+    def __init__(self: zhuff_decode_tree) -> t.CInt: pass
+    def build_decode_tree(self: zhuff_decode_tree, ht: zhuff_tree | t.CPtr) -> t.CInt: pass
+    def decode_symbol(self: zhuff_decode_tree, reader: zdef.zbit_reader | t.CPtr) -> t.CInt: pass

Test/TestProject2/temp/73fcdc4dd1618580.pyi

@@ -0,0 +1,29 @@
+"""
+Auto-generated Python stub file from hashlib.__sha1.py
+Module: hashlib.__sha1
+"""
+
+
+import t, c
+
+SHA1_BLOCK_LEN:  t.CDefine = 64
+SHA1_DIGEST_LEN: t.CDefine = 20
+
+def sha1_rotl(x: t.CUInt32T, n: t.CInt) -> t.CUInt32T: pass
+
+def sha1_f1(b: t.CUInt32T, c: t.CUInt32T, d: t.CUInt32T) -> t.CUInt32T: pass
+
+def sha1_f2(b: t.CUInt32T, c: t.CUInt32T, d: t.CUInt32T) -> t.CUInt32T: pass
+
+def sha1_f3(b: t.CUInt32T, c: t.CUInt32T, d: t.CUInt32T) -> t.CUInt32T: pass
+
+
+@t.Object
+class sha1:
+    state: t.CArray[t.CUInt32T, 5]
+    count: t.CUInt64T
+    buf: t.CArray[t.CUInt8T, SHA1_BLOCK_LEN]
+    def __init__(self: sha1) -> t.CInt: pass
+    def transform(self: sha1, block: t.CUInt8T | t.CPtr) -> t.CInt: pass
+    def update(self: sha1, s: str) -> t.CInt: pass
+    def final(self: sha1, out: t.CArray[t.CUInt8T, SHA1_DIGEST_LEN]) -> t.CInt: pass

Test/TestProject2/temp/75583f20a922ab2e.pyi

@@ -1,38 +0,0 @@
-"""
-Auto-generated Python stub file from zc.test.py
-Module: zc.test
-"""
-
-
-import config
-import t, c
-
-def AboutSizeTWhileTest(length: t.CSizeT) -> t.CInt: pass
-
-def MathBasicTest(x: t.CInt, y: t.CInt) -> t.CInt: pass
-
-def MathAdvancedTest(value: t.CInt) -> t.CInt: pass
-
-def WhileWithElifElseTest(start: t.CInt, end: t.CInt) -> t.CInt: pass
-
-def NestedWhileWithMacrosTest(outer_limit: t.CInt, inner_limit: t.CInt) -> t.CInt: pass
-
-def ComplexConditionTest(a: t.CInt, b: t.CInt, c_val: t.CInt) -> t.CInt: pass
-
-def RetryLoopTest(retry_count: t.CInt) -> t.CInt: pass
-
-def BitwiseOperationsTest(value: t.CInt) -> t.CInt: pass
-
-def CompoundAssignmentMathTest(a: t.CInt, b: t.CInt) -> t.CInt: pass
-
-def PowerAndModuloTest(base: t.CInt, exponent: t.CInt) -> t.CInt: pass
-
-def MixedArithmeticTest(x: t.CInt, y: t.CInt, z: t.CInt) -> t.CInt: pass
-
-def MathWithWhileLoopTest(start: t.CInt, count: t.CInt) -> t.CInt: pass
-
-def ComplexNestedMathTest(a: t.CInt, b: t.CInt) -> t.CInt: pass
-
-def ConditionalMathChainTest(value: t.CInt) -> t.CInt: pass
-
-def BitManipulationMathTest(value: t.CInt) -> t.CInt: pass

Test/TestProject2/temp/8ebed83a7817fa0c.pyi

@@ -0,0 +1,15 @@
+"""
+Auto-generated Python stub file from zlib.zchecksum.py
+Module: zlib.zchecksum
+"""
+
+
+from stdint import *
+import t, c
+
+def zchecksum_adler32(data: UINT8PTR, length: t.CSizeT, init: UINT32) -> t.CUInt32T: pass
+
+
+crc32_table: t.CExtern | t.CArray[t.CUInt32T, 256]
+
+def zchecksum_crc32(data: UINT8PTR, length: t.CSizeT, init: t.CUInt32T) -> t.CUInt32T: pass

Test/TestProject2/temp/96837bcc64032444.pyi

@@ -0,0 +1,13 @@
+"""
+Auto-generated Python stub file from hashlib.__init__.py
+Module: hashlib.__init__
+"""
+
+import t
+import c
+
+
+from .__md5 import md5, MD5_DIGEST_LEN
+from .__sha1 import sha1, SHA1_DIGEST_LEN
+from .__sha256 import sha256, SHA256_DIGEST_LEN
+from .__sha512 import sha512, SHA512_DIGEST_LEN

Test/TestProject2/temp/9dbecd0942a39782.pyi

@@ -0,0 +1,25 @@
+"""
+Auto-generated Python stub file from testcheck.py
+Module: testcheck
+"""
+
+
+import t, c
+import stdio
+
+_pass_count: t.CExtern | t.CInt
+_fail_count: t.CExtern | t.CInt
+
+def begin(name: str) -> t.CInt: pass
+
+def section(name: str) -> t.CInt: pass
+
+def ok(msg: str) -> t.CInt: pass
+
+def fail(msg: str) -> t.CInt: pass
+
+def check(cond: t.CInt, ok_msg: str, fail_msg: str) -> t.CInt: pass
+
+def info(msg: str) -> t.CInt: pass
+
+def end() -> t.CInt: pass

Test/TestProject2/temp/_sha1_map.txt

@@ -1,7 +1,23 @@
-09ba6d4617920d26:main.py
-56cdd754a8a09347:includes/stdint.py
+0991af0d22263577:includes/mpool.py
+257e074b935c33b4:includes/binascii.py
+49bd8cba55979f76:includes/stdint.py
+541a1ed9b8be53c8:main.py
+59d33b6ab0c70953:includes/zlib\zinflate.py
+5a6a2137958c28c5:includes/w32\win32base.py
+6c2029b306556c00:includes/stdlib.py
+6ff26590374ae6fc:includes/hashlib\__sha512.py
+73c1586b83e9b5c2:includes/zlib\zhuff.py
 73edbcf76e32d00b:includes/stdio.py
-75583f20a922ab2e:zc\test.py
-a7dab00d979c009c:zc\class_test.py
+73fcdc4dd1618580:includes/hashlib\__sha1.py
+8ebed83a7817fa0c:includes/zlib\zchecksum.py
+96837bcc64032444:includes/hashlib\__init__.py
+9dbecd0942a39782:includes/testcheck.py
+b5f1dc665c52a1bd:includes/string.py
+bbdf3bbd4c3bc28c:includes/w32\win32console.py
+c39cbbae4b6e264f:includes/zlib\pyzlib.py
+c9d54a4158f7f5a8:includes/hashlib\__sha256.py
+c9f4be41ca1cc2b4:includes/viperio.py
+cc436a125bbaf28c:includes/hashlib\__md5.py
+cd520d14822f3f19:includes/zlib\zdef.py
 cfc83b830141b00e:zc\config.py
-faec3233d98371da:zc\logic_test.py
+f80740e7bcee16ae:includes/zlib\zdeflate.py

Test/TestProject2/temp/a7dab00d979c009c.pyi

@@ -1,66 +0,0 @@
-"""
-Auto-generated Python stub file from zc.class_test.py
-Module: zc.class_test
-"""
-
-
-import stdio
-import stdint
-import t, c
-
-class SimpleData(t.Object):
-    x: t.CInt
-    y: t.CInt
-class Point3D(t.Object):
-    x: t.CFloat
-    y: t.CFloat
-    z: t.CFloat
-class Student(t.Object):
-    name: t.CChar | t.CPtr
-    age: t.CInt
-    score: t.CInt
-    def __init__(self: Student, n: t.CChar | t.CPtr, a: t.CInt, s: t.CInt) -> t.CInt: pass
-    def get_age(self: Student) -> t.CInt: pass
-    def get_score(self: Student) -> t.CInt: pass
-class Counter(t.Object):
-    value: t.CInt
-    def __init__(self: Counter, initial: t.CInt) -> t.CInt: pass
-    def increment(self: Counter) -> t.CInt: pass
-    def get_value(self: Counter) -> t.CInt: pass
-class StackObj(t.Object):
-    data: t.CInt
-    next_ptr: t.CVoid | t.CPtr
-
-def TestBasicDataClass() -> t.CInt: pass
-
-def TestPoint3DClass() -> t.CInt: pass
-
-def TestStudentClass() -> t.CInt: pass
-
-def TestCounterClass() -> t.CInt: pass
-
-def TestStackAllocation() -> t.CInt: pass
-
-def TestHeapAllocation() -> t.CInt: pass
-
-def TestHeapObjectWithInit() -> t.CInt: pass
-
-def TestMultipleStackObjects() -> t.CInt: pass
-
-def TestImplicitInitCall() -> t.CInt: pass
-
-def TestClassWithBitFields() -> t.CInt: pass
-
-def TestIntArray() -> t.CInt: pass
-
-def TestFloatArray() -> t.CInt: pass
-
-def TestCharArray() -> t.CInt: pass
-
-def TestNestedArray() -> t.CInt: pass
-
-def TestArrayWithStruct() -> t.CInt: pass
-
-def TestArrayPointer() -> t.CInt: pass
-
-def TestDynamicString() -> t.CInt: pass

Test/TestProject2/temp/abf9ce3160c9279e.pyi

@@ -0,0 +1,179 @@
+"""
+Auto-generated Python stub file from w32.win32file.py
+Module: w32.win32file
+"""
+
+import c
+
+
+import t
+from stdint import *
+from w32.win32base import *
+
+GENERIC_READ: t.CDefine = 0x80000000
+GENERIC_WRITE: t.CDefine = 0x40000000
+GENERIC_EXECUTE: t.CDefine = 0x20000000
+GENERIC_ALL: t.CDefine = 0x10000000
+FILE_SHARE_READ: t.CDefine = 0x00000001
+FILE_SHARE_WRITE: t.CDefine = 0x00000002
+FILE_SHARE_DELETE: t.CDefine = 0x00000004
+CREATE_NEW: t.CDefine = 1
+CREATE_ALWAYS: t.CDefine = 2
+OPEN_EXISTING: t.CDefine = 3
+OPEN_ALWAYS: t.CDefine = 4
+TRUNCATE_EXISTING: t.CDefine = 5
+FILE_ATTRIBUTE_READONLY: t.CDefine = 0x00000001
+FILE_ATTRIBUTE_HIDDEN: t.CDefine = 0x00000002
+FILE_ATTRIBUTE_SYSTEM: t.CDefine = 0x00000004
+FILE_ATTRIBUTE_DIRECTORY: t.CDefine = 0x00000010
+FILE_ATTRIBUTE_ARCHIVE: t.CDefine = 0x00000020
+FILE_ATTRIBUTE_NORMAL: t.CDefine = 0x00000080
+FILE_ATTRIBUTE_TEMPORARY: t.CDefine = 0x00000100
+FILE_ATTRIBUTE_COMPRESSED: t.CDefine = 0x00000800
+FILE_ATTRIBUTE_OFFLINE: t.CDefine = 0x00001000
+FILE_ATTRIBUTE_ENCRYPTED: t.CDefine = 0x00004000
+FILE_FLAG_WRITE_THROUGH: t.CDefine = 0x80000000
+FILE_FLAG_OVERLAPPED: t.CDefine = 0x40000000
+FILE_FLAG_NO_BUFFERING: t.CDefine = 0x20000000
+FILE_FLAG_RANDOM_ACCESS: t.CDefine = 0x10000000
+FILE_FLAG_SEQUENTIAL_SCAN: t.CDefine = 0x08000000
+FILE_FLAG_DELETE_ON_CLOSE: t.CDefine = 0x04000000
+FILE_FLAG_BACKUP_SEMANTICS: t.CDefine = 0x02000000
+FILE_FLAG_POSIX_SEMANTICS: t.CDefine = 0x01000000
+FILE_BEGIN: t.CDefine = 0
+FILE_CURRENT: t.CDefine = 1
+FILE_END: t.CDefine = 2
+STD_INPUT_HANDLE: t.CDefine = t.CUnsignedLong(-10)
+STD_OUTPUT_HANDLE: t.CDefine = t.CUnsignedLong(-11)
+STD_ERROR_HANDLE: t.CDefine = t.CUnsignedLong(-12)
+MOVEFILE_REPLACE_EXISTING: t.CDefine = 0x00000001
+MOVEFILE_COPY_ALLOWED: t.CDefine = 0x00000002
+MOVEFILE_WRITE_THROUGH: t.CDefine = 0x00000008
+
+class BY_HANDLE_FILE_INFORMATION:
+    dwFileAttributes: ULONG
+    ftCreationTime: FILETIME
+    ftLastAccessTime: FILETIME
+    ftLastWriteTime: FILETIME
+    dwVolumeSerialNumber: ULONG
+    nFileSizeHigh: ULONG
+    nFileSizeLow: ULONG
+    nNumberOfLinks: ULONG
+    nFileIndexHigh: ULONG
+    nFileIndexLow: ULONG
+class WIN32_FIND_DATAA:
+    dwFileAttributes: ULONG
+    ftCreationTime: FILETIME
+    ftLastAccessTime: FILETIME
+    ftLastWriteTime: FILETIME
+    nFileSizeHigh: ULONG
+    nFileSizeLow: ULONG
+    dwReserved0: ULONG
+    dwReserved1: ULONG
+    cFileName: CHARPTR
+    cAlternateFileName: CHARPTR
+class WIN32_FIND_DATAW:
+    dwFileAttributes: ULONG
+    ftCreationTime: FILETIME
+    ftLastAccessTime: FILETIME
+    ftLastWriteTime: FILETIME
+    nFileSizeHigh: ULONG
+    nFileSizeLow: ULONG
+    dwReserved0: ULONG
+    dwReserved1: ULONG
+    cFileName: WCHARPTR
+    cAlternateFileName: WCHARPTR
+
+def CreateFileA(lpFileName: LPCSTR, dwDesiredAccess: ULONG, dwShareMode: ULONG, lpSecurityAttributes: SECURITY_ATTRIBUTES | t.CPtr, dwCreationDisposition: ULONG, dwFlagsAndAttributes: ULONG, hTemplateFile: HANDLE) -> HANDLE | t.State: pass
+
+def CreateFileW(lpFileName: LPCWSTR, dwDesiredAccess: ULONG, dwShareMode: ULONG, lpSecurityAttributes: SECURITY_ATTRIBUTES | t.CPtr, dwCreationDisposition: ULONG, dwFlagsAndAttributes: ULONG, hTemplateFile: HANDLE) -> HANDLE | t.State: pass
+
+def ReadFile(hFile: HANDLE, lpBuffer: VOIDPTR, nNumberOfBytesToRead: ULONG, lpNumberOfBytesRead: ULONG | t.CPtr, lpOverlapped: OVERLAPPED | t.CPtr) -> BOOL | t.State: pass
+
+def WriteFile(hFile: HANDLE, lpBuffer: t.CConst | VOIDPTR, nNumberOfBytesToWrite: ULONG, lpNumberOfBytesWritten: ULONG | t.CPtr, lpOverlapped: OVERLAPPED | t.CPtr) -> BOOL | t.State: pass
+
+def SetFilePointer(hFile: HANDLE, lDistanceToMove: LONG, lpDistanceToMoveHigh: LONG | t.CPtr, dwMoveMethod: ULONG) -> LONG | t.State: pass
+
+def SetFilePointerEx(hFile: HANDLE, liDistanceToMove: LARGE_INTEGER | t.CPtr, lpNewFilePointer: LARGE_INTEGER | t.CPtr, dwMoveMethod: ULONG) -> BOOL | t.State: pass
+
+def GetFileSize(hFile: HANDLE, lpFileSizeHigh: ULONG | t.CPtr) -> ULONG | t.State: pass
+
+def GetFileSizeEx(hFile: HANDLE, lpFileSize: LARGE_INTEGER | t.CPtr) -> BOOL | t.State: pass
+
+def SetEndOfFile(hFile: HANDLE) -> BOOL | t.State: pass
+
+def FlushFileBuffers(hFile: HANDLE) -> BOOL | t.State: pass
+
+def GetFileType(hFile: HANDLE) -> ULONG | t.State: pass
+
+def GetFileAttributesA(lpFileName: LPCSTR) -> ULONG | t.State: pass
+
+def GetFileAttributesW(lpFileName: LPCWSTR) -> ULONG | t.State: pass
+
+def SetFileAttributesA(lpFileName: LPCSTR, dwFileAttributes: ULONG) -> BOOL | t.State: pass
+
+def SetFileAttributesW(lpFileName: LPCWSTR, dwFileAttributes: ULONG) -> BOOL | t.State: pass
+
+def DeleteFileA(lpFileName: LPCSTR) -> BOOL | t.State: pass
+
+def DeleteFileW(lpFileName: LPCWSTR) -> BOOL | t.State: pass
+
+def MoveFileA(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR) -> BOOL | t.State: pass
+
+def MoveFileW(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR) -> BOOL | t.State: pass
+
+def MoveFileExA(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, dwFlags: ULONG) -> BOOL | t.State: pass
+
+def MoveFileExW(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, dwFlags: ULONG) -> BOOL | t.State: pass
+
+def CopyFileA(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, bFailIfExists: BOOL) -> BOOL | t.State: pass
+
+def CopyFileW(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, bFailIfExists: BOOL) -> BOOL | t.State: pass
+
+def CreateDirectoryA(lpPathName: LPCSTR, lpSecurityAttributes: SECURITY_ATTRIBUTES | t.CPtr) -> BOOL | t.State: pass
+
+def CreateDirectoryW(lpPathName: LPCWSTR, lpSecurityAttributes: SECURITY_ATTRIBUTES | t.CPtr) -> BOOL | t.State: pass
+
+def RemoveDirectoryA(lpPathName: LPCSTR) -> BOOL | t.State: pass
+
+def RemoveDirectoryW(lpPathName: LPCWSTR) -> BOOL | t.State: pass
+
+def FindFirstFileA(lpFileName: LPCSTR, lpFindFileData: WIN32_FIND_DATAA | t.CPtr) -> HANDLE | t.State: pass
+
+def FindFirstFileW(lpFileName: LPCWSTR, lpFindFileData: WIN32_FIND_DATAW | t.CPtr) -> HANDLE | t.State: pass
+
+def FindNextFileA(hFindFile: HANDLE, lpFindFileData: WIN32_FIND_DATAA | t.CPtr) -> BOOL | t.State: pass
+
+def FindNextFileW(hFindFile: HANDLE, lpFindFileData: WIN32_FIND_DATAW | t.CPtr) -> BOOL | t.State: pass
+
+def FindClose(hFindFile: HANDLE) -> BOOL | t.State: pass
+
+def GetStdHandle(nStdHandle: ULONG) -> HANDLE | t.State: pass
+
+def SetStdHandle(nStdHandle: ULONG, hHandle: HANDLE) -> BOOL | t.State: pass
+
+def GetFileInformationByHandle(hFile: HANDLE, lpFileInformation: BY_HANDLE_FILE_INFORMATION | t.CPtr) -> BOOL | t.State: pass
+
+def LockFile(hFile: HANDLE, dwFileOffsetLow: ULONG, dwFileOffsetHigh: ULONG, nNumberOfBytesToLockLow: ULONG, nNumberOfBytesToLockHigh: ULONG) -> BOOL | t.State: pass
+
+def UnlockFile(hFile: HANDLE, dwFileOffsetLow: ULONG, dwFileOffsetHigh: ULONG, nNumberOfBytesToUnlockLow: ULONG, nNumberOfBytesToUnlockHigh: ULONG) -> BOOL | t.State: pass
+
+def GetTempPathA(nBufferLength: ULONG, lpBuffer: CHARPTR) -> ULONG | t.State: pass
+
+def GetTempPathW(nBufferLength: ULONG, lpBuffer: WCHARPTR) -> ULONG | t.State: pass
+
+def GetTempFileNameA(lpPathName: LPCSTR, lpPrefixString: LPCSTR, uUnique: UINT, lpTempFileName: CHARPTR) -> UINT | t.State: pass
+
+def GetTempFileNameW(lpPathName: LPCWSTR, lpPrefixString: LPCWSTR, uUnique: UINT, lpTempFileName: WCHARPTR) -> UINT | t.State: pass
+
+def GetCurrentDirectoryA(nBufferLength: ULONG, lpBuffer: CHARPTR) -> ULONG | t.State: pass
+
+def GetCurrentDirectoryW(nBufferLength: ULONG, lpBuffer: WCHARPTR) -> ULONG | t.State: pass
+
+def SetCurrentDirectoryA(lpPathName: LPCSTR) -> BOOL | t.State: pass
+
+def SetCurrentDirectoryW(lpPathName: LPCWSTR) -> BOOL | t.State: pass
+
+def GetModuleFileNameA(hModule: HANDLE, lpFilename: CHARPTR, nSize: ULONG) -> ULONG | t.State: pass
+
+def GetModuleFileNameW(hModule: HANDLE, lpFilename: WCHARPTR, nSize: ULONG) -> ULONG | t.State: pass

Test/TestProject2/temp/b5f1dc665c52a1bd.pyi

@@ -0,0 +1,44 @@
+"""
+Auto-generated Python stub file from string.py
+Module: string
+"""
+
+
+from stdint import *
+import t, c
+
+def strcpy(dest: str, src: str) -> str: pass
+
+def strncpy(dest: str, src: str, n: t.CSizeT) -> str: pass
+
+def strlen(src: str) -> t.CSizeT | t.CExport: pass
+
+def strcmp(str1: str, str2: str) -> t.CInt: pass
+
+def samestr(str1: str, str2: str) -> bool: pass
+
+def strncmp(str1: str, str2: str, n: t.CSizeT) -> t.CInt: pass
+
+def memcmp(ptr1: t.CVoid | t.CPtr, ptr2: t.CVoid | t.CPtr, n: t.CSizeT) -> t.CInt: pass
+
+def strchr(s: str, cr: t.CInt) -> str: pass
+
+def strrchr(s: str, cr: t.CInt) -> str: pass
+
+def strspn(s: str, skip: str) -> int: pass
+
+def memset(ptr: t.CVoid | t.CPtr, value: t.CInt, num: t.CSizeT) -> t.CVoid | t.CPtr | t.CExport: pass
+
+def memset32(ptr: t.CVoid | t.CPtr, value: t.CUInt32T, count: t.CSizeT) -> t.CVoid | t.CPtr: pass
+
+def memcpy(dest: t.CVoid | t.CPtr, src: t.CVoid | t.CPtr, num: t.CSizeT) -> t.CVoid | t.CPtr | t.CExport: pass
+
+def memmove(dest: t.CVoid | t.CPtr, src: t.CVoid | t.CPtr, num: t.CSizeT) -> t.CVoid | t.CPtr: pass
+
+def atoi(src: str) -> t.CInt: pass
+
+def atoll(src: str) -> t.CInt64T: pass
+
+def atof(src: str) -> t.CDouble: pass
+
+def split(s: str, delim: str, result: t.CArray[str]) -> int: pass

Test/TestProject2/temp/bbdf3bbd4c3bc28c.pyi

@@ -0,0 +1,138 @@
+"""
+Auto-generated Python stub file from w32.win32console.py
+Module: w32.win32console
+"""
+
+import c
+
+
+import t
+from stdint import *
+from w32.win32base import *
+
+ENABLE_PROCESSED_INPUT: t.CDefine = 0x0001
+ENABLE_LINE_INPUT: t.CDefine = 0x0002
+ENABLE_ECHO_INPUT: t.CDefine = 0x0004
+ENABLE_WINDOW_INPUT: t.CDefine = 0x0008
+ENABLE_MOUSE_INPUT: t.CDefine = 0x0010
+ENABLE_INSERT_MODE: t.CDefine = 0x0020
+ENABLE_QUICK_EDIT_MODE: t.CDefine = 0x0040
+ENABLE_EXTENDED_FLAGS: t.CDefine = 0x0080
+ENABLE_PROCESSED_OUTPUT: t.CDefine = 0x0001
+ENABLE_WRAP_AT_EOL_OUTPUT: t.CDefine = 0x0002
+ENABLE_VIRTUAL_TERMINAL_PROCESSING: t.CDefine = 0x0004
+DISABLE_NEWLINE_AUTO_RETURN: t.CDefine = 0x0008
+ENABLE_LVB_GRID_WORLDWIDE: t.CDefine = 0x0010
+FOREGROUND_BLUE: t.CDefine = 0x0001
+FOREGROUND_GREEN: t.CDefine = 0x0002
+FOREGROUND_RED: t.CDefine = 0x0004
+FOREGROUND_INTENSITY: t.CDefine = 0x0008
+BACKGROUND_BLUE: t.CDefine = 0x0010
+BACKGROUND_GREEN: t.CDefine = 0x0020
+BACKGROUND_RED: t.CDefine = 0x0040
+BACKGROUND_INTENSITY: t.CDefine = 0x0080
+KEY_EVENT: t.CDefine = 0x0001
+MOUSE_EVENT: t.CDefine = 0x0002
+WINDOW_BUFFER_SIZE_EVENT: t.CDefine = 0x0004
+MENU_EVENT: t.CDefine = 0x0008
+FOCUS_EVENT: t.CDefine = 0x0010
+
+class COORD:
+    X: SHORT
+    Y: SHORT
+class SMALL_RECT:
+    Left: SHORT
+    Top: SHORT
+    Right: SHORT
+    Bottom: SHORT
+class CONSOLE_SCREEN_BUFFER_INFO:
+    dwSize: COORD
+    dwCursorPosition: COORD
+    wAttributes: WORD
+    srWindow: SMALL_RECT
+    dwMaximumWindowSize: COORD
+class CONSOLE_CURSOR_INFO:
+    dwSize: ULONG
+    bVisible: BOOL
+class CHAR_INFO:
+    UnicodeChar: WCHAR
+    Attributes: WORD
+class KEY_EVENT_RECORD:
+    bKeyDown: BOOL
+    wRepeatCount: WORD
+    wVirtualKeyCode: WORD
+    wVirtualScanCode: WORD
+    uChar: WCHAR
+    dwControlKeyState: ULONG
+class MOUSE_EVENT_RECORD:
+    dwMousePosition: COORD
+    dwButtonState: ULONG
+    dwControlKeyState: ULONG
+    dwEventFlags: ULONG
+class WINDOW_BUFFER_SIZE_RECORD:
+    dwSize: COORD
+class INPUT_RECORD:
+    EventType: WORD
+    Event: KEY_EVENT_RECORD
+
+def SetConsoleOutputCP(codepage: UINT) -> BOOL | t.State: pass
+
+def SetConsoleCP(codepage: UINT) -> BOOL | t.State: pass
+
+def GetConsoleCP() -> UINT | t.State: pass
+
+def GetConsoleOutputCP() -> UINT | t.State: pass
+
+def GetConsoleScreenBufferInfo(hConsoleOutput: HANDLE, lpConsoleScreenBufferInfo: CONSOLE_SCREEN_BUFFER_INFO | t.CPtr) -> BOOL | t.State: pass
+
+def SetConsoleScreenBufferSize(hConsoleOutput: HANDLE, dwSize: COORD) -> BOOL | t.State: pass
+
+def SetConsoleCursorPosition(hConsoleOutput: HANDLE, dwCursorPosition: COORD) -> BOOL | t.State: pass
+
+def GetConsoleCursorInfo(hConsoleOutput: HANDLE, lpConsoleCursorInfo: CONSOLE_CURSOR_INFO | t.CPtr) -> BOOL | t.State: pass
+
+def SetConsoleCursorInfo(hConsoleOutput: HANDLE, lpConsoleCursorInfo: CONSOLE_CURSOR_INFO | t.CPtr) -> BOOL | t.State: pass
+
+def SetConsoleTextAttribute(hConsoleOutput: HANDLE, wAttributes: WORD) -> BOOL | t.State: pass
+
+def FillConsoleOutputCharacterA(hConsoleOutput: HANDLE, cCharacter: t.CChar, nLength: ULONG, dwWriteCoord: COORD, lpNumberOfCharsWritten: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def FillConsoleOutputCharacterW(hConsoleOutput: HANDLE, cCharacter: WCHAR, nLength: ULONG, dwWriteCoord: COORD, lpNumberOfCharsWritten: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def FillConsoleOutputAttribute(hConsoleOutput: HANDLE, wAttribute: WORD, nLength: ULONG, dwWriteCoord: COORD, lpNumberOfAttrsWritten: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def WriteConsoleA(hConsoleOutput: HANDLE, lpBuffer: t.CConst | VOIDPTR, nNumberOfCharsToWrite: ULONG, lpNumberOfCharsWritten: ULONG | t.CPtr, lpReserved: VOIDPTR) -> BOOL | t.State: pass
+
+def WriteConsoleW(hConsoleOutput: HANDLE, lpBuffer: t.CConst | VOIDPTR, nNumberOfCharsToWrite: ULONG, lpNumberOfCharsWritten: ULONG | t.CPtr, lpReserved: VOIDPTR) -> BOOL | t.State: pass
+
+def ReadConsoleA(hConsoleInput: HANDLE, lpBuffer: VOIDPTR, nNumberOfCharsToRead: ULONG, lpNumberOfCharsRead: ULONG | t.CPtr, pInputControl: VOIDPTR) -> BOOL | t.State: pass
+
+def ReadConsoleW(hConsoleInput: HANDLE, lpBuffer: VOIDPTR, nNumberOfCharsToRead: ULONG, lpNumberOfCharsRead: ULONG | t.CPtr, pInputControl: VOIDPTR) -> BOOL | t.State: pass
+
+def GetConsoleMode(hConsoleHandle: HANDLE, lpMode: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def SetConsoleMode(hConsoleHandle: HANDLE, dwMode: ULONG) -> BOOL | t.State: pass
+
+def ReadConsoleInputA(hConsoleInput: HANDLE, lpBuffer: INPUT_RECORD | t.CPtr, nLength: ULONG, lpNumberOfEventsRead: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def ReadConsoleInputW(hConsoleInput: HANDLE, lpBuffer: INPUT_RECORD | t.CPtr, nLength: ULONG, lpNumberOfEventsRead: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def GetNumberOfConsoleInputEvents(hConsoleInput: HANDLE, lpNumberOfEvents: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def FlushConsoleInputBuffer(hConsoleInput: HANDLE) -> BOOL | t.State: pass
+
+def SetConsoleTitleA(lpConsoleTitle: LPCSTR) -> BOOL | t.State: pass
+
+def SetConsoleTitleW(lpConsoleTitle: LPCWSTR) -> BOOL | t.State: pass
+
+def GetConsoleTitleA(lpConsoleTitle: CHARPTR, nSize: ULONG) -> ULONG | t.State: pass
+
+def GetConsoleTitleW(lpConsoleTitle: WCHARPTR, nSize: ULONG) -> ULONG | t.State: pass
+
+def AllocConsole() -> BOOL | t.State: pass
+
+def FreeConsole() -> BOOL | t.State: pass
+
+def SetConsoleWindowInfo(hConsoleOutput: HANDLE, bAbsolute: BOOL, lpConsoleWindow: SMALL_RECT | t.CPtr) -> BOOL | t.State: pass
+
+def ScrollConsoleScreenBufferA(hConsoleOutput: HANDLE, lpScrollRectangle: SMALL_RECT | t.CPtr, lpClipRectangle: SMALL_RECT | t.CPtr, dwDestinationOrigin: COORD, lpFill: CHAR_INFO | t.CPtr) -> BOOL | t.State: pass

Test/TestProject2/temp/c39cbbae4b6e264f.pyi

@@ -0,0 +1,126 @@
+"""
+Auto-generated Python stub file from zlib.pyzlib.py
+Module: zlib.pyzlib
+"""
+
+
+from stdint import *
+import zlib.zdeflate as zdeflate
+import zlib.zinflate as zinflate
+import zlib.zchecksum as zchecksum
+import zlib.zdef as zdef
+import zlib.zhuff as zhuff
+import stdlib
+import string
+import stdio
+import mpool
+import t, c
+
+Z_NO_COMPRESSION:      t.CDefine = 0
+Z_BEST_SPEED:          t.CDefine = 1
+Z_BEST_COMPRESSION:    t.CDefine = 9
+Z_DEFAULT_COMPRESSION: t.CDefine = (-1)
+DEFLATED:              t.CDefine = 8
+Z_NO_FLUSH:            t.CDefine = 0
+Z_PARTIAL_FLUSH:       t.CDefine = 1
+Z_SYNC_FLUSH:          t.CDefine = 2
+Z_FULL_FLUSH:          t.CDefine = 3
+Z_FINISH:              t.CDefine = 4
+Z_BLOCK:               t.CDefine = 5
+Z_TREES:               t.CDefine = 6
+Z_DEFAULT_STRATEGY: t.CDefine = 0
+Z_FILTERED:         t.CDefine = 1
+Z_HUFFMAN_ONLY:     t.CDefine = 2
+Z_RLE:              t.CDefine = 3
+Z_FIXED:            t.CDefine = 4
+Z_OK:            t.CDefine = 0
+Z_STREAM_END:    t.CDefine = 1
+Z_NEED_DICT:     t.CDefine = 2
+Z_ERRNO:         t.CDefine = (-1)
+Z_STREAM_ERROR:  t.CDefine = (-2)
+Z_DATA_ERROR:    t.CDefine = (-3)
+Z_MEM_ERROR:     t.CDefine = (-4)
+Z_BUF_ERROR:     t.CDefine = (-5)
+Z_VERSION_ERROR: t.CDefine = (-6)
+MAX_WBITS:       t.CDefine = 15
+DEF_BUF_SIZE:    t.CDefine = 16384
+DEF_MEM_LEVEL:   t.CDefine = 8
+ZLIB_VERSION:    t.CDefine = "1.3.2"
+pyzlib_error_msg: t.CExtern | t.CArray[t.CChar, 512]
+pyzlib_error_code_val: t.CExtern | t.CInt
+
+@t.Object
+class Compress:
+    pool: mpool.MPool | t.CPtr
+    stream: VOIDPTR
+    is_initialized: t.CInt
+    is_finished: t.CInt
+    level: t.CInt
+    method: t.CInt
+    wbits: t.CInt
+    memLevel: t.CInt
+    strategy: t.CInt
+    zdict: BYTEPTR
+    zdict_len: t.CSizeT
+    last_pos: t.CSizeT
+    input_buf: BYTEPTR
+    input_buf_len: t.CSizeT
+    input_buf_cap: t.CSizeT
+    header_written: t.CInt
+    def compress(self: Compress, data: BYTEPTR, data_len: t.CSizeT, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+    def flush(self: Compress, mode: t.CInt, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+    def copy(self: Compress) -> Compress | t.CPtr: pass
+    def delete(self: Compress) -> t.CInt: pass
+    def __del__(self: Compress) -> t.CInt: pass
+@t.Object
+class Decompress:
+    pool: mpool.MPool | t.CPtr
+    stream: VOIDPTR
+    is_initialized: t.CInt
+    eof: t.CInt
+    wbits: t.CInt
+    zdict: BYTEPTR
+    zdict_len: t.CSizeT
+    _unused_data: BYTEPTR
+    _unused_data_len: t.CSizeT
+    _unused_data_cap: t.CSizeT
+    _unconsumed_tail: BYTEPTR
+    _unconsumed_tail_len: t.CSizeT
+    _unconsumed_tail_cap: t.CSizeT
+    input_buf: BYTEPTR
+    input_buf_len: t.CSizeT
+    input_buf_cap: t.CSizeT
+    def decompress(self: Decompress, data: BYTEPTR, data_len: t.CSizeT, max_length: t.CSizeT, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+    def flush(self: Decompress, length: t.CSizeT, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+    def copy(self: Decompress) -> Decompress | t.CPtr: pass
+    def delete(self: Decompress) -> t.CInt: pass
+    def unused_data(self: Decompress, length: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+    def unconsumed_tail(self: Decompress, length: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+
+def set_error(code: int, msg: str) -> t.CInt: pass
+
+def clone_bytes(pool: mpool.MPool | t.CPtr, src: BYTEPTR, length: t.CSizeT) -> BYTEPTR: pass
+
+def append_bytes(pool: mpool.MPool | t.CPtr, buf: BYTE | t.CPtr[t.CPtr], length: t.CSizeT | t.CPtr, cap: t.CSizeT | t.CPtr, data: BYTEPTR, data_len: t.CSizeT) -> t.CInt: pass
+
+def shrink_to_fit(pool: mpool.MPool | t.CPtr, buf: BYTEPTR, length: t.CSizeT) -> BYTEPTR: pass
+
+def runtime_version() -> str: pass
+
+def get_error() -> str: pass
+
+def get_error_code() -> t.CInt: pass
+
+def clear_error() -> t.CInt: pass
+
+def compress(pool: mpool.MPool | t.CPtr, data: BYTEPTR, data_len: t.CSizeT, level: t.CInt, wbits: t.CInt, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+
+def decompress(pool: mpool.MPool | t.CPtr, data: BYTEPTR, data_len: t.CSizeT, wbits: t.CInt, bufsize: t.CSizeT, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+
+def compressobj(pool: mpool.MPool | t.CPtr, level: t.CInt, method: t.CInt, wbits: t.CInt, memLevel: t.CInt, strategy: t.CInt, zdict: BYTEPTR, zdict_len: t.CSizeT) -> Compress | t.CPtr: pass
+
+def decompressobj(pool: mpool.MPool | t.CPtr, wbits: t.CInt, zdict: BYTEPTR, zdict_len: t.CSizeT) -> Decompress | t.CPtr: pass
+
+def zlib_adler32(data: BYTEPTR, length: t.CSizeT, value: t.CUnsignedLong) -> t.CUnsignedLong: pass
+
+def zlib_crc32(data: BYTEPTR, length: t.CSizeT, value: t.CUnsignedLong) -> t.CUnsignedLong: pass

Test/TestProject2/temp/c9d54a4158f7f5a8.pyi

@@ -0,0 +1,34 @@
+"""
+Auto-generated Python stub file from hashlib.__sha256.py
+Module: hashlib.__sha256
+"""
+
+
+import t, c
+
+SHA256_BLOCK_LEN:  t.CDefine = 64
+SHA256_DIGEST_LEN: t.CDefine = 32
+sha256_K: t.CExtern | t.CArray[t.CUInt32T, 64]
+
+def s0(x: t.CUInt32T) -> t.CUInt32T: pass
+
+def s1(x: t.CUInt32T) -> t.CUInt32T: pass
+
+def S0(x: t.CUInt32T) -> t.CUInt32T: pass
+
+def S1(x: t.CUInt32T) -> t.CUInt32T: pass
+
+def Ch(x: t.CUInt32T, y: t.CUInt32T, z: t.CUInt32T) -> t.CUInt32T: pass
+
+def Maj(x: t.CUInt32T, y: t.CUInt32T, z: t.CUInt32T) -> t.CUInt32T: pass
+
+
+@t.Object
+class sha256:
+    state: t.CArray[t.CUInt32T, 8]
+    count: t.CUInt64T
+    buf: t.CArray[t.CUInt8T, SHA256_BLOCK_LEN]
+    def __init__(self: sha256) -> t.CInt: pass
+    def transform(self: sha256, block: t.CUInt8T | t.CPtr) -> t.CInt: pass
+    def update(self: sha256, s: str) -> t.CInt: pass
+    def final(self: sha256, out: t.CArray[t.CUInt8T, SHA256_DIGEST_LEN]) -> t.CInt: pass

Test/TestProject2/temp/c9f4be41ca1cc2b4.pyi

@@ -0,0 +1,22 @@
+"""
+Auto-generated Python stub file from viperio.py
+Module: viperio
+"""
+
+
+import t, c
+from stdint import *
+
+class Buf:
+    data: t.CChar | t.CPtr
+    length: t.CSizeT
+    capacity: t.CSizeT
+    owned: bool
+    def __init__(self: Buf, data: t.CChar | t.CPtr, capacity: t.CSizeT, length: t.CSizeT, owned: bool) -> t.CInt: pass
+    def clear(self: Buf) -> t.CInt: pass
+    def write(self: Buf, src: t.CChar | t.CPtr, count: t.CSizeT) -> t.CSizeT: pass
+    def cstr(self: Buf) -> t.CChar | t.CPtr: pass
+    def reset(self: Buf) -> t.CInt: pass
+    def __enter__(self: Buf) -> 'Buf' | t.CPtr: pass
+    def __exit__(self: Buf) -> t.CInt: pass
+    def free(self: Buf) -> t.CInt: pass

Test/TestProject2/temp/cc436a125bbaf28c.pyi

@@ -0,0 +1,34 @@
+"""
+Auto-generated Python stub file from hashlib.__md5.py
+Module: hashlib.__md5
+"""
+
+
+import t, c
+
+MD5_BLOCK_LEN:  t.CDefine = 64    # 分组块大小
+MD5_DIGEST_LEN: t.CDefine = 16    # 摘要输出长度
+
+def md5_F(x: t.CUInt32T, y: t.CUInt32T, z: t.CUInt32T) -> t.CUInt32T: pass
+
+def md5_G(x: t.CUInt32T, y: t.CUInt32T, z: t.CUInt32T) -> t.CUInt32T: pass
+
+def md5_H(x: t.CUInt32T, y: t.CUInt32T, z: t.CUInt32T) -> t.CUInt32T: pass
+
+def md5_I(x: t.CUInt32T, y: t.CUInt32T, z: t.CUInt32T) -> t.CUInt32T: pass
+
+def md5_rotl(x: t.CUInt32T, n: t.CInt) -> t.CUInt32T: pass
+
+
+md5_T: t.CExtern | t.CArray[t.CUInt32T, 64]
+md5_S: t.CExtern | t.CArray[t.CInt, 64]
+
+@t.Object
+class md5:
+    state: t.CArray[t.CUInt32T, 4]
+    count: t.CUInt64T
+    buf: t.CArray[t.CUInt8T, MD5_BLOCK_LEN]
+    def __init__(self: md5) -> t.CInt: pass
+    def transform(self: md5, block: t.CUInt8T | t.CPtr) -> t.CInt: pass
+    def update(self: md5, s: str) -> t.CInt: pass
+    def final(self: md5, out: t.CArray[t.CUInt8T, MD5_DIGEST_LEN]) -> t.CInt: pass

Test/TestProject2/temp/cd520d14822f3f19.pyi

@@ -0,0 +1,67 @@
+"""
+Auto-generated Python stub file from zlib.zdef.py
+Module: zlib.zdef
+"""
+
+
+from stdint import *
+import stddef
+import string
+import stdlib
+import mpool
+import t, c
+
+ZDEFLATE_WINDOW_BITS: t.CDefine = 15
+ZDEFLATE_WINDOW_SIZE: t.CDefine =    (1 << ZDEFLATE_WINDOW_BITS)
+ZDEFLATE_WINDOW_MASK: t.CDefine =    (ZDEFLATE_WINDOW_SIZE - 1)
+ZDEFLATE_MIN_MATCH: t.CDefine =      3
+ZDEFLATE_MAX_MATCH: t.CDefine =      258
+ZDEFLATE_HASH_BITS: t.CDefine =      15
+ZDEFLATE_HASH_SIZE: t.CDefine =      (1 << ZDEFLATE_HASH_BITS)
+ZDEFLATE_HASH_MASK: t.CDefine =      (ZDEFLATE_HASH_SIZE - 1)
+ZDEFLATE_MAX_CODES:         t.CDefine =      288
+ZDEFLATE_MAX_DIST_CODES:    t.CDefine = 32
+ZDEFLATE_MAX_BITS:          t.CDefine =       15
+ZDEFLATE_MAX_CODELEN_CODES: t.CDefine = 19
+ZDEFLATE_LIT_COUNT:  t.CDefine =      286
+ZDEFLATE_DIST_COUNT: t.CDefine =     30
+ZDEFLATE_LEN_SYMBOLS_BASE: t.CDefine = 257
+ZDEFLATE_END_OF_BLOCK:     t.CDefine =     256
+zdeflate_len_extra_bits: t.CExtern | t.CArray[t.CInt, 29]
+zdeflate_len_base: t.CExtern | t.CArray[t.CInt, 29]
+zdeflate_dist_extra_bits: t.CExtern | t.CArray[t.CInt, 30]
+zdeflate_dist_base: t.CExtern | t.CArray[t.CInt, 30]
+zdeflate_codelen_order: t.CExtern | t.CArray[int, 19]
+
+@t.Object
+class zbit_writer:
+    pool: mpool.MPool | t.CPtr
+    buf: BYTE | t.CPtr
+    cap: t.CSizeT
+    byte_pos: t.CSizeT
+    bit_pos: t.CInt
+    def __init__(self: zbit_writer, pool: mpool.MPool | t.CPtr) -> t.CInt: pass
+    def ensure(self: zbit_writer, need: t.CSizeT) -> t.CInt: pass
+    def write_bits(self: zbit_writer, value: UINT, nbits: t.CInt) -> t.CInt: pass
+    def write_bits_rev(self: zbit_writer, code: UINT, nbits: t.CInt) -> t.CInt: pass
+    def stored_block(self: zbit_writer, data: UINT8PTR, length: t.CSizeT, final: t.CInt) -> t.CInt: pass
+    def write_zlib_header(self: zbit_writer, wbits: t.CInt, level: t.CInt) -> t.CInt: pass
+    def write_gzip_header(self: zbit_writer) -> t.CInt: pass
+    def align(self: zbit_writer) -> t.CInt: pass
+    def total(self: zbit_writer) -> t.CSizeT: pass
+    def free(self: zbit_writer) -> t.CInt: pass
+    def __del__(self: zbit_writer) -> t.CInt: pass
+@t.Object
+class zbit_reader:
+    buf: BYTE | t.CPtr
+    length: t.CSizeT
+    byte_pos: t.CSizeT
+    bit_pos: t.CInt
+    def init(self: zbit_reader, buf: BYTE | t.CPtr, length: t.CSizeT) -> t.CInt: pass
+    def read_bits(self: zbit_reader, nbits: t.CInt, out: UINTPTR) -> t.CInt: pass
+    def read_bits_rev(self: zbit_reader, nbits: t.CInt, out: UINTPTR) -> t.CInt: pass
+    def align(self: zbit_reader) -> t.CInt: pass
+
+def zdef_alloc(pool: mpool.MPool | t.CPtr, n: t.CSizeT) -> VOIDPTR: pass
+
+def zdef_free(pool: mpool.MPool | t.CPtr, p: VOIDPTR) -> t.CInt: pass

Test/TestProject2/temp/f80740e7bcee16ae.pyi

@@ -0,0 +1,57 @@
+"""
+Auto-generated Python stub file from zlib.zdeflate.py
+Module: zlib.zdeflate
+"""
+
+
+from stdint import *
+import zlib.zchecksum as zchecksum
+import zlib.zhuff as zhuff
+import zlib.zdef as zdef
+import string
+import stdio
+import mpool
+import t, c
+
+@t.Object
+class zdeflate_stream:
+    pool: mpool.MPool | t.CPtr
+    writer: zdef.zbit_writer
+    window: BYTE | t.CPtr
+    window_pos: t.CInt
+    window_size: t.CInt
+    hash_head: t.CInt | t.CPtr
+    hash_prev: t.CInt | t.CPtr
+    level: t.CInt
+    strategy: t.CInt
+    wbits: t.CInt
+    is_finished: t.CInt
+    adler: t.CUInt32T
+    def find_match(self: zdeflate_stream, data: BYTE | t.CPtr, data_len: t.CSizeT, pos: t.CSizeT, best_dist: t.CInt | t.CPtr) -> t.CInt: pass
+    def update_hash(self: zdeflate_stream, data: BYTE | t.CPtr, pos: t.CSizeT) -> t.CInt: pass
+    def write_fixed_block(self: zdeflate_stream, data: UINT8PTR, length: t.CSizeT, final: t.CInt) -> t.CInt: pass
+    def encode_block_data(self: zdeflate_stream, data: UINT8PTR, length: t.CSizeT, lit_tree: zhuff.zhuff_tree | t.CPtr, dist_tree: zhuff.zhuff_tree | t.CPtr) -> t.CInt: pass
+    def write_dynamic_block(self: zdeflate_stream, data: UINT8PTR, length: t.CSizeT, final: t.CInt) -> t.CInt: pass
+    def compress_block(self: zdeflate_stream, data: UINT8PTR, length: t.CSizeT, final: t.CInt) -> t.CInt: pass
+    def write_stored_block(self: zdeflate_stream, data: UINT8PTR, length: t.CSizeT, final: t.CInt) -> t.CInt: pass
+    def compress(self: zdeflate_stream, data: UINT8PTR, length: t.CSizeT, out: t.CUInt8T | t.CPtr[t.CPtr], out_len: t.CSizeT | t.CPtr) -> t.CInt: pass
+    def flush(self: zdeflate_stream, mode: t.CInt, out: t.CUInt8T | t.CPtr[t.CPtr], out_len: t.CSizeT | t.CPtr) -> t.CInt: pass
+    def set_dictionary(self: zdeflate_stream, dict: UINT8PTR, length: t.CSizeT) -> t.CInt: pass
+    def copy(self: zdeflate_stream) -> zdeflate_stream | t.CPtr: pass
+    def destroy(self: zdeflate_stream) -> t.CInt: pass
+
+def zdeflate_count_freqs(lit_freqs: INTPTR, dist_freqs: INTPTR, s: zdeflate_stream | t.CPtr, data: UINT8PTR, length: t.CSizeT) -> t.CInt: pass
+
+def zdeflate_hash(p: BYTE | t.CPtr) -> t.CUnsignedInt: pass
+
+def zdeflate_len_to_symbol(length: t.CInt) -> t.CInt: pass
+
+def zdeflate_dist_to_symbol(dist: t.CInt) -> t.CInt: pass
+
+def zdeflate_count_cl_freqs(all_lengths: INTPTR, total: t.CInt, cl_freqs: INTPTR) -> t.CInt: pass
+
+def zdeflate_write_cl_encoded(all_lengths: INTPTR, total: t.CInt, w: zdef.zbit_writer | t.CPtr, cl_tree: zhuff.zhuff_tree | t.CPtr) -> t.CInt: pass
+
+def zdeflate_create(pool: mpool.MPool | t.CPtr, level: t.CInt, wbits: t.CInt, mem_level: t.CInt, strategy: t.CInt) -> zdeflate_stream | t.CPtr: pass
+
+def zdeflate_one_shot(pool: mpool.MPool | t.CPtr, data: UINT8PTR, length: t.CSizeT, level: t.CInt, wbits: t.CInt, out_len: t.CSizeT | t.CPtr) -> t.CUInt8T | t.CPtr: pass

Test/TestProject2/temp/fa3691e66b426950.pyi

@@ -0,0 +1,80 @@
+"""
+Auto-generated Python stub file from w32.fileio.py
+Module: w32.fileio
+"""
+
+
+import t, c
+from stdint import *
+import w32.win32base
+import w32.win32file
+
+class MODE(t.CEnum):
+    R = 0
+    W = 1
+    A = 2
+    RP = 3
+    WP = 4
+    AP = 5
+    X = 6
+    XP = 7
+class FRESULT(t.CEnum):
+    OK = 0
+    ERR = -1
+    ERR_CLOSED = -2
+    ERR_PERM = -3
+    ERR_IO = -4
+    ERR_NOTFOUND = -5
+
+SEEK_SET: t.CDefine = 0
+SEEK_CUR: t.CDefine = 1
+SEEK_END: t.CDefine = 2
+INVALID_SET_FILE_POINTER: t.CDefine = -1
+SHARE_READ: t.CDefine = 0x00000001
+SHARE_WRITE: t.CDefine = 0x00000002
+SHARE_DELETE: t.CDefine = 0x00000004
+
+class File:
+    handle: w32.win32base.HANDLE
+    closed: bool
+    can_read: bool
+    can_write: bool
+    is_append: bool
+    _share_mode: ULONG
+    def __init__(self: File, filename: str, mode: ULONG, share: ULONG) -> t.CInt: pass
+    def __enter__(self: File) -> 'File' | t.CPtr: pass
+    def __exit__(self: File) -> t.CInt: pass
+    def read(self: File, buf: bytes, count: ULONG) -> LONG: pass
+    def write(self: File, buf: bytes, count: ULONG) -> LONG: pass
+    def write_str(self: File, s: str) -> LONG: pass
+    def seek(self: File, offset: LONG, origin: ULONG) -> LONG: pass
+    def tell(self: File) -> LONG: pass
+    def close(self: File) -> LONG: pass
+    def flush(self: File) -> LONG: pass
+    def size(self: File) -> LONGLONG: pass
+    def readline(self: File, buf: bytes, max_count: ULONG) -> LONG: pass
+    def read_all(self: File, buf: bytes, max_count: ULONG) -> LONG: pass
+class FileW:
+    handle: HANDLE
+    closed: bool
+    can_read: bool
+    can_write: bool
+    is_append: bool
+    _share_mode: ULONG
+    def __init__(self: FileW, filename: LPCWSTR, mode: ULONG, share: ULONG) -> t.CInt: pass
+    def __enter__(self: FileW) -> 'FileW' | t.CPtr: pass
+    def __exit__(self: FileW) -> t.CInt: pass
+    def read(self: FileW, buf: bytes, count: ULONG) -> LONG: pass
+    def write(self: FileW, buf: bytes, count: ULONG) -> LONG: pass
+    def write_str(self: FileW, s: str) -> LONG: pass
+    def seek(self: FileW, offset: LONG, origin: ULONG) -> LONG: pass
+    def tell(self: FileW) -> LONG: pass
+    def close(self: FileW) -> LONG: pass
+    def flush(self: FileW) -> LONG: pass
+    def size(self: FileW) -> LONGLONG: pass
+    def readline(self: FileW, buf: bytes, max_count: ULONG) -> LONG: pass
+    def read_all(self: FileW, buf: bytes, max_count: ULONG) -> LONG: pass
+
+def open(filename: str, mode: ULONG, share: ULONG) -> File | t.CPtr: pass
+
+def openw(filename: LPCWSTR, mode: ULONG, share: ULONG) -> FileW | t.CPtr: pass

Test/TestProject2/temp/faec3233d98371da.pyi

@@ -1,54 +0,0 @@
-"""
-Auto-generated Python stub file from zc.logic_test.py
-Module: zc.logic_test
-"""
-
-
-import config
-import t, c
-
-def ForRangeBasicTest(stop: t.CInt) -> t.CInt: pass
-
-def ForRangeWithStartStop(start: t.CInt, stop: t.CInt, step: t.CInt) -> t.CInt: pass
-
-def NestedForRangeTest(rows: t.CInt, cols: t.CInt) -> t.CInt: pass
-
-def ForWithIfBreakTest(data_size: t.CInt) -> t.CInt: pass
-
-def ForWithIfContinueTest(n: t.CInt) -> t.CInt: pass
-
-def ForWithElifBranchTest(value: t.CInt) -> t.CInt: pass
-
-def WhileWithIfElifElseTest(iterations: t.CInt) -> t.CInt: pass
-
-def WhileWithNestedIfTest(limit: t.CInt) -> t.CInt: pass
-
-def WhileWithMatchCaseTest(value: t.CInt) -> t.CInt: pass
-
-def WhileWithMatchCaseNoBreakTest(value: t.CInt) -> t.CInt: pass
-
-def ComplexForWhileMatchTest(outer_limit: t.CInt, inner_limit: t.CInt) -> t.CInt: pass
-
-def ForWithCaseAndNoBreakTest(n: t.CInt) -> t.CInt: pass
-
-def WhileWithBreakConditionTest(limit: t.CInt) -> t.CInt: pass
-
-def NestedWhileWithMultipleBreakPoints(depth: t.CInt, width: t.CInt) -> t.CInt: pass
-
-def ForWithMatchCaseInLoopTest(iterations: t.CInt) -> t.CInt: pass
-
-def ComplexLogicWithElifChains(a: t.CInt, b: t.CInt, c_val: t.CInt) -> t.CInt: pass
-
-def ForRangeWithStepAndCondition(n: t.CInt, step: t.CInt) -> t.CInt: pass
-
-def MatchCaseWithGuardConditions(value: t.CInt) -> t.CInt: pass
-
-def WhileWithMultipleMatchCases(iterations: t.CInt) -> t.CInt: pass
-
-def ForWhileMixWithBreakAndContinue(n: t.CInt) -> t.CInt: pass
-
-def ComplexCaseMatchingWithRanges(start: t.CInt, end: t.CInt) -> t.CInt: pass
-
-def WhileWithElifInElifChain(limit: t.CInt) -> t.CInt: pass
-
-def ForWithCaseNoBreakNested(inner_limit: t.CInt) -> t.CInt: pass