GVSDS/TransPyC
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

snapshot before regression test

Browse Source
This commit is contained in:
t
2026-07-18 19:25:40 +08:00
commit 796222a300
2295 changed files with 206453 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1705
Test/NewAstTest/App/main.py Normal file
View File

File diff suppressed because it is too large Load Diff

1
Test/NewAstTest/output/4175f14c5fbef360.deps.json Normal file
View File

@@ -0,0 +1 @@
{"ast.lexer": "0c212981c180e7fb", "lexer": "0c212981c180e7fb", "atom": "271ea3decb810db2", "ast.__init__": "34548789d646f432", "__init__": "34548789d646f432", "ast": "34548789d646f432", "ast.astaux": "4337fb260448bbe2", "astaux": "4337fb260448bbe2", "ast.exprs": "47767b5026a8ee15", "exprs": "47767b5026a8ee15", "ast.match": "4dd6b3f1427d1cc5", "match": "4dd6b3f1427d1cc5", "ast.base": "5dab8cb390496d22", "base": "5dab8cb390496d22", "ast.stmts": "657e182b27c2a022", "stmts": "657e182b27c2a022", "stdio": "6f62fe05c5ea1ceb", "stdarg": "71e0a3ffcb3ebfad", "stdlib": "90c53dd6db8d41cf", "string": "ab6e54ba9a669f76", "ast.tokens": "b547ac4f380bddb6", "tokens": "b547ac4f380bddb6", "viperlib": "c3b259b4059f8668", "viperio": "c9f4be41ca1cc2b4", "memhub": "ee084e9fc6ee413a", "ast.parser": "ee52c08239684346", "parser": "ee52c08239684346", "_list": "f2ecbf8ced20575c", "stdint": "f5522571bcce7bcb", "main.tokens": "b547ac4f380bddb6", "main.base": "5dab8cb390496d22", "main.exprs": "47767b5026a8ee15", "main.stmts": "657e182b27c2a022", "main.astaux": "4337fb260448bbe2", "main.match": "4dd6b3f1427d1cc5", "main.lexer": "0c212981c180e7fb"}

29
Test/NewAstTest/project.json Normal file
View File

@@ -0,0 +1,29 @@
{
"$schema": "https://raw.githubusercontent.com/TermiNexus/TransPyC/main/schemas/project-schema.json",
"name": "NewAstTest",
"version": "1.0.0",
"source_dir": "./App",
"temp_dir": "./temp",
"output_dir": "./output",
"compiler": {
"cmd": "llc",
"flags": ["-filetype=obj", "-relocation-model=pic"]
},
"linker": {
"cmd": "clang++",
"flags": ["-lmsvcrt", "-lucrt", "-lpthread", "-lmingwex", "-lkernel32", "-Wl,--allow-multiple-definition"],
"output": "NewAstTest.exe"
},
"includes": [
"../../includes"
],
"target": {
"triple": "x86_64-pc-windows-gnu",
"datalayout": "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
},
"options": {
"slice_level": 3,
"target": "llvm",
"strict_mode": true
}
}

67
Test/NewAstTest/temp/0c212981c180e7fb.pyi Normal file
View File

@@ -0,0 +1,67 @@
"""
Auto-generated Python stub file from ast.lexer.py
Module: ast.lexer
"""
import t, c
from stdint import *
import memhub
import string
from .tokens import Token, TokenType, TokOp, _init_tables, _kw_lookup, _op_head, OpEntry, new_token, token_set_str, token_set_str_literal
LEXER_MAX_INDENT: t.CDefine = 256
class Lexer:
src: str
pos: t.CSizeT
len: t.CSizeT
lineno: t.CInt
col: t.CInt
pool: memhub.MemManager | t.CPtr
indent_stack: t.CInt | t.CPtr
indent_top: t.CInt
paren_depth: t.CInt
tokens_head: Token | t.CPtr
tokens_tail: Token | t.CPtr
at_line_start: t.CInt
error_count: t.CInt
def __new__(self: Lexer, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
def new_lexer(pool: memhub.MemManager | t.CPtr) -> Lexer | t.CPtr: pass
def _lexer_init(lx: Lexer | t.CPtr, src: str, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
def _peek(lx: Lexer | t.CPtr, offset: t.CSizeT) -> t.CChar: pass
def _peek_cur(lx: Lexer | t.CPtr) -> t.CChar: pass
def _advance(lx: Lexer | t.CPtr) -> t.CChar: pass
def _is_alpha(ch: t.CChar) -> t.CInt: pass
def _is_digit(ch: t.CChar) -> t.CInt: pass
def _is_alnum(ch: t.CChar) -> t.CInt: pass
def _is_hex(ch: t.CChar) -> t.CInt: pass
def _is_space(ch: t.CChar) -> t.CInt: pass
def _emit(lx: Lexer | t.CPtr, tok: Token | t.CPtr) -> t.CInt: pass
def _make_op_token(lx: Lexer | t.CPtr, op_id: t.CInt, length: t.CInt, lineno: t.CInt, col: t.CInt) -> Token | t.CPtr: pass
def _handle_indent(lx: Lexer | t.CPtr) -> t.CInt: pass
def _read_name(lx: Lexer | t.CPtr) -> t.CInt: pass
def _read_number(lx: Lexer | t.CPtr) -> t.CInt: pass
def _emit_number(lx: Lexer | t.CPtr, start: t.CSizeT, start_lineno: t.CInt, start_col: t.CInt, is_float: t.CInt, is_complex: t.CInt, is_hex: t.CInt) -> t.CInt: pass
def _read_string(lx: Lexer | t.CPtr) -> t.CInt: pass
def _read_operator(lx: Lexer | t.CPtr) -> t.CInt: pass
def tokenize(lx: Lexer | t.CPtr) -> Token | t.CPtr: pass

26
Test/NewAstTest/temp/271ea3decb810db2.pyi Normal file
View File

@@ -0,0 +1,26 @@
"""
Auto-generated Python stub file from atom.py
Module: atom
"""
import t, c
ATOMIC_RELAXED: t.CDefine = 0
ATOMIC_CONSUME: t.CDefine = 1
ATOMIC_ACQUIRE: t.CDefine = 2
ATOMIC_RELEASE: t.CDefine = 3
ATOMIC_ACQ_REL: t.CDefine = 4
ATOMIC_SEQ_CST: t.CDefine = 5
def __atomic_test_and_set(ptr: t.CUInt64T | t.CPtr, order: t.CInt) -> t.CBool: pass
def __atomic_clear(ptr: t.CUInt64T | t.CPtr, order: t.CInt) -> t.CVoid: pass
def __atomic_thread_fence(order: t.CInt) -> t.CVoid: pass
def __atomic_signal_fence(order: t.CInt) -> t.CVoid: pass
def __atomic_always_lock_free(size: t.CSizeT, ptr: t.CVoid | t.CPtr) -> t.CBool: pass
def __atomic_is_lock_free(size: t.CSizeT, ptr: t.CVoid | t.CPtr) -> t.CBool: pass

26
Test/NewAstTest/temp/34548789d646f432.pyi Normal file
View File

@@ -0,0 +1,26 @@
"""
Auto-generated Python stub file from ast.__init__.py
Module: ast.__init__
"""
import t, c
from stdint import *
import memhub
import string
from .tokens import Token, TokenType, Keyword, TokOp, _init_tables
from .base import AST, ASTKind, ASTCtx, OpKind, ASTFlag, CONST_INT, CONST_FLOAT, CONST_STR, CONST_BOOL, CONST_NONE, FLAG_IS_ASYNC, FLAG_SIMPLE, FLAG_HAS_STAR, _init_ast, _copy_str, _set_pos, _inherit_pos, _set_parent_list, _binop_from_op, _augop_from_op, _cmpop_from_op, _emit, _emit_str, _emit_int, _dump_list, dump
from .stmts import Module, Expression, Interactive, FunctionType, FunctionDef, ClassDef, Return, Delete, Assign, AugAssign, AnnAssign, For, While, If, With, Raise, Try, Assert, Global, Nonlocal, Pass, Break, Continue, Expr, Import, ImportFrom, Match
from .exprs import BoolOp, BinOp, UnaryOp, Lambda, IfExp, Dict, Set, ListComp, SetComp, DictComp, GeneratorExp, Await, Yield, YieldFrom, FormattedValue, JoinedStr, Constant, NamedExpr, Attribute, Subscript, Starred, Name, List, Tuple, Slice, Call, Compare, OpNode
from .astaux import ExceptHandler, Arguments, Arg, Keyword, Alias, WithItem, Comprehension
from .match import MatchCase, MatchValue, MatchSingleton, MatchSequence, MatchMapping, MatchClass, MatchStar, MatchAs, MatchOr
from .visitor import ASTVisitor
from .lexer import Lexer, _lexer_init, tokenize, new_lexer
from .parser import Parser, _parser_init, parse_tokens, new_parser
from .parser import _parse_test
_mbuddy: t.CExtern | memhub.MemBuddy | t.CPtr
def parse(src: str, pool: memhub.MemManager | t.CPtr) -> AST | t.CPtr: pass
def parse_expression(src: str, pool: memhub.MemManager | t.CPtr) -> AST | t.CPtr: pass

1
Test/NewAstTest/temp/4175f14c5fbef360.doc.json Normal file
View File

@@ -0,0 +1 @@
{}

17
Test/NewAstTest/temp/4175f14c5fbef360.pyi Normal file
View File

@@ -0,0 +1,17 @@
"""
Auto-generated Python stub file from main.py
Module: main
"""
import t, c
from t import CInt, CExport, CPtr
from stdio import printf
import memhub
import stdlib
import string
from ast import AST, ASTKind, Module, FunctionDef, Assign, If, For, While, With, Return, Expr, Name, Constant, BinOp, UnaryOp, Call, Compare, Import, ImportFrom, Expression, CONST_INT, CONST_STR, CONST_BOOL, CONST_NONE, OpKind, ASTCtx, FLAG_IS_ASYNC, parse, parse_expression, dump
ARENA_SIZE: t.CExtern | CInt
def main() -> CInt | CExport: pass

73
Test/NewAstTest/temp/4337fb260448bbe2.pyi Normal file
View File

@@ -0,0 +1,73 @@
"""
Auto-generated Python stub file from ast.astaux.py
Module: ast.astaux
"""
import t, c
from stdint import *
import memhub
import string
from .base import AST, ASTKind, _init_ast, _copy_str, _set_parent_list, _emit, _emit_str, _emit_int, _dump_list
class ExceptHandler(AST):
type: AST | t.CPtr
name: str
def __new__(self: ExceptHandler, pool: memhub.MemManager | t.CPtr, type: AST | t.CPtr, name: str) -> t.CInt: pass
def __init__(self: ExceptHandler, pool: memhub.MemManager | t.CPtr, type: AST | t.CPtr, name: str) -> t.CInt: pass
def kind(self: ExceptHandler) -> t.CInt: pass
def type_name(self: ExceptHandler) -> str: pass
def dump(self: ExceptHandler, buf: bytes, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Arguments(AST):
args: list[AST | t.CPtr] | t.CPtr
vararg: AST | t.CPtr
kwarg: AST | t.CPtr
defaults: list[AST | t.CPtr] | t.CPtr
kw_defaults: list[AST | t.CPtr] | t.CPtr
def __new__(self: Arguments, pool: memhub.MemManager | t.CPtr, args: list[AST | t.CPtr] | t.CPtr, vararg: AST | t.CPtr, kwarg: AST | t.CPtr, defaults: list[AST | t.CPtr] | t.CPtr, kw_defaults: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def __init__(self: Arguments, pool: memhub.MemManager | t.CPtr, args: list[AST | t.CPtr] | t.CPtr, vararg: AST | t.CPtr, kwarg: AST | t.CPtr, defaults: list[AST | t.CPtr] | t.CPtr, kw_defaults: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def kind(self: Arguments) -> t.CInt: pass
def type_name(self: Arguments) -> str: pass
def dump(self: Arguments, buf: bytes, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Arg(AST):
arg: str
annotation: AST | t.CPtr
def __new__(self: Arg, pool: memhub.MemManager | t.CPtr, arg: str, annotation: AST | t.CPtr) -> t.CInt: pass
def __init__(self: Arg, pool: memhub.MemManager | t.CPtr, arg: str, annotation: AST | t.CPtr) -> t.CInt: pass
def kind(self: Arg) -> t.CInt: pass
def type_name(self: Arg) -> str: pass
def dump(self: Arg, buf: bytes, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Keyword(AST):
arg: str
value: AST | t.CPtr
def __new__(self: Keyword, pool: memhub.MemManager | t.CPtr, arg: str, value: AST | t.CPtr) -> t.CInt: pass
def __init__(self: Keyword, pool: memhub.MemManager | t.CPtr, arg: str, value: AST | t.CPtr) -> t.CInt: pass
def kind(self: Keyword) -> t.CInt: pass
def type_name(self: Keyword) -> str: pass
def dump(self: Keyword, buf: bytes, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Alias(AST):
name: str
asname: str
def __new__(self: Alias, pool: memhub.MemManager | t.CPtr, name: str, asname: str) -> t.CInt: pass
def __init__(self: Alias, pool: memhub.MemManager | t.CPtr, name: str, asname: str) -> t.CInt: pass
def kind(self: Alias) -> t.CInt: pass
def type_name(self: Alias) -> str: pass
def dump(self: Alias, buf: bytes, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class WithItem(AST):
context_expr: AST | t.CPtr
optional_vars: AST | t.CPtr
def __new__(self: WithItem, pool: memhub.MemManager | t.CPtr, context_expr: AST | t.CPtr, optional_vars: AST | t.CPtr) -> t.CInt: pass
def __init__(self: WithItem, pool: memhub.MemManager | t.CPtr, context_expr: AST | t.CPtr, optional_vars: AST | t.CPtr) -> t.CInt: pass
def kind(self: WithItem) -> t.CInt: pass
def type_name(self: WithItem) -> str: pass
def dump(self: WithItem, buf: bytes, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Comprehension(AST):
target: AST | t.CPtr
iter: AST | t.CPtr
ifs: list[AST | t.CPtr] | t.CPtr
is_async: t.CInt
def __new__(self: Comprehension, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, iter: AST | t.CPtr, ifs: list[AST | t.CPtr] | t.CPtr, is_async: t.CInt) -> t.CInt: pass
def __init__(self: Comprehension, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, iter: AST | t.CPtr, ifs: list[AST | t.CPtr] | t.CPtr, is_async: t.CInt) -> t.CInt: pass
def kind(self: Comprehension) -> t.CInt: pass
def type_name(self: Comprehension) -> str: pass
def dump(self: Comprehension, buf: bytes, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass

241
Test/NewAstTest/temp/47767b5026a8ee15.pyi Normal file
View File

@@ -0,0 +1,241 @@
"""
Auto-generated Python stub file from ast.exprs.py
Module: ast.exprs
"""
import t, c
from stdint import *
import memhub
import string
from .base import AST, ASTKind, ASTCtx, OpKind, _init_ast, _copy_str, _set_parent_list, _emit, _emit_str, _emit_int, _dump_list, _dump_op_list, _op_name, CONST_INT, CONST_FLOAT, CONST_STR, CONST_BOOL, CONST_NONE
class Name(AST):
id: str
ctx: t.CInt
def __new__(self: Name, pool: memhub.MemManager | t.CPtr, id: str, ctx: t.CInt) -> t.CInt: pass
def __init__(self: Name, pool: memhub.MemManager | t.CPtr, id: str, ctx: t.CInt) -> t.CInt: pass
def kind(self: Name) -> t.CInt: pass
def type_name(self: Name) -> str: pass
def dump(self: Name, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Constant(AST):
int_val: t.CInt64T
float_val: t.CDouble
str_val: str
const_kind: t.CInt
def __new__(self: Constant, pool: memhub.MemManager | t.CPtr, const_kind: t.CInt, int_val: t.CInt64T, float_val: t.CDouble, str_val: str, lineno: t.CInt, col: t.CInt) -> t.CInt: pass
def __init__(self: Constant, pool: memhub.MemManager | t.CPtr, const_kind: t.CInt, int_val: t.CInt64T, float_val: t.CDouble, str_val: str, lineno: t.CInt, col: t.CInt) -> t.CInt: pass
def kind(self: Constant) -> t.CInt: pass
def type_name(self: Constant) -> str: pass
def dump(self: Constant, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class BinOp(AST):
left: AST | t.CPtr
op: t.CInt
right: AST | t.CPtr
def __new__(self: BinOp, pool: memhub.MemManager | t.CPtr, left: AST | t.CPtr, op: t.CInt, right: AST | t.CPtr) -> t.CInt: pass
def __init__(self: BinOp, pool: memhub.MemManager | t.CPtr, left: AST | t.CPtr, op: t.CInt, right: AST | t.CPtr) -> t.CInt: pass
def kind(self: BinOp) -> t.CInt: pass
def type_name(self: BinOp) -> str: pass
def dump(self: BinOp, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class UnaryOp(AST):
op: t.CInt
operand: AST | t.CPtr
def __new__(self: UnaryOp, pool: memhub.MemManager | t.CPtr, op: t.CInt, operand: AST | t.CPtr) -> t.CInt: pass
def __init__(self: UnaryOp, pool: memhub.MemManager | t.CPtr, op: t.CInt, operand: AST | t.CPtr) -> t.CInt: pass
def kind(self: UnaryOp) -> t.CInt: pass
def type_name(self: UnaryOp) -> str: pass
def dump(self: UnaryOp, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Compare(AST):
left: AST | t.CPtr
ops: t.CPtr
comparators: list[AST | t.CPtr] | t.CPtr
def __new__(self: Compare, pool: memhub.MemManager | t.CPtr, left: AST | t.CPtr, ops: t.CPtr, comparators: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def __init__(self: Compare, pool: memhub.MemManager | t.CPtr, left: AST | t.CPtr, ops: t.CPtr, comparators: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def kind(self: Compare) -> t.CInt: pass
def type_name(self: Compare) -> str: pass
def dump(self: Compare, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Call(AST):
func: AST | t.CPtr
args: list[AST | t.CPtr] | t.CPtr
keywords: list[AST | t.CPtr] | t.CPtr
def __new__(self: Call, pool: memhub.MemManager | t.CPtr, func: AST | t.CPtr, args: list[AST | t.CPtr] | t.CPtr, keywords: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def __init__(self: Call, pool: memhub.MemManager | t.CPtr, func: AST | t.CPtr, args: list[AST | t.CPtr] | t.CPtr, keywords: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def kind(self: Call) -> t.CInt: pass
def type_name(self: Call) -> str: pass
def dump(self: Call, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class BoolOp(AST):
op: t.CInt
values: list[AST | t.CPtr] | t.CPtr
def __new__(self: BoolOp, pool: memhub.MemManager | t.CPtr, op: t.CInt, values: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def __init__(self: BoolOp, pool: memhub.MemManager | t.CPtr, op: t.CInt, values: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def kind(self: BoolOp) -> t.CInt: pass
def type_name(self: BoolOp) -> str: pass
def dump(self: BoolOp, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Lambda(AST):
args: AST | t.CPtr
body: AST | t.CPtr
def __new__(self: Lambda, pool: memhub.MemManager | t.CPtr, args: AST | t.CPtr, body: AST | t.CPtr) -> t.CInt: pass
def __init__(self: Lambda, pool: memhub.MemManager | t.CPtr, args: AST | t.CPtr, body: AST | t.CPtr) -> t.CInt: pass
def kind(self: Lambda) -> t.CInt: pass
def type_name(self: Lambda) -> str: pass
def dump(self: Lambda, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class IfExp(AST):
test: AST | t.CPtr
body: AST | t.CPtr
orelse: AST | t.CPtr
def __new__(self: IfExp, pool: memhub.MemManager | t.CPtr, test: AST | t.CPtr, body: AST | t.CPtr, orelse: AST | t.CPtr) -> t.CInt: pass
def __init__(self: IfExp, pool: memhub.MemManager | t.CPtr, test: AST | t.CPtr, body: AST | t.CPtr, orelse: AST | t.CPtr) -> t.CInt: pass
def kind(self: IfExp) -> t.CInt: pass
def type_name(self: IfExp) -> str: pass
def dump(self: IfExp, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Dict(AST):
keys: list[AST | t.CPtr] | t.CPtr
values: list[AST | t.CPtr] | t.CPtr
def __new__(self: Dict, pool: memhub.MemManager | t.CPtr, keys: list[AST | t.CPtr] | t.CPtr, values: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def __init__(self: Dict, pool: memhub.MemManager | t.CPtr, keys: list[AST | t.CPtr] | t.CPtr, values: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def kind(self: Dict) -> t.CInt: pass
def type_name(self: Dict) -> str: pass
def dump(self: Dict, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Set(AST):
elts: list[AST | t.CPtr] | t.CPtr
def __new__(self: Set, pool: memhub.MemManager | t.CPtr, elts: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def __init__(self: Set, pool: memhub.MemManager | t.CPtr, elts: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def kind(self: Set) -> t.CInt: pass
def type_name(self: Set) -> str: pass
def dump(self: Set, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class ListComp(AST):
elt: AST | t.CPtr
generators: list[AST | t.CPtr] | t.CPtr
def __new__(self: ListComp, pool: memhub.MemManager | t.CPtr, elt: AST | t.CPtr, generators: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def __init__(self: ListComp, pool: memhub.MemManager | t.CPtr, elt: AST | t.CPtr, generators: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def kind(self: ListComp) -> t.CInt: pass
def type_name(self: ListComp) -> str: pass
def dump(self: ListComp, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class SetComp(AST):
elt: AST | t.CPtr
generators: list[AST | t.CPtr] | t.CPtr
def __new__(self: SetComp, pool: memhub.MemManager | t.CPtr, elt: AST | t.CPtr, generators: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def __init__(self: SetComp, pool: memhub.MemManager | t.CPtr, elt: AST | t.CPtr, generators: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def kind(self: SetComp) -> t.CInt: pass
def type_name(self: SetComp) -> str: pass
def dump(self: SetComp, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class DictComp(AST):
key: AST | t.CPtr
value: AST | t.CPtr
generators: list[AST | t.CPtr] | t.CPtr
def __new__(self: DictComp, pool: memhub.MemManager | t.CPtr, key: AST | t.CPtr, value: AST | t.CPtr, generators: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def __init__(self: DictComp, pool: memhub.MemManager | t.CPtr, key: AST | t.CPtr, value: AST | t.CPtr, generators: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def kind(self: DictComp) -> t.CInt: pass
def type_name(self: DictComp) -> str: pass
def dump(self: DictComp, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class GeneratorExp(AST):
elt: AST | t.CPtr
generators: list[AST | t.CPtr] | t.CPtr
def __new__(self: GeneratorExp, pool: memhub.MemManager | t.CPtr, elt: AST | t.CPtr, generators: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def __init__(self: GeneratorExp, pool: memhub.MemManager | t.CPtr, elt: AST | t.CPtr, generators: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def kind(self: GeneratorExp) -> t.CInt: pass
def type_name(self: GeneratorExp) -> str: pass
def dump(self: GeneratorExp, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Await(AST):
value: AST | t.CPtr
def __new__(self: Await, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
def __init__(self: Await, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
def kind(self: Await) -> t.CInt: pass
def type_name(self: Await) -> str: pass
def dump(self: Await, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Yield(AST):
value: AST | t.CPtr
def __new__(self: Yield, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
def __init__(self: Yield, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
def kind(self: Yield) -> t.CInt: pass
def type_name(self: Yield) -> str: pass
def dump(self: Yield, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class YieldFrom(AST):
value: AST | t.CPtr
def __new__(self: YieldFrom, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
def __init__(self: YieldFrom, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
def kind(self: YieldFrom) -> t.CInt: pass
def type_name(self: YieldFrom) -> str: pass
def dump(self: YieldFrom, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class FormattedValue(AST):
value: AST | t.CPtr
conversion: t.CInt
format_spec: AST | t.CPtr
def __new__(self: FormattedValue, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr, conversion: t.CInt, format_spec: AST | t.CPtr) -> t.CInt: pass
def __init__(self: FormattedValue, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr, conversion: t.CInt, format_spec: AST | t.CPtr) -> t.CInt: pass
def kind(self: FormattedValue) -> t.CInt: pass
def type_name(self: FormattedValue) -> str: pass
def dump(self: FormattedValue, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class JoinedStr(AST):
values: list[AST | t.CPtr] | t.CPtr
def __new__(self: JoinedStr, pool: memhub.MemManager | t.CPtr, values: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def __init__(self: JoinedStr, pool: memhub.MemManager | t.CPtr, values: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def kind(self: JoinedStr) -> t.CInt: pass
def type_name(self: JoinedStr) -> str: pass
def dump(self: JoinedStr, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Attribute(AST):
value: AST | t.CPtr
attr: str
ctx: t.CInt
def __new__(self: Attribute, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr, attr: str, ctx: t.CInt) -> t.CInt: pass
def __init__(self: Attribute, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr, attr: str, ctx: t.CInt) -> t.CInt: pass
def kind(self: Attribute) -> t.CInt: pass
def type_name(self: Attribute) -> str: pass
def dump(self: Attribute, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Subscript(AST):
value: AST | t.CPtr
slice: AST | t.CPtr
ctx: t.CInt
def __new__(self: Subscript, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr, slice: AST | t.CPtr, ctx: t.CInt) -> t.CInt: pass
def __init__(self: Subscript, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr, slice: AST | t.CPtr, ctx: t.CInt) -> t.CInt: pass
def kind(self: Subscript) -> t.CInt: pass
def type_name(self: Subscript) -> str: pass
def dump(self: Subscript, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Starred(AST):
value: AST | t.CPtr
ctx: t.CInt
def __new__(self: Starred, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr, ctx: t.CInt) -> t.CInt: pass
def __init__(self: Starred, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr, ctx: t.CInt) -> t.CInt: pass
def kind(self: Starred) -> t.CInt: pass
def type_name(self: Starred) -> str: pass
def dump(self: Starred, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class List(AST):
elts: list[AST | t.CPtr] | t.CPtr
ctx: t.CInt
def __new__(self: List, pool: memhub.MemManager | t.CPtr, elts: list[AST | t.CPtr] | t.CPtr, ctx: t.CInt) -> t.CInt: pass
def __init__(self: List, pool: memhub.MemManager | t.CPtr, elts: list[AST | t.CPtr] | t.CPtr, ctx: t.CInt) -> t.CInt: pass
def kind(self: List) -> t.CInt: pass
def type_name(self: List) -> str: pass
def dump(self: List, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Tuple(AST):
elts: list[AST | t.CPtr] | t.CPtr
ctx: t.CInt
def __new__(self: Tuple, pool: memhub.MemManager | t.CPtr, elts: list[AST | t.CPtr] | t.CPtr, ctx: t.CInt) -> t.CInt: pass
def __init__(self: Tuple, pool: memhub.MemManager | t.CPtr, elts: list[AST | t.CPtr] | t.CPtr, ctx: t.CInt) -> t.CInt: pass
def kind(self: Tuple) -> t.CInt: pass
def type_name(self: Tuple) -> str: pass
def dump(self: Tuple, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Slice(AST):
lower: AST | t.CPtr
upper: AST | t.CPtr
step: AST | t.CPtr
def __new__(self: Slice, pool: memhub.MemManager | t.CPtr, lower: AST | t.CPtr, upper: AST | t.CPtr, step: AST | t.CPtr) -> t.CInt: pass
def __init__(self: Slice, pool: memhub.MemManager | t.CPtr, lower: AST | t.CPtr, upper: AST | t.CPtr, step: AST | t.CPtr) -> t.CInt: pass
def kind(self: Slice) -> t.CInt: pass
def type_name(self: Slice) -> str: pass
def dump(self: Slice, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class NamedExpr(AST):
target: AST | t.CPtr
value: AST | t.CPtr
def __new__(self: NamedExpr, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
def __init__(self: NamedExpr, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
def kind(self: NamedExpr) -> t.CInt: pass
def type_name(self: NamedExpr) -> str: pass
def dump(self: NamedExpr, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class OpNode(AST):
op: t.CInt
def __new__(self: OpNode, pool: memhub.MemManager | t.CPtr, op: t.CInt) -> t.CInt: pass
def __init__(self: OpNode, pool: memhub.MemManager | t.CPtr, op: t.CInt) -> t.CInt: pass
def kind(self: OpNode) -> t.CInt: pass
def type_name(self: OpNode) -> str: pass
def dump(self: OpNode, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass

82
Test/NewAstTest/temp/4dd6b3f1427d1cc5.pyi Normal file
View File

@@ -0,0 +1,82 @@
"""
Auto-generated Python stub file from ast.match.py
Module: ast.match
"""
import t, c
from stdint import *
import memhub
import string
from .base import AST, ASTKind, _init_ast, _copy_str, _set_parent_list, _emit, _emit_str, _emit_int, _dump_list
class MatchCase(AST):
pattern: AST | t.CPtr
guard: AST | t.CPtr
def __new__(self: MatchCase, pool: memhub.MemManager | t.CPtr, pattern: AST | t.CPtr, guard: AST | t.CPtr) -> t.CInt: pass
def __init__(self: MatchCase, pool: memhub.MemManager | t.CPtr, pattern: AST | t.CPtr, guard: AST | t.CPtr) -> t.CInt: pass
def kind(self: MatchCase) -> t.CInt: pass
def type_name(self: MatchCase) -> str: pass
def dump(self: MatchCase, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class MatchValue(AST):
value: AST | t.CPtr
def __new__(self: MatchValue, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
def __init__(self: MatchValue, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
def kind(self: MatchValue) -> t.CInt: pass
def type_name(self: MatchValue) -> str: pass
def dump(self: MatchValue, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class MatchSingleton(AST):
value: AST | t.CPtr
def __new__(self: MatchSingleton, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
def __init__(self: MatchSingleton, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
def kind(self: MatchSingleton) -> t.CInt: pass
def type_name(self: MatchSingleton) -> str: pass
def dump(self: MatchSingleton, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class MatchSequence(AST):
patterns: list[AST | t.CPtr] | t.CPtr
def __new__(self: MatchSequence, pool: memhub.MemManager | t.CPtr, patterns: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def __init__(self: MatchSequence, pool: memhub.MemManager | t.CPtr, patterns: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def kind(self: MatchSequence) -> t.CInt: pass
def type_name(self: MatchSequence) -> str: pass
def dump(self: MatchSequence, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class MatchMapping(AST):
keys: list[AST | t.CPtr] | t.CPtr
patterns: list[AST | t.CPtr] | t.CPtr
rest: str
def __new__(self: MatchMapping, pool: memhub.MemManager | t.CPtr, keys: list[AST | t.CPtr] | t.CPtr, patterns: list[AST | t.CPtr] | t.CPtr, rest: str) -> t.CInt: pass
def __init__(self: MatchMapping, pool: memhub.MemManager | t.CPtr, keys: list[AST | t.CPtr] | t.CPtr, patterns: list[AST | t.CPtr] | t.CPtr, rest: str) -> t.CInt: pass
def kind(self: MatchMapping) -> t.CInt: pass
def type_name(self: MatchMapping) -> str: pass
def dump(self: MatchMapping, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class MatchClass(AST):
cls: AST | t.CPtr
patterns: list[AST | t.CPtr] | t.CPtr
kwd_attrs: list[AST | t.CPtr] | t.CPtr
kwd_patterns: list[AST | t.CPtr] | t.CPtr
def __new__(self: MatchClass, pool: memhub.MemManager | t.CPtr, cls: AST | t.CPtr, patterns: list[AST | t.CPtr] | t.CPtr, kwd_attrs: list[AST | t.CPtr] | t.CPtr, kwd_patterns: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def __init__(self: MatchClass, pool: memhub.MemManager | t.CPtr, cls: AST | t.CPtr, patterns: list[AST | t.CPtr] | t.CPtr, kwd_attrs: list[AST | t.CPtr] | t.CPtr, kwd_patterns: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def kind(self: MatchClass) -> t.CInt: pass
def type_name(self: MatchClass) -> str: pass
def dump(self: MatchClass, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class MatchStar(AST):
name: str
def __new__(self: MatchStar, pool: memhub.MemManager | t.CPtr, name: str) -> t.CInt: pass
def __init__(self: MatchStar, pool: memhub.MemManager | t.CPtr, name: str) -> t.CInt: pass
def kind(self: MatchStar) -> t.CInt: pass
def type_name(self: MatchStar) -> str: pass
def dump(self: MatchStar, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class MatchAs(AST):
pattern: AST | t.CPtr
name: str
def __new__(self: MatchAs, pool: memhub.MemManager | t.CPtr, pattern: AST | t.CPtr, name: str) -> t.CInt: pass
def __init__(self: MatchAs, pool: memhub.MemManager | t.CPtr, pattern: AST | t.CPtr, name: str) -> t.CInt: pass
def kind(self: MatchAs) -> t.CInt: pass
def type_name(self: MatchAs) -> str: pass
def dump(self: MatchAs, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class MatchOr(AST):
patterns: list[AST | t.CPtr] | t.CPtr
def __new__(self: MatchOr, pool: memhub.MemManager | t.CPtr, patterns: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def __init__(self: MatchOr, pool: memhub.MemManager | t.CPtr, patterns: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def kind(self: MatchOr) -> t.CInt: pass
def type_name(self: MatchOr) -> str: pass
def dump(self: MatchOr, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass

182
Test/NewAstTest/temp/5dab8cb390496d22.pyi Normal file
View File

@@ -0,0 +1,182 @@
"""
Auto-generated Python stub file from ast.base.py
Module: ast.base
"""
import t, c
from stdint import *
import memhub
import string
import viperlib
from .tokens import TokOp
class ASTKind(t.CEnum):
Module: t.State
FunctionDef: t.State
ClassDef: t.State
Assign: t.State
If: t.State
For: t.State
While: t.State
Return: t.State
Expr: t.State
Name: t.State
Constant: t.State
BinOp: t.State
UnaryOp: t.State
Call: t.State
Compare: t.State
Expression: t.State
Interactive: t.State
FunctionType: t.State
Delete: t.State
AugAssign: t.State
AnnAssign: t.State
With: t.State
Raise: t.State
Try: t.State
Assert: t.State
Global: t.State
Nonlocal: t.State
Pass: t.State
Break: t.State
Continue: t.State
Import: t.State
ImportFrom: t.State
Match: t.State
BoolOp: t.State
Lambda: t.State
IfExp: t.State
Dict: t.State
Set: t.State
ListComp: t.State
SetComp: t.State
DictComp: t.State
GeneratorExp: t.State
Await: t.State
Yield: t.State
YieldFrom: t.State
FormattedValue: t.State
JoinedStr: t.State
Attribute: t.State
Subscript: t.State
Starred: t.State
List: t.State
Tuple: t.State
Slice: t.State
NamedExpr: t.State
ExceptHandler: t.State
Arguments: t.State
Arg: t.State
Keyword: t.State
Alias: t.State
WithItem: t.State
Comprehension: t.State
OpNode: t.State
MatchCase: t.State
MatchValue: t.State
MatchSingleton: t.State
MatchSequence: t.State
MatchMapping: t.State
MatchClass: t.State
MatchStar: t.State
MatchAs: t.State
MatchOr: t.State
class ASTCtx(t.CEnum):
Load: t.State
Store: t.State
Del: t.State
class OpKind(t.CEnum):
Add: t.State
Sub: t.State
Mult: t.State
MatMult: t.State
Div: t.State
Mod: t.State
Pow: t.State
LShift: t.State
RShift: t.State
BitOr: t.State
BitXor: t.State
BitAnd: t.State
FloorDiv: t.State
And: t.State
Or: t.State
Eq: t.State
Ne: t.State
Lt: t.State
Le: t.State
Gt: t.State
Ge: t.State
Is: t.State
IsNot: t.State
In: t.State
NotIn: t.State
Not: t.State
UAdd: t.State
USub: t.State
Invert: t.State
NoneOp: t.State
CONST_INT: t.CDefine = 1
CONST_FLOAT: t.CDefine = 2
CONST_STR: t.CDefine = 3
CONST_BOOL: t.CDefine = 4
CONST_NONE: t.CDefine = 5
FLAG_IS_ASYNC: t.CDefine = 1
FLAG_SIMPLE: t.CDefine = 2
FLAG_HAS_STAR: t.CDefine = 4
class ASTFlag(t.CEnum):
IsAsync: t.State
Simple: t.State
HasStar: t.State
def _copy_str(pool: memhub.MemManager | t.CPtr, src: str) -> str: pass
def _set_pos(node: AST | t.CPtr, lineno: t.CInt, col_offset: t.CInt, end_lineno: t.CInt, end_col_offset: t.CInt) -> t.CInt: pass
def _inherit_pos(node: AST | t.CPtr, ref: AST | t.CPtr) -> t.CInt: pass
def _init_ast(node: AST | t.CPtr, pool: memhub.MemManager | t.CPtr, lineno: t.CInt, col: t.CInt) -> t.CInt: pass
def _set_parent_list(lst: list[AST | t.CPtr] | t.CPtr, parent: AST | t.CPtr) -> t.CInt: pass
def _append_child(lst: list[AST | t.CPtr] | t.CPtr, node: AST | t.CPtr, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
def _binop_from_op(op_id: t.CInt) -> t.CInt: pass
def _augop_from_op(op_id: t.CInt) -> t.CInt: pass
def _cmpop_from_op(op_id: t.CInt) -> t.CInt: pass
def _emit(buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT, text: str) -> t.CSizeT: pass
def _emit_str(buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT, text: str) -> t.CSizeT: pass
def _emit_int(buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT, val: t.CInt64T) -> t.CSizeT: pass
def _op_name(op: t.CInt) -> str: pass
def _dump_list(lst: list[AST | t.CPtr] | t.CPtr, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
def _dump_op_list(lst: t.CPtr, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
@t.CVTable
class AST:
parent: AST | t.CPtr
pool: memhub.MemManager | t.CPtr
lineno: t.CInt
col_offset: t.CInt
end_lineno: t.CInt
end_col_offset: t.CInt
children: list[AST | t.CPtr] | t.CPtr
def kind(self: AST) -> t.CInt: pass
def type_name(self: AST) -> str: pass
def dump(self: AST, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
def accept(self: AST, visitor: t.CPtr) -> t.CInt: pass
def append(self: AST, node: AST | t.CPtr) -> t.CInt: pass
def dump(node: AST | t.CPtr, buf: t.CChar | t.CPtr, size: t.CSizeT) -> t.CInt: pass

226
Test/NewAstTest/temp/657e182b27c2a022.pyi Normal file
View File

@@ -0,0 +1,226 @@
"""
Auto-generated Python stub file from ast.stmts.py
Module: ast.stmts
"""
import t, c
from stdint import *
import memhub
import string
from .base import AST, ASTKind, ASTCtx, OpKind, _init_ast, _copy_str, _set_parent_list, _emit, _emit_str, _emit_int, _dump_list, FLAG_IS_ASYNC
@t.CVTable
class Module(AST):
def __new__(self: Module, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
def __init__(self: Module, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
def kind(self: Module) -> t.CInt: pass
def type_name(self: Module) -> str: pass
def dump(self: Module, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Assign(AST):
targets: list[AST | t.CPtr] | t.CPtr
value: AST | t.CPtr
def __new__(self: Assign, pool: memhub.MemManager | t.CPtr, targets: list[AST | t.CPtr] | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
def __init__(self: Assign, pool: memhub.MemManager | t.CPtr, targets: list[AST | t.CPtr] | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
def kind(self: Assign) -> t.CInt: pass
def type_name(self: Assign) -> str: pass
def dump(self: Assign, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class If(AST):
test: AST | t.CPtr
orelse: list[AST | t.CPtr] | t.CPtr
def __new__(self: If, pool: memhub.MemManager | t.CPtr, test: AST | t.CPtr, orelse: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def __init__(self: If, pool: memhub.MemManager | t.CPtr, test: AST | t.CPtr, orelse: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def kind(self: If) -> t.CInt: pass
def type_name(self: If) -> str: pass
def dump(self: If, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class For(AST):
target: AST | t.CPtr
iter: AST | t.CPtr
orelse: list[AST | t.CPtr] | t.CPtr
flags: t.CInt
def __new__(self: For, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, iter: AST | t.CPtr, orelse: list[AST | t.CPtr] | t.CPtr, is_async: t.CInt) -> t.CInt: pass
def __init__(self: For, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, iter: AST | t.CPtr, orelse: list[AST | t.CPtr] | t.CPtr, is_async: t.CInt) -> t.CInt: pass
def kind(self: For) -> t.CInt: pass
def type_name(self: For) -> str: pass
def dump(self: For, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class While(AST):
test: AST | t.CPtr
orelse: list[AST | t.CPtr] | t.CPtr
def __new__(self: While, pool: memhub.MemManager | t.CPtr, test: AST | t.CPtr, orelse: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def __init__(self: While, pool: memhub.MemManager | t.CPtr, test: AST | t.CPtr, orelse: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def kind(self: While) -> t.CInt: pass
def type_name(self: While) -> str: pass
def dump(self: While, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Return(AST):
value: AST | t.CPtr
def __new__(self: Return, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
def __init__(self: Return, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
def kind(self: Return) -> t.CInt: pass
def type_name(self: Return) -> str: pass
def dump(self: Return, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Expr(AST):
value: AST | t.CPtr
def __new__(self: Expr, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
def __init__(self: Expr, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
def kind(self: Expr) -> t.CInt: pass
def type_name(self: Expr) -> str: pass
def dump(self: Expr, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class FunctionDef(AST):
name: str
args: AST | t.CPtr
decorator_list: list[AST | t.CPtr] | t.CPtr
returns: AST | t.CPtr
flags: t.CInt
def __new__(self: FunctionDef, pool: memhub.MemManager | t.CPtr, name: str, args: AST | t.CPtr, decorator_list: list[AST | t.CPtr] | t.CPtr, returns: AST | t.CPtr, is_async: t.CInt) -> t.CInt: pass
def __init__(self: FunctionDef, pool: memhub.MemManager | t.CPtr, name: str, args: AST | t.CPtr, decorator_list: list[AST | t.CPtr] | t.CPtr, returns: AST | t.CPtr, is_async: t.CInt) -> t.CInt: pass
def kind(self: FunctionDef) -> t.CInt: pass
def type_name(self: FunctionDef) -> str: pass
def dump(self: FunctionDef, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Expression(AST):
body: AST | t.CPtr
def __new__(self: Expression, pool: memhub.MemManager | t.CPtr, body: AST | t.CPtr) -> t.CInt: pass
def __init__(self: Expression, pool: memhub.MemManager | t.CPtr, body: AST | t.CPtr) -> t.CInt: pass
def kind(self: Expression) -> t.CInt: pass
def type_name(self: Expression) -> str: pass
def dump(self: Expression, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Interactive(AST):
body: AST | t.CPtr
def __new__(self: Interactive, pool: memhub.MemManager | t.CPtr, body: AST | t.CPtr) -> t.CInt: pass
def __init__(self: Interactive, pool: memhub.MemManager | t.CPtr, body: AST | t.CPtr) -> t.CInt: pass
def kind(self: Interactive) -> t.CInt: pass
def type_name(self: Interactive) -> str: pass
def dump(self: Interactive, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class FunctionType(AST):
argtypes: list[AST | t.CPtr] | t.CPtr
returns: AST | t.CPtr
def __new__(self: FunctionType, pool: memhub.MemManager | t.CPtr, argtypes: list[AST | t.CPtr] | t.CPtr, returns: AST | t.CPtr) -> t.CInt: pass
def __init__(self: FunctionType, pool: memhub.MemManager | t.CPtr, argtypes: list[AST | t.CPtr] | t.CPtr, returns: AST | t.CPtr) -> t.CInt: pass
def kind(self: FunctionType) -> t.CInt: pass
def type_name(self: FunctionType) -> str: pass
def dump(self: FunctionType, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class ClassDef(AST):
name: str
bases: list[AST | t.CPtr] | t.CPtr
keywords: list[AST | t.CPtr] | t.CPtr
decorator_list: list[AST | t.CPtr] | t.CPtr
type_params: list[str] | t.CPtr
def __new__(self: ClassDef, pool: memhub.MemManager | t.CPtr, name: str, bases: list[AST | t.CPtr] | t.CPtr, keywords: list[AST | t.CPtr] | t.CPtr, decorator_list: list[AST | t.CPtr] | t.CPtr, type_params: list[str] | t.CPtr) -> t.CInt: pass
def __init__(self: ClassDef, pool: memhub.MemManager | t.CPtr, name: str, bases: list[AST | t.CPtr] | t.CPtr, keywords: list[AST | t.CPtr] | t.CPtr, decorator_list: list[AST | t.CPtr] | t.CPtr, type_params: list[str] | t.CPtr) -> t.CInt: pass
def kind(self: ClassDef) -> t.CInt: pass
def type_name(self: ClassDef) -> str: pass
def dump(self: ClassDef, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Delete(AST):
targets: list[AST | t.CPtr] | t.CPtr
def __new__(self: Delete, pool: memhub.MemManager | t.CPtr, targets: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def __init__(self: Delete, pool: memhub.MemManager | t.CPtr, targets: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def kind(self: Delete) -> t.CInt: pass
def type_name(self: Delete) -> str: pass
def dump(self: Delete, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class AugAssign(AST):
target: AST | t.CPtr
op: t.CInt
value: AST | t.CPtr
def __new__(self: AugAssign, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, op: t.CInt, value: AST | t.CPtr) -> t.CInt: pass
def __init__(self: AugAssign, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, op: t.CInt, value: AST | t.CPtr) -> t.CInt: pass
def kind(self: AugAssign) -> t.CInt: pass
def type_name(self: AugAssign) -> str: pass
def dump(self: AugAssign, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class AnnAssign(AST):
target: AST | t.CPtr
annotation: AST | t.CPtr
value: AST | t.CPtr
simple: t.CInt
def __new__(self: AnnAssign, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, annotation: AST | t.CPtr, value: AST | t.CPtr, simple: t.CInt) -> t.CInt: pass
def __init__(self: AnnAssign, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, annotation: AST | t.CPtr, value: AST | t.CPtr, simple: t.CInt) -> t.CInt: pass
def kind(self: AnnAssign) -> t.CInt: pass
def type_name(self: AnnAssign) -> str: pass
def dump(self: AnnAssign, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class With(AST):
items: list[AST | t.CPtr] | t.CPtr
flags: t.CInt
def __new__(self: With, pool: memhub.MemManager | t.CPtr, items: list[AST | t.CPtr] | t.CPtr, is_async: t.CInt) -> t.CInt: pass
def __init__(self: With, pool: memhub.MemManager | t.CPtr, items: list[AST | t.CPtr] | t.CPtr, is_async: t.CInt) -> t.CInt: pass
def kind(self: With) -> t.CInt: pass
def type_name(self: With) -> str: pass
def dump(self: With, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Raise(AST):
exc: AST | t.CPtr
cause: AST | t.CPtr
def __new__(self: Raise, pool: memhub.MemManager | t.CPtr, exc: AST | t.CPtr, cause: AST | t.CPtr) -> t.CInt: pass
def __init__(self: Raise, pool: memhub.MemManager | t.CPtr, exc: AST | t.CPtr, cause: AST | t.CPtr) -> t.CInt: pass
def kind(self: Raise) -> t.CInt: pass
def type_name(self: Raise) -> str: pass
def dump(self: Raise, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Try(AST):
handlers: list[AST | t.CPtr] | t.CPtr
orelse: list[AST | t.CPtr] | t.CPtr
finalbody: list[AST | t.CPtr] | t.CPtr
def __new__(self: Try, pool: memhub.MemManager | t.CPtr, handlers: list[AST | t.CPtr] | t.CPtr, orelse: list[AST | t.CPtr] | t.CPtr, finalbody: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def __init__(self: Try, pool: memhub.MemManager | t.CPtr, handlers: list[AST | t.CPtr] | t.CPtr, orelse: list[AST | t.CPtr] | t.CPtr, finalbody: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def kind(self: Try) -> t.CInt: pass
def type_name(self: Try) -> str: pass
def dump(self: Try, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Assert(AST):
test: AST | t.CPtr
msg: AST | t.CPtr
def __new__(self: Assert, pool: memhub.MemManager | t.CPtr, test: AST | t.CPtr, msg: AST | t.CPtr) -> t.CInt: pass
def __init__(self: Assert, pool: memhub.MemManager | t.CPtr, test: AST | t.CPtr, msg: AST | t.CPtr) -> t.CInt: pass
def kind(self: Assert) -> t.CInt: pass
def type_name(self: Assert) -> str: pass
def dump(self: Assert, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Global(AST):
names: list[AST | t.CPtr] | t.CPtr
def __new__(self: Global, pool: memhub.MemManager | t.CPtr, names: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def __init__(self: Global, pool: memhub.MemManager | t.CPtr, names: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def kind(self: Global) -> t.CInt: pass
def type_name(self: Global) -> str: pass
def dump(self: Global, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Nonlocal(AST):
names: list[AST | t.CPtr] | t.CPtr
def __new__(self: Nonlocal, pool: memhub.MemManager | t.CPtr, names: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def __init__(self: Nonlocal, pool: memhub.MemManager | t.CPtr, names: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def kind(self: Nonlocal) -> t.CInt: pass
def type_name(self: Nonlocal) -> str: pass
def dump(self: Nonlocal, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Pass(AST):
def __new__(self: Pass, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
def __init__(self: Pass, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
def kind(self: Pass) -> t.CInt: pass
def type_name(self: Pass) -> str: pass
def dump(self: Pass, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Break(AST):
def __new__(self: Break, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
def __init__(self: Break, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
def kind(self: Break) -> t.CInt: pass
def type_name(self: Break) -> str: pass
def dump(self: Break, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Continue(AST):
def __new__(self: Continue, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
def __init__(self: Continue, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
def kind(self: Continue) -> t.CInt: pass
def type_name(self: Continue) -> str: pass
def dump(self: Continue, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Import(AST):
names: list[AST | t.CPtr] | t.CPtr
def __new__(self: Import, pool: memhub.MemManager | t.CPtr, names: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def __init__(self: Import, pool: memhub.MemManager | t.CPtr, names: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def kind(self: Import) -> t.CInt: pass
def type_name(self: Import) -> str: pass
def dump(self: Import, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class ImportFrom(AST):
module: str
names: list[AST | t.CPtr] | t.CPtr
level: t.CInt
def __new__(self: ImportFrom, pool: memhub.MemManager | t.CPtr, module: str, names: list[AST | t.CPtr] | t.CPtr, level: t.CInt) -> t.CInt: pass
def __init__(self: ImportFrom, pool: memhub.MemManager | t.CPtr, module: str, names: list[AST | t.CPtr] | t.CPtr, level: t.CInt) -> t.CInt: pass
def kind(self: ImportFrom) -> t.CInt: pass
def type_name(self: ImportFrom) -> str: pass
def dump(self: ImportFrom, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Match(AST):
subject: AST | t.CPtr
cases: list[AST | t.CPtr] | t.CPtr
def __new__(self: Match, pool: memhub.MemManager | t.CPtr, subject: AST | t.CPtr, cases: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def __init__(self: Match, pool: memhub.MemManager | t.CPtr, subject: AST | t.CPtr, cases: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
def kind(self: Match) -> t.CInt: pass
def type_name(self: Match) -> str: pass
def dump(self: Match, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass

28
Test/NewAstTest/temp/6f62fe05c5ea1ceb.pyi Normal file
View File

@@ -0,0 +1,28 @@
"""
Auto-generated Python stub file from stdio.py
Module: stdio
"""
import t, c
def printf(fmt: t.CConst | str, *args) -> t.CInt | t.State: pass
def fprintf(stream: bytes, fmt: t.CConst | str, *args) -> t.CInt | t.State: pass
def sprintf(buf: bytes, fmt: t.CConst | str, *args) -> t.CInt | t.State: pass
def snprintf(buf: bytes, size: t.CSizeT, fmt: t.CConst | str, *args) -> t.CInt | t.State: pass
def puts(s: t.CConst | str) -> t.CInt | t.State: pass
def fputs(s: t.CConst | str, stream: bytes) -> t.CInt | t.State: pass
def fgets(buf: bytes, size: t.CInt, stream: bytes) -> bytes | t.State: pass
def fflush(stream: bytes) -> t.CInt | t.State: pass
stdin: t.CExtern | bytes
stdout: t.CExtern | bytes
stderr: t.CExtern | bytes

20
Test/NewAstTest/temp/71e0a3ffcb3ebfad.pyi Normal file
View File

@@ -0,0 +1,20 @@
"""
Auto-generated Python stub file from stdarg.py
Module: stdarg
"""
import c
import t
def va_start(args: t.CPtr, last_arg: t.CPtr) -> t.State: pass
def va_arg(args: t.CPtr, type: t.CPtr) -> t.CPtr | t.State: pass
def va_end(args: t.CPtr) -> t.State | t.State: pass
va_list: t.CTypedef = t.CUnsignedChar | t.CPtr
def arg(type: t.CType) -> t.State: pass

20
Test/NewAstTest/temp/90c53dd6db8d41cf.pyi Normal file
View File

@@ -0,0 +1,20 @@
"""
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: pass
def calloc(nmemb: t.CSizeT, size: t.CSizeT) -> t.CVoid | t.CPtr | t.State: pass
def realloc(p: t.CVoid | t.CPtr, size: t.CSizeT) -> t.CVoid | t.CPtr | t.State: pass
def free(p: t.CVoid | t.CPtr) -> t.State: pass
def system(cmd: t.CConst | t.CChar | t.CPtr) -> INT | t.State: pass

1
Test/NewAstTest/temp/_phase1_manifest.json Normal file
View File

@@ -0,0 +1 @@
{"D:\\Users\\TermiNexus\\Desktop\\TransPyC\\Test\\NewAstTest\\App\\main.py": {"sha1": "4175f14c5fbef360", "mtime": 1783001020.789755, "size": 63423}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\_list.py": {"sha1": "f2ecbf8ced20575c", "mtime": 1784203829.5212443, "size": 3277}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\ast\\__init__.py": {"sha1": "34548789d646f432", "mtime": 1784102404.6307266, "size": 3409}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\ast\\astaux.py": {"sha1": "4337fb260448bbe2", "mtime": 1784006094.7981195, "size": 11489}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\ast\\base.py": {"sha1": "5dab8cb390496d22", "mtime": 1784197698.3282094, "size": 14966}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\ast\\exprs.py": {"sha1": "47767b5026a8ee15", "mtime": 1783239758.809719, "size": 40615}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\ast\\lexer.py": {"sha1": "0c212981c180e7fb", "mtime": 1783400609.908198, "size": 23535}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\ast\\match.py": {"sha1": "4dd6b3f1427d1cc5", "mtime": 1782961799.8492737, "size": 12309}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\ast\\parser.py": {"sha1": "ee52c08239684346", "mtime": 1784102405.1933146, "size": 85445}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\ast\\stmts.py": {"sha1": "657e182b27c2a022", "mtime": 1783929993.759902, "size": 37926}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\ast\\tokens.py": {"sha1": "b547ac4f380bddb6", "mtime": 1783165480.469121, "size": 13722}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\atom.py": {"sha1": "271ea3decb810db2", "mtime": 1782226548.693161, "size": 1290}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\memhub.py": {"sha1": "ee084e9fc6ee413a", "mtime": 1784214242.4485993, "size": 17765}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\stdarg.py": {"sha1": "71e0a3ffcb3ebfad", "mtime": 1781258888.113146, "size": 277}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\stdint.py": {"sha1": "f5522571bcce7bcb", "mtime": 1782383975.8824987, "size": 4356}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\stdio.py": {"sha1": "6f62fe05c5ea1ceb", "mtime": 1783239556.0959673, "size": 714}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\stdlib.py": {"sha1": "90c53dd6db8d41cf", "mtime": 1783874975.3597875, "size": 375}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\string.py": {"sha1": "ab6e54ba9a669f76", "mtime": 1783933178.7264287, "size": 9922}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\viperio.py": {"sha1": "c9f4be41ca1cc2b4", "mtime": 1782812279.506002, "size": 1556}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\viperlib.py": {"sha1": "c3b259b4059f8668", "mtime": 1782821991.979496, "size": 56772}}

20
Test/NewAstTest/temp/_sha1_map.txt Normal file
View File

@@ -0,0 +1,20 @@
0c212981c180e7fb:includes/ast\lexer.py
271ea3decb810db2:includes/atom.py
34548789d646f432:includes/ast\__init__.py
4175f14c5fbef360:main.py
4337fb260448bbe2:includes/ast\astaux.py
47767b5026a8ee15:includes/ast\exprs.py
4dd6b3f1427d1cc5:includes/ast\match.py
5dab8cb390496d22:includes/ast\base.py
657e182b27c2a022:includes/ast\stmts.py
6f62fe05c5ea1ceb:includes/stdio.py
71e0a3ffcb3ebfad:includes/stdarg.py
90c53dd6db8d41cf:includes/stdlib.py
ab6e54ba9a669f76:includes/string.py
b547ac4f380bddb6:includes/ast\tokens.py
c3b259b4059f8668:includes/viperlib.py
c9f4be41ca1cc2b4:includes/viperio.py
ee084e9fc6ee413a:includes/memhub.py
ee52c08239684346:includes/ast\parser.py
f2ecbf8ced20575c:includes/_list.py
f5522571bcce7bcb:includes/stdint.py

48
Test/NewAstTest/temp/ab6e54ba9a669f76.pyi Normal file
View File

@@ -0,0 +1,48 @@
"""
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 strcat(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 strstr(s: str, needle: str) -> 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

166
Test/NewAstTest/temp/b547ac4f380bddb6.pyi Normal file
View File

@@ -0,0 +1,166 @@
"""
Auto-generated Python stub file from ast.tokens.py
Module: ast.tokens
"""
import t, c
from stdint import *
import memhub
import string
class TokenType(t.CEnum):
EndMarker: t.State
NewLine: t.State
Indent: t.State
Dedent: t.State
Name: t.State
Number: t.State
String: t.State
FStringStart: t.State
FStringMiddle: t.State
FStringEnd: t.State
Op: t.State
Nl: t.State
Comment: t.State
Encoding: t.State
class Keyword(t.CEnum):
NotKeyword: t.State
False_: t.State
None_: t.State
True_: t.State
And: t.State
As: t.State
Assert: t.State
Async: t.State
Await: t.State
Break: t.State
Class: t.State
Continue: t.State
Def: t.State
Del: t.State
Elif: t.State
Else: t.State
Except: t.State
Finally: t.State
For: t.State
From: t.State
Global: t.State
If: t.State
Import: t.State
In: t.State
Is: t.State
Lambda: t.State
Nonlocal: t.State
Not: t.State
Or: t.State
Pass: t.State
Raise: t.State
Return: t.State
Try: t.State
While: t.State
With: t.State
Yield: t.State
Match: t.State
Case: t.State
Type: t.State
class TokOp(t.CEnum):
LPar: t.State
RPar: t.State
Lsqb: t.State
Rsqb: t.State
LBrace: t.State
RBrace: t.State
Comma: t.State
Colon: t.State
Dot: t.State
Semi: t.State
At: t.State
Equal: t.State
RArrow: t.State
PlusEq: t.State
MinusEq: t.State
StarEq: t.State
SlashEq: t.State
DSlashEq: t.State
PercentEq: t.State
AtEq: t.State
AmpEq: t.State
VBarEq: t.State
CaretEq: t.State
GtGtEq: t.State
LtLtEq: t.State
StarEqEq: t.State
DSlash: t.State
StarStar: t.State
LtLt: t.State
GtGt: t.State
LessEq: t.State
GreaterEq: t.State
EqEq: t.State
ExclaimEq: t.State
Less: t.State
Greater: t.State
Plus: t.State
Minus: t.State
Star: t.State
Slash: t.State
Percent: t.State
Amp: t.State
VBar: t.State
Caret: t.State
Tilde: t.State
ColonEq: t.State
Ellipsis: t.State
Bang: t.State
class Token:
type: t.CInt
op_subtype: t.CInt
kw_subtype: t.CInt
str_val: str
int_val: t.CInt64T
float_val: t.CDouble
is_float: t.CInt
is_complex: t.CInt
lineno: t.CInt
col_offset: t.CInt
end_lineno: t.CInt
end_col_offset: t.CInt
next: Token | t.CPtr
def __new__(self: Token, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
class KwEntry:
name: str
kw_id: t.CInt
next: KwEntry | t.CPtr
def __new__(self: KwEntry, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
_kw_head: t.CExtern | KwEntry | t.CPtr
_kw_pool: t.CExtern | memhub.MemManager | t.CPtr
def _kw_intern(pool: memhub.MemManager | t.CPtr, name: str, kw_id: t.CInt) -> t.CInt: pass
def _kw_lookup(name: str) -> t.CInt: pass
def _init_keywords(pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
class OpEntry:
name: str
op_id: t.CInt
length: t.CInt
next: OpEntry | t.CPtr
def __new__(self: OpEntry, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
_op_head: t.CExtern | OpEntry | t.CPtr
def _op_intern(pool: memhub.MemManager | t.CPtr, name: str, op_id: t.CInt) -> t.CInt: pass
def _init_operators(pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
def _init_tables(pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
def new_token(pool: memhub.MemManager | t.CPtr, ttype: t.CInt, lineno: t.CInt, col_offset: t.CInt) -> Token | t.CPtr: pass
def token_set_str(pool: memhub.MemManager | t.CPtr, tok: Token | t.CPtr, src: str, start: t.CSizeT, length: t.CSizeT) -> t.CInt: pass
def token_set_str_literal(pool: memhub.MemManager | t.CPtr, tok: Token | t.CPtr, text: str) -> t.CInt: pass

23
Test/NewAstTest/temp/c3b259b4059f8668.pyi Normal file
View File

@@ -0,0 +1,23 @@
"""
Auto-generated Python stub file from viperlib.py
Module: viperlib
"""
import t, c
import viperio
from stdarg import arg, va_arg
TEMP_BUF_SIZE: t.CDefine = 68
def get_digit_count(num: t.CUnsignedInt, base: t.CInt) -> t.CStatic | t.CInt: pass
def sprintf(buf: t.CChar | t.CPtr, rule: str, *args) -> t.CVoid | t.CExport: pass
def vsprintf(buf: t.CChar | t.CPtr, rule: str, *args) -> t.CInt: pass
def snprintf(buf: t.CChar | t.CPtr, size: t.CSizeT, fmt: str, *args) -> t.CInt | t.CExport: pass
def _check_special_float(fv: t.CDouble) -> t.CInt: pass
def vsnprintf(buf: t.CChar | t.CPtr, size: t.CSizeT, fmt: str, ap: t.CChar | t.CPtr) -> t.CInt | t.CExport: pass

22
Test/NewAstTest/temp/c9f4be41ca1cc2b4.pyi Normal file
View File

@@ -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

81
Test/NewAstTest/temp/ee084e9fc6ee413a.pyi Normal file
View File

@@ -0,0 +1,81 @@
"""
Auto-generated Python stub file from memhub.py
Module: memhub
"""
import t, c
from stdint import *
import string
import atom
import viperio
MEMHUB_ALIGN: t.CDefine = 8
MEMSLAB_MIN_BLOCK: t.CDefine = 16
MEMSLAB_BITMAP_BYTES: t.CDefine = 256
MEMBUDDY_MIN_BLOCK: t.CDefine = 32
MEMBUDDY_MAX_ORDERS: t.CDefine = 32
MEMBUDDY_HEADER_SIZE: t.CDefine = 8
def _align_up(val: t.CSizeT, align: t.CSizeT) -> t.CSizeT: pass
def _largest_pow2_le(val: t.CSizeT) -> t.CSizeT: pass
def _block_size_at_order(order: t.CInt) -> t.CSizeT: pass
@t.CVTable
class MemManager:
__provides__: list[str] = ['__memmgr__']
base: t.CVoid | t.CPtr
size: t.CSizeT
def __init__(self: MemManager, base: t.CVoid | t.CPtr, size: t.CSizeT) -> t.CInt: pass
def alloc(self: MemManager, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
def free(self: MemManager, ptr: t.CVoid | t.CPtr) -> t.CInt: pass
def reset(self: MemManager) -> t.CInt: pass
def calloc(self: MemManager, count: t.CSizeT, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
def realloc(self: MemManager, ptr: t.CVoid | t.CPtr, old_size: t.CSizeT, new_size: t.CSizeT) -> t.CVoid | t.CPtr: pass
def __enter__(self: MemManager) -> 'MemManager' | t.CPtr: pass
def __exit__(self: MemManager) -> t.CInt: pass
def alloc_buf(self: MemManager, capacity: t.CSizeT) -> viperio.Buf | t.CPtr: pass
class MemPool(MemManager):
offset: t.CSizeT
high_water: t.CSizeT
def __init__(self: MemPool, base: t.CVoid | t.CPtr, size: t.CSizeT) -> t.CInt: pass
def alloc(self: MemPool, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
def free(self: MemPool, ptr: t.CVoid | t.CPtr) -> t.CInt: pass
def reset(self: MemPool) -> t.CInt: pass
class MemSlab(MemManager):
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
usable: t.CVoid | t.CPtr
usable_size: t.CSizeT
def __init__(self: MemSlab, base: t.CVoid | t.CPtr, size: t.CSizeT, block_size: t.CSizeT) -> t.CInt: pass
def alloc(self: MemSlab, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
def free(self: MemSlab, ptr: t.CVoid | t.CPtr) -> t.CInt: pass
def reset(self: MemSlab) -> t.CInt: pass
class MemBuddy(MemManager):
max_order: t.CInt
free_lists: t.CUInt64T | t.CPtr
lock_val: t.CVolatile | t.CInt
usable: t.CVoid | t.CPtr
usable_size: t.CSizeT
def __init__(self: MemBuddy, base: t.CVoid | t.CPtr, size: t.CSizeT) -> t.CInt: pass
def _fl_push(self: MemBuddy, order: t.CInt, block: t.CVoid | t.CPtr) -> t.CInt: pass
def _fl_pop(self: MemBuddy, order: t.CInt) -> t.CVoid | t.CPtr: pass
def _fl_find_and_remove(self: MemBuddy, order: t.CInt, target: t.CVoid | t.CPtr) -> t.CInt: pass
def _buddy_of(self: MemBuddy, block: t.CVoid | t.CPtr, order: t.CInt) -> t.CVoid | t.CPtr: pass
def _order_for_size(self: MemBuddy, size: t.CSizeT) -> t.CInt: pass
def _split_to_order(self: MemBuddy, to_order: t.CInt) -> t.CVoid | t.CPtr: pass
def _coalesce(self: MemBuddy, block: t.CVoid | t.CPtr, order: t.CInt) -> t.CInt: pass
def _is_valid_ptr(self: MemBuddy, ptr: t.CVoid | t.CPtr) -> t.CInt: pass
def _lock(self: MemBuddy) -> t.CInt: pass
def _unlock(self: MemBuddy) -> t.CInt: pass
def alloc(self: MemBuddy, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
def free(self: MemBuddy, ptr: t.CVoid | t.CPtr) -> t.CInt: pass
def reset(self: MemBuddy) -> t.CInt: pass
def realloc(self: MemBuddy, ptr: t.CVoid | t.CPtr, old_size: t.CSizeT, new_size: t.CSizeT) -> t.CVoid | t.CPtr: pass

215
Test/NewAstTest/temp/ee52c08239684346.pyi Normal file
View File

@@ -0,0 +1,215 @@
"""
Auto-generated Python stub file from ast.parser.py
Module: ast.parser
"""
import t, c
from stdint import *
import memhub
import string
from .tokens import Token, TokenType, Keyword, TokOp
from .base import AST, ASTCtx, ASTKind, OpKind, ASTFlag, _set_pos, _binop_from_op, _augop_from_op, _cmpop_from_op, _copy_str, _inherit_pos, _init_ast, CONST_INT, CONST_FLOAT, CONST_STR, CONST_BOOL, CONST_NONE, FLAG_IS_ASYNC
from .exprs import BoolOp, BinOp, UnaryOp, Lambda, IfExp, Dict, Set, ListComp, SetComp, DictComp, GeneratorExp, Await, Yield, YieldFrom, FormattedValue, JoinedStr, Constant, NamedExpr, Attribute, Subscript, Starred, Name, List, Tuple, Slice, Call, Compare, OpNode
from .stmts import Module, Expression, Interactive, FunctionType, FunctionDef, ClassDef, Return, Delete, Assign, AugAssign, AnnAssign, For, While, If, With, Raise, Try, Assert, Global, Nonlocal, Pass, Break, Continue, Expr, Import, ImportFrom, Match
from .astaux import ExceptHandler, Arguments, Arg, Keyword as KwNode, Alias, WithItem, Comprehension
from .match import MatchCase, MatchValue, MatchSingleton, MatchSequence, MatchMapping, MatchClass, MatchStar, MatchAs, MatchOr
from .lexer import Lexer, _lexer_init, tokenize, new_lexer
class Parser:
tokens: Token | t.CPtr
cur: Token | t.CPtr
pool: memhub.MemManager | t.CPtr
error_count: t.CInt
pending_decorators: list[AST | t.CPtr] | t.CPtr
def __new__(self: Parser, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
def new_parser(pool: memhub.MemManager | t.CPtr) -> Parser | t.CPtr: pass
def _parser_init(ps: Parser | t.CPtr, tokens: Token | t.CPtr, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
def _advance(ps: Parser | t.CPtr) -> t.CInt: pass
def _cur_type(ps: Parser | t.CPtr) -> t.CInt: pass
def _cur_op(ps: Parser | t.CPtr) -> t.CInt: pass
def _cur_kw(ps: Parser | t.CPtr) -> t.CInt: pass
def _cur_str(ps: Parser | t.CPtr) -> str: pass
def _cur_lineno(ps: Parser | t.CPtr) -> t.CInt: pass
def _cur_col(ps: Parser | t.CPtr) -> t.CInt: pass
def _skip_nl(ps: Parser | t.CPtr) -> t.CInt: pass
def _skip_nls_and_newlines(ps: Parser | t.CPtr) -> t.CInt: pass
def _expect_type(ps: Parser | t.CPtr, ttype: t.CInt) -> t.CInt: pass
def _expect_op(ps: Parser | t.CPtr, op_id: t.CInt) -> t.CInt: pass
def _match_op(ps: Parser | t.CPtr, op_id: t.CInt) -> t.CInt: pass
def _accept_op(ps: Parser | t.CPtr, op_id: t.CInt) -> t.CInt: pass
def _new_const_int(pool: memhub.MemManager | t.CPtr, val: t.CInt64T, lineno: t.CInt, col: t.CInt) -> AST | t.CPtr: pass
def _new_const_float(pool: memhub.MemManager | t.CPtr, val: t.CDouble, lineno: t.CInt, col: t.CInt) -> AST | t.CPtr: pass
def _new_const_str(pool: memhub.MemManager | t.CPtr, val: str, lineno: t.CInt, col: t.CInt) -> AST | t.CPtr: pass
def _new_const_bool(pool: memhub.MemManager | t.CPtr, val: t.CInt, lineno: t.CInt, col: t.CInt) -> AST | t.CPtr: pass
def _new_const_none(pool: memhub.MemManager | t.CPtr, lineno: t.CInt, col: t.CInt) -> AST | t.CPtr: pass
def _set_ctx(node: AST | t.CPtr, ctx: t.CInt) -> t.CInt: pass
def _fix_store_ctx(node: AST | t.CPtr) -> t.CInt: pass
def _parse_expr(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_namedexpr(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_test(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_lambda(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_or_test(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_and_test(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_not_test(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_comparison(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _match_comp_op(ps: Parser | t.CPtr) -> t.CInt: pass
def _advance_comp_op(ps: Parser | t.CPtr) -> t.CInt: pass
def _parse_bitor(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_bitxor(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_bitand(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_shift(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_arith(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_term(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_factor(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_power(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_atom_expr(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_call(ps: Parser | t.CPtr, func: AST | t.CPtr) -> AST | t.CPtr: pass
def _parse_subscript(ps: Parser | t.CPtr, value: AST | t.CPtr) -> AST | t.CPtr: pass
def _parse_slice(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_atom(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_paren(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_list(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_brace(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_sub_expr(ps: Parser | t.CPtr, src: str) -> AST | t.CPtr: pass
def _parse_fstring(ps: Parser | t.CPtr, content: str, lineno: t.CInt, col: t.CInt) -> AST | t.CPtr: pass
def _parse_comprehension(ps: Parser | t.CPtr, elt: AST | t.CPtr, vtype: t.CInt, lineno: t.CInt, col: t.CInt) -> AST | t.CPtr: pass
def _parse_comp_for(ps: Parser | t.CPtr) -> list[AST | t.CPtr] | t.CPtr: pass
def _parse_target_list(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_target(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_yield(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_varargslist(ps: Parser | t.CPtr, is_lambda: t.CInt) -> AST | t.CPtr: pass
def _parse_arg_def(ps: Parser | t.CPtr, is_lambda: t.CInt) -> AST | t.CPtr: pass
def _parse_suite_into_children(ps: Parser | t.CPtr, parent: AST | t.CPtr) -> t.CInt: pass
def _parse_statement_into(ps: Parser | t.CPtr, parent: AST | t.CPtr) -> t.CInt: pass
def _parse_simple_stmt_into(ps: Parser | t.CPtr, parent: AST | t.CPtr) -> t.CInt: pass
def _parse_small_stmt(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _maybe_tuple(ps: Parser | t.CPtr, first: AST | t.CPtr) -> AST | t.CPtr: pass
def _parse_testlist(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_expr_stmt(ps: Parser | t.CPtr, first: AST | t.CPtr) -> AST | t.CPtr: pass
def _parse_return(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_raise(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_global(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_nonlocal(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_import(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_from_import(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_alias_list(ps: Parser | t.CPtr) -> list[AST | t.CPtr] | t.CPtr: pass
def _parse_del(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_assert(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_compound(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_if(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_if_tail(ps: Parser | t.CPtr) -> list[AST | t.CPtr] | t.CPtr: pass
def _parse_while(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_for(ps: Parser | t.CPtr, is_async: t.CInt) -> AST | t.CPtr: pass
def _parse_try(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_except_handler(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_with(ps: Parser | t.CPtr, is_async: t.CInt) -> AST | t.CPtr: pass
def _parse_with_item(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_funcdef(ps: Parser | t.CPtr, is_async: t.CInt) -> AST | t.CPtr: pass
def _parse_classdef(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_match(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _make_name_ast(pool: memhub.MemManager | t.CPtr, node: Name | t.CPtr) -> AST | t.CPtr: pass
def _parse_pattern(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_closed_pattern(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_sequence_pattern(ps: Parser | t.CPtr, close_op: t.CInt, lineno: t.CInt, col: t.CInt) -> AST | t.CPtr: pass
def _parse_mapping_pattern(ps: Parser | t.CPtr, lineno: t.CInt, col: t.CInt) -> AST | t.CPtr: pass
def _parse_class_pattern(ps: Parser | t.CPtr, cls: AST | t.CPtr, lineno: t.CInt, col: t.CInt) -> AST | t.CPtr: pass
def _parse_match_case(ps: Parser | t.CPtr) -> AST | t.CPtr: pass
def _parse_decorators(ps: Parser | t.CPtr) -> list[AST | t.CPtr] | t.CPtr: pass
def _parse_module_body(ps: Parser | t.CPtr, module_node: AST | t.CPtr) -> t.CInt: pass
def parse_tokens(pool: memhub.MemManager | t.CPtr, tokens: Token | t.CPtr) -> AST | t.CPtr: pass

30
Test/NewAstTest/temp/f2ecbf8ced20575c.pyi Normal file
View File

@@ -0,0 +1,30 @@
"""
Auto-generated Python stub file from _list.py
Module: _list
"""
import t, c
import memhub
import string
from stdint import *
class list[T]:
__data__: t.CVoid | t.CPtr
__count__: t.CSizeT
__capacity__: t.CSizeT
__pool__: memhub.MemManager | t.CPtr
__elem_size__: t.CSizeT
__iter_index__: t.CSizeT
def __new__(self: list, pool: memhub.MemManager | t.CPtr, elem_size: t.CSizeT) -> t.CInt: pass
def __init__(self: list, pool: memhub.MemManager | t.CPtr, elem_size: t.CSizeT) -> t.CInt: pass
def __len__(self: list) -> t.CSizeT: pass
def append(self: list, item: T) -> t.CInt: pass
def get(self: list, index: t.CSizeT) -> T: pass
def __getitem__(self: list, index: t.CSizeT) -> T: pass
def set(self: list, index: t.CSizeT, value: T) -> t.CInt: pass
def __setitem__(self: list, index: t.CSizeT, value: T) -> t.CInt: pass
def pop(self: list) -> T: pass
def clear(self: list) -> t.CInt: pass
def __iter__(self: list) -> list[T] | t.CPtr: pass
def __next__(self: list) -> T: pass

100
Test/NewAstTest/temp/f5522571bcce7bcb.pyi Normal file
View File

@@ -0,0 +1,100 @@
"""
Auto-generated Python stub file from stdint.py
Module: stdint
"""
import c
import t
INT: t.CTypedef = t.CInt
INTPTR: t.CTypedef = t.CInt | t.CPtr
BOOL: t.CTypedef = t.CInt
UINT: t.CTypedef = t.CUnsignedInt
UINTPTR: t.CTypedef = UINT | t.CPtr
BYTE: t.CTypedef = t.CUnsignedChar
BYTEPTR: t.CTypedef = BYTE | t.CPtr
WORD: t.CTypedef = t.CUInt16T
DWORD: t.CTypedef = t.CUInt32T
QWORD: t.CTypedef = t.CUInt64T
TCHAR: t.CTypedef = t.CChar
CHARLIST: t.CTypedef = str | t.CPtr
VOID: t.CTypedef = t.CVoid
SHORT: t.CTypedef = t.CShort
SHORTPTR: t.CTypedef = t.CShort | t.CPtr
USHORT: t.CTypedef = t.CUnsignedShort
USHORTPTR: t.CTypedef = t.CUnsignedShort | t.CPtr
LONGLONG: t.CTypedef = t.CLongLong
ULONGLONG: t.CTypedef = t.CUnsignedLongLong
LONG: t.CTypedef = t.CLong
ULONG: t.CTypedef = t.CUnsignedLong
WCHAR: t.CTypedef = WORD
WCHARPTR: t.CTypedef = WORD | t.CPtr
CHARPTR: t.CTypedef = t.CChar | t.CPtr
FSIZE_t: t.CTypedef = DWORD
LBA_t: t.CTypedef = DWORD
VOIDPTR: t.CTypedef = t.CVoid | t.CPtr
FLOAT: t.CTypedef = t.CFloat
DOUBLE: t.CTypedef = t.CDouble
FLOAT8: t.CTypedef = t.CFloat8T
FLOAT16: t.CTypedef = t.CFloat16T
FLOAT32: t.CTypedef = t.CFloat32T
FLOAT64: t.CTypedef = t.CFloat64T
FLOAT128: t.CTypedef = t.CFloat128T
INT8: t.CTypedef = t.CInt8T
INT16: t.CTypedef = t.CInt16T
INT32: t.CTypedef = t.CInt32T
INT64: t.CTypedef = t.CInt64T
UINT8: t.CTypedef = t.CUInt8T
UINT16: t.CTypedef = t.CUInt16T
UINT32: t.CTypedef = t.CUInt32T
UINT64: t.CTypedef = t.CUInt64T
INT8PTR: t.CTypedef = t.CInt8T | t.CPtr
INT16PTR: t.CTypedef = t.CInt16T | t.CPtr
INT32PTR: t.CTypedef = t.CInt32T | t.CPtr
INT64PTR: t.CTypedef = t.CInt64T | t.CPtr
UINT8PTR: t.CTypedef = t.CUInt8T | t.CPtr
UINT16PTR: t.CTypedef = t.CUInt16T | t.CPtr
UINT32PTR: t.CTypedef = t.CUInt32T | t.CPtr
UINT64PTR: t.CTypedef = t.CUInt64T | t.CPtr
CHAR8: t.CTypedef = t.CChar8T
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
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
SIZE_T: t.CTypedef = t.CSizeT
SSIZE_T: t.CTypedef = t.CPtrDiffT
PTRDIFF_T: t.CTypedef = t.CPtrDiffT
int8_t: t.CTypedef = t.CInt8T
int16_t: t.CTypedef = t.CInt16T
int32_t: t.CTypedef = t.CInt32T
int64_t: t.CTypedef = t.CInt64T
uint8_t: t.CTypedef = t.CUInt8T
uint16_t: t.CTypedef = t.CUInt16T
uint32_t: t.CTypedef = t.CUInt32T
uint64_t: t.CTypedef = t.CUInt64T
size_t: t.CTypedef = t.CSizeT
ssize_t: t.CTypedef = t.CPtrDiffT
ptrdiff_t: t.CTypedef = t.CPtrDiffT
intptr_t: t.CTypedef = t.CIntPtrT
uintptr_t: t.CTypedef = t.CUIntPtrT
wchar_t: t.CTypedef = t.CWCharT
char8_t: t.CTypedef = t.CChar8T
char16_t: t.CTypedef = t.CChar16T
char32_t: t.CTypedef = t.CChar32T
float8_t: t.CTypedef = t.CFloat8T
float16_t: t.CTypedef = t.CFloat16T
float32_t: t.CTypedef = t.CFloat32T
float64_t: t.CTypedef = t.CFloat64T
float128_t: t.CTypedef = t.CFloat128T
_Bool: t.CTypedef = t.CBool