相对稳定版本

Test/SlotsBugTest/.tpv_build/temp/03/03d3ece355d95d76.deps.txt

@@ -0,0 +1 @@
+t c vipermath

Test/SlotsBugTest/.tpv_build/temp/06/067c78e9f121dce3.deps.txt

@@ -0,0 +1 @@
+t stdint w32.win32base

Test/SlotsBugTest/.tpv_build/temp/06/06f53cc594b4ac6c.deps.txt

@@ -0,0 +1 @@
+t stdint w32.win32base

Test/SlotsBugTest/.tpv_build/temp/07/07536d26b435806c.deps.txt

@@ -0,0 +1 @@
+t c stdint vqt6._types

Test/SlotsBugTest/.tpv_build/temp/0c/0c67644125bea0fd.deps.txt

@@ -0,0 +1 @@
+t c stdint platmacro memhub string stdio w32.win32base w32 w32.win32process w32 posix

Test/SlotsBugTest/.tpv_build/temp/0c/0cb53ffd1825de7e.deps.txt

@@ -0,0 +1 @@
+t c stdint w32.win32base w32.win32sync

Test/SlotsBugTest/.tpv_build/temp/0d/0df65b8ed15664b0.deps.txt

@@ -0,0 +1 @@
+string t c

Test/SlotsBugTest/.tpv_build/temp/13/13110effbb0bb06c.deps.txt

@@ -0,0 +1 @@
+t c stdint string memhub platmacro

Test/SlotsBugTest/.tpv_build/temp/14/143d6f5584d3b646.deps.txt

@@ -0,0 +1 @@
+t c stdint

Test/SlotsBugTest/.tpv_build/temp/19/19f8024d10c828e8.deps.txt

@@ -0,0 +1 @@
+string t c

Test/SlotsBugTest/.tpv_build/temp/1f/1f6617c02fc8899d.deps.txt

@@ -0,0 +1 @@
+stdint string stdlib memhub t c

Test/SlotsBugTest/.tpv_build/temp/20/20cd49775c100a38.deps.txt

@@ -0,0 +1 @@
+t c stdint memhub string stdio json

Test/SlotsBugTest/.tpv_build/temp/22/22bc0df83b3f0e62.deps.txt

@@ -0,0 +1 @@
+t c stdint memhub string viperlib ast.tokens

Test/SlotsBugTest/.tpv_build/temp/22/22bc0df83b3f0e62.vpi

@@ -0,0 +1,180 @@
+"""Auto-generated Python stub file"""
+
+
+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
+CONST_CHAR: t.CDefine = 6
+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): pass
+
+def _inherit_pos(node: AST | t.CPtr, ref: AST | t.CPtr): pass
+
+def _init_ast(node: AST | t.CPtr, pool: memhub.MemManager | t.CPtr, lineno: t.CInt, col: t.CInt): pass
+
+def _set_parent_list(lst: list[AST | t.CPtr] | t.CPtr, parent: AST | t.CPtr): pass
+
+def _append_child(lst: list[AST | t.CPtr] | t.CPtr, node: AST | t.CPtr, pool: memhub.MemManager | t.CPtr): 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) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+    def accept(self, visitor: t.CPtr): pass
+    def append(self, node: AST | t.CPtr): pass
+
+def dump(node: AST | t.CPtr, buf: t.CChar | t.CPtr, size: t.CSizeT): pass
+

Test/SlotsBugTest/.tpv_build/temp/24/240a9a4157959a9f.deps.txt

@@ -0,0 +1 @@
+t c stdint memhub string json

Test/SlotsBugTest/.tpv_build/temp/28/285a822aa26bfbda.deps.txt

@@ -0,0 +1 @@
+t c stdint memhub

Test/SlotsBugTest/.tpv_build/temp/28/285b6aa29a34754d.deps.txt

@@ -0,0 +1 @@
+t c

Test/SlotsBugTest/.tpv_build/temp/28/28de517e3820658a.deps.txt

@@ -0,0 +1 @@
+t c stdint

Test/SlotsBugTest/.tpv_build/temp/2b/2b77d783c41d21d1.deps.txt

@@ -0,0 +1 @@
+t c string memhub stdint

Test/SlotsBugTest/.tpv_build/temp/2f/2ff06fad52dc2c2c.deps.txt

@@ -0,0 +1 @@
+t c stdint w32.win32base w32.win32sync

Test/SlotsBugTest/.tpv_build/temp/32/32cfd766982bc6e7.deps.txt

@@ -0,0 +1 @@
+stdio t c

Test/SlotsBugTest/.tpv_build/temp/33/33d64eeb99369a85.deps.txt

@@ -0,0 +1 @@
+t c stdint memhub string viperlib llvmlite.__types llvmlite.__values llvmlite.__function llvmlite.__module llvmlite.__builder llvmlite.__verify

Test/SlotsBugTest/.tpv_build/temp/34/3487a256b250bb74.deps.txt

@@ -0,0 +1 @@
+t c

Test/SlotsBugTest/.tpv_build/temp/36/3624cfde3c5cb6cb.deps.txt

@@ -0,0 +1 @@
+string

Test/SlotsBugTest/.tpv_build/temp/3b/3b96973f2c5c4418.deps.txt

@@ -0,0 +1 @@
+t c stdint w32.win32base w32.win32sync

Test/SlotsBugTest/.tpv_build/temp/3e/3e775aa83705b119.deps.txt

@@ -0,0 +1 @@
+stdint zlib.zdeflate zdeflate zlib.zinflate zinflate zlib.zchecksum zchecksum zlib.zdef zdef zlib.zhuff zhuff stdlib string memhub t c

Test/SlotsBugTest/.tpv_build/temp/3f/3f7c5e78d8652535.deps.txt

@@ -0,0 +1 @@
+t c

Test/SlotsBugTest/.tpv_build/temp/40/40c03bc03431ef81.deps.txt

@@ -0,0 +1 @@
+t c stdint string stdio viperlib memhub linkedlist llvmlite.__types llvmlite.__function

Test/SlotsBugTest/.tpv_build/temp/43/4337fb260448bbe2.deps.txt

@@ -0,0 +1 @@
+t c stdint memhub string ast.base

Test/SlotsBugTest/.tpv_build/temp/43/4337fb260448bbe2.vpi

@@ -0,0 +1,76 @@
+"""Auto-generated Python stub file"""
+
+
+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, pool: memhub.MemManager | t.CPtr, type: AST | t.CPtr, name: str): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, type: AST | t.CPtr, name: str): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, 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, 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): pass
+    def __init__(self, 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): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, buf: bytes, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+
+class Arg(AST):
+    arg: str
+    annotation: AST | t.CPtr
+    def __new__(self, pool: memhub.MemManager | t.CPtr, arg: str, annotation: AST | t.CPtr): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, arg: str, annotation: AST | t.CPtr): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, buf: bytes, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+
+class Keyword(AST):
+    arg: str
+    value: AST | t.CPtr
+    def __new__(self, pool: memhub.MemManager | t.CPtr, arg: str, value: AST | t.CPtr): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, arg: str, value: AST | t.CPtr): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, buf: bytes, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+
+class Alias(AST):
+    name: str
+    asname: str
+    def __new__(self, pool: memhub.MemManager | t.CPtr, name: str, asname: str): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, name: str, asname: str): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, 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, pool: memhub.MemManager | t.CPtr, context_expr: AST | t.CPtr, optional_vars: AST | t.CPtr): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, context_expr: AST | t.CPtr, optional_vars: AST | t.CPtr): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, 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, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, iter: AST | t.CPtr, ifs: list[AST | t.CPtr] | t.CPtr, is_async: t.CInt): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, iter: AST | t.CPtr, ifs: list[AST | t.CPtr] | t.CPtr, is_async: t.CInt): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, buf: bytes, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+

Test/SlotsBugTest/.tpv_build/temp/45/451745df21e598af.deps.txt

@@ -0,0 +1 @@
+stdint zlib.zchecksum zchecksum zlib.zdef zdef zlib.zhuff zhuff string memhub t c

Test/SlotsBugTest/.tpv_build/temp/48/4826f733b0735536.deps.txt

@@ -0,0 +1 @@
+t c stdint platmacro memhub os.path os os._win32 os os._posix os

Test/SlotsBugTest/.tpv_build/temp/4d/4dd6b3f1427d1cc5.deps.txt

@@ -0,0 +1 @@
+t c stdint memhub string ast.base

Test/SlotsBugTest/.tpv_build/temp/63/63d0e4548b4c4672.deps.txt

@@ -0,0 +1 @@
+t c stdint viperlib string memhub stdio stdlib linkedlist

Test/SlotsBugTest/.tpv_build/temp/63/63f2c82fe8a3ef8e.deps.txt

@@ -0,0 +1 @@
+t c atom

Test/SlotsBugTest/.tpv_build/temp/64/6446627d4f07a1b5.deps.txt

@@ -0,0 +1 @@
+t c stdint w32.win32base

Test/SlotsBugTest/.tpv_build/temp/65/657e182b27c2a022.deps.txt

@@ -0,0 +1 @@
+t c stdint memhub string ast.base

Test/SlotsBugTest/.tpv_build/temp/69/691880abe4506068.deps.txt

@@ -0,0 +1 @@
+stdio

Test/SlotsBugTest/.tpv_build/temp/6b/6b3bc463fd044545.deps.txt

@@ -0,0 +1 @@
+t c stdint string viperlib memhub linkedlist llvmlite.__function llvmlite.__module

Test/SlotsBugTest/.tpv_build/temp/6c/6c658cc728d0bbf4.deps.txt

@@ -0,0 +1 @@
+stdint t

Test/SlotsBugTest/.tpv_build/temp/6d/6d535de0b03e99b5.deps.txt

@@ -0,0 +1 @@
+t stdint

Test/SlotsBugTest/.tpv_build/temp/6d/6dde8fc09b24666c.deps.txt

@@ -0,0 +1 @@
+t c

Test/SlotsBugTest/.tpv_build/temp/6d/6ddf430432a0e373.deps.txt

@@ -0,0 +1 @@
+t c stdint memhub string viperio json.__parser json.__writer

Test/SlotsBugTest/.tpv_build/temp/6f/6ff26590374ae6fc.deps.txt

@@ -0,0 +1 @@
+t c

Test/SlotsBugTest/.tpv_build/temp/71/71e0a3ffcb3ebfad.deps.txt

@@ -0,0 +1 @@
+t

Test/SlotsBugTest/.tpv_build/temp/72/72e2d5ccb7cedcf1.deps.txt

@@ -0,0 +1 @@
+t stdint w32.win32base

Test/SlotsBugTest/.tpv_build/temp/74/748d0424e8976fa0.deps.txt

@@ -0,0 +1 @@
+t c stdio w32.win32console

Test/SlotsBugTest/.tpv_build/temp/74/74cd54a2cba56957.deps.txt

@@ -0,0 +1 @@
+t c stdint w32.win32process stdlib stdio string

Test/SlotsBugTest/.tpv_build/temp/7c/7cadfe07e983fd90.deps.txt

@@ -0,0 +1 @@
+t c memhub string stdint

Test/SlotsBugTest/.tpv_build/temp/7d/7d8c26e41226955a.deps.txt

@@ -0,0 +1 @@
+t c stdint platmacro memhub string w32.win32base w32 w32.win32file w32 posix

Test/SlotsBugTest/.tpv_build/temp/87/874bac141c97bae9.deps.txt

@@ -0,0 +1 @@
+t c stdint string viperlib memhub stdio linkedlist llvmlite.__types

Test/SlotsBugTest/.tpv_build/temp/8e/8ebed83a7817fa0c.deps.txt

@@ -0,0 +1 @@
+stdint t c

Test/SlotsBugTest/.tpv_build/temp/90/90921d009fdd674c.deps.txt

@@ -0,0 +1 @@
+stdint zlib.zchecksum zchecksum zlib.zhuff zhuff zlib.zdef zdef string memhub t c

Test/SlotsBugTest/.tpv_build/temp/96/96837bcc64032444.deps.txt

@@ -0,0 +1 @@
+hashlib.__md5 hashlib.__sha1 hashlib.__sha256 hashlib.__sha512

Test/SlotsBugTest/.tpv_build/temp/99/995f884b86cf981e.deps.txt

@@ -0,0 +1 @@
+t stdint vqt6._types vqt6._qtcore vqt6._qtwidgets vqt6._qtgui vqt6._qtnetwork

Test/SlotsBugTest/.tpv_build/temp/_sha1_map.txt

@@ -0,0 +1,22 @@
+4337fb260448bbe2:includes/ast/astaux.vp
+22bc0df83b3f0e62:includes/ast/base.vp
+b543bc1dfb592119:includes/ast/exprs.vp
+f5d13f1be34f417a:includes/ast/lexer.vp
+fde6db0747bdd959:includes/ast/parser.vp
+657e182b27c2a022:includes/ast/stmts.vp
+b547ac4f380bddb6:includes/ast/tokens.vp
+de3357cb9182715e:includes/ast/__init__.vp
+aa246c6e6aa30484:includes/atom.vp
+6ddf430432a0e373:includes/json/__init__.vp
+240a9a4157959a9f:includes/json/__parser.vp
+20cd49775c100a38:includes/json/__writer.vp
+f9d023d1df2bc9c5:includes/memhub.vp
+71e0a3ffcb3ebfad:includes/stdarg.vp
+f5522571bcce7bcb:includes/stdint.vp
+285b6aa29a34754d:includes/stdio.vp
+6c658cc728d0bbf4:includes/stdlib.vp
+ffaf70367668b227:includes/string.vp
+c9f4be41ca1cc2b4:includes/viperio.vp
+f6ab8989f3545e83:includes/viperlib.vp
+e0f0afe3caa1e486:includes/_dict.vp
+7cadfe07e983fd90:includes/_list.vp

Test/SlotsBugTest/.tpv_build/temp/a2/a2c1138ed2328b33.deps.txt

@@ -0,0 +1 @@
+t c stdint string socket memhub stdio

Test/SlotsBugTest/.tpv_build/temp/a3/a335eb99f2e34479.deps.txt

@@ -0,0 +1 @@
+t c stdint platmacro memhub string w32.win32base w32 w32.win32file w32 w32.win32process w32 w32.win32sync w32 posix

Test/SlotsBugTest/.tpv_build/temp/a4/a44503977f4f5951.deps.txt

@@ -0,0 +1 @@
+t c

Test/SlotsBugTest/.tpv_build/temp/a5/a5e9a83e9db303ad.deps.txt

@@ -0,0 +1 @@
+t c stdint

Test/SlotsBugTest/.tpv_build/temp/a6/a68b70f233541a7f.deps.txt

@@ -0,0 +1 @@
+t c stdint w32.win32base w32 w32.win32file w32 memhub stdlib

Test/SlotsBugTest/.tpv_build/temp/a7/a7748ef067f79205.deps.txt

@@ -0,0 +1 @@
+t c stdint string viperlib memhub stdio linkedlist llvmlite.__types llvmlite.__values llvmlite.__function

Test/SlotsBugTest/.tpv_build/temp/a7/a7cef7aa679215d9.deps.txt

@@ -0,0 +1 @@
+t c stdint w32.win32base w32.win32sync

Test/SlotsBugTest/.tpv_build/temp/aa/aa246c6e6aa30484.deps.txt

@@ -0,0 +1 @@
+t c

Test/SlotsBugTest/.tpv_build/temp/ab/ab0baf141ec5b021.deps.txt

@@ -0,0 +1 @@
+t c stdint w32.win32base w32.win32process w32.win32sync lock event condition rwlock

Test/SlotsBugTest/.tpv_build/temp/af/af37c9ab38eea99e.deps.txt

@@ -0,0 +1 @@
+t

Test/SlotsBugTest/.tpv_build/temp/b3/b311b47f33281389.deps.txt

@@ -0,0 +1 @@
+t memhub string

Test/SlotsBugTest/.tpv_build/temp/b3/b370d93b74bf55cc.deps.txt

@@ -0,0 +1 @@
+t c string memhub stdio hashtable

Test/SlotsBugTest/.tpv_build/temp/b5/b543bc1dfb592119.deps.txt

@@ -0,0 +1 @@
+t c stdint memhub string ast.base

Test/SlotsBugTest/.tpv_build/temp/b5/b543bc1dfb592119.vpi

@@ -0,0 +1,265 @@
+"""Auto-generated Python stub file"""
+
+
+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, CONST_CHAR
+class Name(AST):
+    id: str
+    ctx: t.CInt
+    def __new__(self, pool: memhub.MemManager | t.CPtr, id: str, ctx: t.CInt): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, id: str, ctx: t.CInt): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, 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, 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): pass
+    def __init__(self, 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): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, 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, pool: memhub.MemManager | t.CPtr, left: AST | t.CPtr, op: t.CInt, right: AST | t.CPtr): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, left: AST | t.CPtr, op: t.CInt, right: AST | t.CPtr): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, 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, pool: memhub.MemManager | t.CPtr, op: t.CInt, operand: AST | t.CPtr): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, op: t.CInt, operand: AST | t.CPtr): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, 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, pool: memhub.MemManager | t.CPtr, left: AST | t.CPtr, ops: t.CPtr, comparators: list[AST | t.CPtr] | t.CPtr): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, left: AST | t.CPtr, ops: t.CPtr, comparators: list[AST | t.CPtr] | t.CPtr): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, 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, pool: memhub.MemManager | t.CPtr, func: AST | t.CPtr, args: list[AST | t.CPtr] | t.CPtr, keywords: list[AST | t.CPtr] | t.CPtr): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, func: AST | t.CPtr, args: list[AST | t.CPtr] | t.CPtr, keywords: list[AST | t.CPtr] | t.CPtr): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, 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, pool: memhub.MemManager | t.CPtr, op: t.CInt, values: list[AST | t.CPtr] | t.CPtr): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, op: t.CInt, values: list[AST | t.CPtr] | t.CPtr): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, 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, pool: memhub.MemManager | t.CPtr, args: AST | t.CPtr, body: AST | t.CPtr): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, args: AST | t.CPtr, body: AST | t.CPtr): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, 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, pool: memhub.MemManager | t.CPtr, test: AST | t.CPtr, body: AST | t.CPtr, orelse: AST | t.CPtr): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, test: AST | t.CPtr, body: AST | t.CPtr, orelse: AST | t.CPtr): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, 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, pool: memhub.MemManager | t.CPtr, keys: list[AST | t.CPtr] | t.CPtr, values: list[AST | t.CPtr] | t.CPtr): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, keys: list[AST | t.CPtr] | t.CPtr, values: list[AST | t.CPtr] | t.CPtr): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, 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, pool: memhub.MemManager | t.CPtr, elts: list[AST | t.CPtr] | t.CPtr): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, elts: list[AST | t.CPtr] | t.CPtr): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, 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, pool: memhub.MemManager | t.CPtr, elt: AST | t.CPtr, generators: list[AST | t.CPtr] | t.CPtr): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, elt: AST | t.CPtr, generators: list[AST | t.CPtr] | t.CPtr): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, 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, pool: memhub.MemManager | t.CPtr, elt: AST | t.CPtr, generators: list[AST | t.CPtr] | t.CPtr): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, elt: AST | t.CPtr, generators: list[AST | t.CPtr] | t.CPtr): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, 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, pool: memhub.MemManager | t.CPtr, key: AST | t.CPtr, value: AST | t.CPtr, generators: list[AST | t.CPtr] | t.CPtr): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, key: AST | t.CPtr, value: AST | t.CPtr, generators: list[AST | t.CPtr] | t.CPtr): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, 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, pool: memhub.MemManager | t.CPtr, elt: AST | t.CPtr, generators: list[AST | t.CPtr] | t.CPtr): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, elt: AST | t.CPtr, generators: list[AST | t.CPtr] | t.CPtr): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+
+class Await(AST):
+    value: AST | t.CPtr
+    def __new__(self, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+
+class Yield(AST):
+    value: AST | t.CPtr
+    def __new__(self, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+
+class YieldFrom(AST):
+    value: AST | t.CPtr
+    def __new__(self, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, 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, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr, conversion: t.CInt, format_spec: AST | t.CPtr): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr, conversion: t.CInt, format_spec: AST | t.CPtr): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, 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, pool: memhub.MemManager | t.CPtr, values: list[AST | t.CPtr] | t.CPtr): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, values: list[AST | t.CPtr] | t.CPtr): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, 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, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr, attr: str, ctx: t.CInt): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr, attr: str, ctx: t.CInt): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, 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, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr, slice: AST | t.CPtr, ctx: t.CInt): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr, slice: AST | t.CPtr, ctx: t.CInt): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, 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, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr, ctx: t.CInt): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr, ctx: t.CInt): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, 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, pool: memhub.MemManager | t.CPtr, elts: list[AST | t.CPtr] | t.CPtr, ctx: t.CInt): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, elts: list[AST | t.CPtr] | t.CPtr, ctx: t.CInt): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, 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, pool: memhub.MemManager | t.CPtr, elts: list[AST | t.CPtr] | t.CPtr, ctx: t.CInt): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, elts: list[AST | t.CPtr] | t.CPtr, ctx: t.CInt): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, 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, pool: memhub.MemManager | t.CPtr, lower: AST | t.CPtr, upper: AST | t.CPtr, step: AST | t.CPtr): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, lower: AST | t.CPtr, upper: AST | t.CPtr, step: AST | t.CPtr): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, 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, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, value: AST | t.CPtr): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, value: AST | t.CPtr): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+
+class OpNode(AST):
+    op: t.CInt
+    def __new__(self, pool: memhub.MemManager | t.CPtr, op: t.CInt): pass
+    def __init__(self, pool: memhub.MemManager | t.CPtr, op: t.CInt): pass
+    def kind(self) -> t.CInt: pass
+    def type_name(self) -> str: pass
+    def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
+

Test/SlotsBugTest/.tpv_build/temp/b5/b547ac4f380bddb6.deps.txt

@@ -0,0 +1 @@
+t c stdint memhub string

Test/SlotsBugTest/.tpv_build/temp/b5/b57252077e6b596b.deps.txt

@@ -0,0 +1 @@
+t c

Test/SlotsBugTest/.tpv_build/temp/bb/bbdf3bbd4c3bc28c.deps.txt

@@ -0,0 +1 @@
+t stdint w32.win32base

Test/SlotsBugTest/.tpv_build/temp/c1/c18c3a20f82d7525.deps.txt

@@ -0,0 +1 @@
+t c stdint vqt6._types

Test/SlotsBugTest/.tpv_build/temp/c3/c3a6aed1f1fb8b1e.deps.txt

@@ -0,0 +1 @@
+stdint stdlib string vipermath stdio t c memhub

Test/SlotsBugTest/.tpv_build/temp/c9/c9d54a4158f7f5a8.deps.txt

@@ -0,0 +1 @@
+t c

Test/SlotsBugTest/.tpv_build/temp/c9/c9f4be41ca1cc2b4.deps.txt

@@ -0,0 +1 @@
+t c stdint

Test/SlotsBugTest/.tpv_build/temp/d1/d137b1f3311f3a7f.deps.txt

@@ -0,0 +1 @@
+t c stdint stdio w32.win32base w32 w32.win32file w32

Test/SlotsBugTest/.tpv_build/temp/d1/d152115b49e50218.deps.txt

@@ -0,0 +1 @@
+t c stdint posix memhub stdlib

Test/SlotsBugTest/.tpv_build/temp/d3/d3917d97537f703c.deps.txt

@@ -0,0 +1 @@
+t c

Test/SlotsBugTest/.tpv_build/temp/d5/d541ade6afb689a5.deps.txt

@@ -0,0 +1 @@
+stdint zlib.zdef zdef memhub t c

Test/SlotsBugTest/.tpv_build/temp/d6/d63d2c2a2bd9bd2a.deps.txt

@@ -0,0 +1 @@
+zlib.pyzlib

Test/SlotsBugTest/.tpv_build/temp/d9/d989a211953ede05.deps.txt

@@ -0,0 +1 @@
+t c stdint vqt6._types

Test/SlotsBugTest/.tpv_build/temp/de/de3357cb9182715e.deps.txt

@@ -0,0 +1 @@
+t c stdint memhub string ast.tokens ast.base ast.stmts ast.exprs ast.astaux ast.visitor ast.lexer ast.parser ast.parser

Test/SlotsBugTest/.tpv_build/temp/e0/e0f0afe3caa1e486.deps.txt

@@ -0,0 +1 @@
+t c memhub string json stdint

Test/SlotsBugTest/.tpv_build/temp/e1/e1f7ae4d330dcf9f.deps.txt

@@ -0,0 +1 @@
+t c stdint vqt6._types

Test/SlotsBugTest/.tpv_build/temp/f5/f5522571bcce7bcb.deps.txt

@@ -0,0 +1 @@
+t

Test/SlotsBugTest/.tpv_build/temp/f5/f5d13f1be34f417a.deps.txt

@@ -0,0 +1 @@
+t c stdint memhub string ast.tokens

Test/SlotsBugTest/.tpv_build/temp/f5/f5d13f1be34f417a.vpi

@@ -0,0 +1,64 @@
+"""Auto-generated Python stub file"""
+
+
+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, pool: memhub.MemManager | t.CPtr): 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): 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): 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): pass
+
+def _read_name(lx: Lexer | t.CPtr): pass
+
+def _read_number(lx: Lexer | t.CPtr): 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): pass
+
+def _read_string(lx: Lexer | t.CPtr): pass
+
+def _read_operator(lx: Lexer | t.CPtr): pass
+
+def tokenize(lx: Lexer | t.CPtr) -> Token | t.CPtr: pass
+
+tok: Token | t.CPtr

Test/SlotsBugTest/.tpv_build/temp/f6/f6ab8989f3545e83.deps.txt

@@ -0,0 +1 @@
+t c viperio stdarg

Test/SlotsBugTest/.tpv_build/temp/f6/f6b51804a0ba8ff0.deps.txt

@@ -0,0 +1 @@
+t stdint w32.win32base

Test/SlotsBugTest/.tpv_build/temp/f7/f742623d43c327ea.deps.txt

@@ -0,0 +1 @@
+t c stdint string platmacro stdio w32.winsock2 w32

Test/SlotsBugTest/.tpv_build/temp/f9/f9d023d1df2bc9c5.deps.txt

@@ -0,0 +1 @@
+t c stdint string atom viperio stdio stdlib

Test/SlotsBugTest/.tpv_build/temp/f9/f9e36e2cd6fa659f.deps.txt

@@ -0,0 +1 @@
+t c stdint string viperlib memhub linkedlist llvmlite.__types

Test/SlotsBugTest/.tpv_build/temp/fc/fc980acec33d69a7.deps.txt

@@ -0,0 +1 @@
+t stdint

Test/SlotsBugTest/.tpv_build/temp/fd/fde6db0747bdd959.deps.txt

@@ -0,0 +1 @@
+t c stdint memhub string ast.tokens ast.base ast.exprs ast.stmts ast.astaux ast.lexer

Test/SlotsBugTest/.tpv_build/temp/fd/fde6db0747bdd959.vpi

@@ -0,0 +1,211 @@
+"""Auto-generated Python stub file"""
+
+
+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, CONST_CHAR, 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 .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, pool: memhub.MemManager | t.CPtr): 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): pass
+
+def _advance(ps: Parser | t.CPtr): 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): pass
+
+def _skip_nls_and_newlines(ps: Parser | t.CPtr): 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, is_dquote: t.CInt, is_triple: t.CInt, is_char: 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): pass
+
+def _fix_store_ctx(node: AST | t.CPtr): 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): 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): pass
+
+def _parse_statement_into(ps: Parser | t.CPtr, parent: AST | t.CPtr): pass
+
+def _parse_simple_stmt_into(ps: Parser | t.CPtr, parent: AST | t.CPtr): 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): pass
+
+def parse_tokens(pool: memhub.MemManager | t.CPtr, tokens: Token | t.CPtr) -> AST | t.CPtr: pass
+

Test/SlotsBugTest/.tpv_build/temp/ff/ffaf70367668b227.deps.txt

@@ -0,0 +1 @@
+stdint t c

Test/SlotsBugTest/temp/22bc0df83b3f0e62.stub.ll.dep

@@ -0,0 +1 @@
+285b6aa29a34754d|6c658cc728d0bbf4|71e0a3ffcb3ebfad|aa246c6e6aa30484|b547ac4f380bddb6|c9f4be41ca1cc2b4|f5522571bcce7bcb|f6ab8989f3545e83|f9d023d1df2bc9c5|ffaf70367668b227

Test/SlotsBugTest/temp/22bc0df83b3f0e62.vpi

@@ -0,0 +1,183 @@
+"""
+Auto-generated Python stub file from ast.base.vp
+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
+CONST_CHAR: t.CDefine = 6
+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