feat(ast): 结构化 Stmt/Expr 中间基类（isinstance 分类支持）

- base.vp 新增 Stmt/Expr（CVTable，继承 AST），__init__.vp 导出
- stmts.vp 23 个语句类继承 Stmt，exprs.vp 27 个表达式类继承 Expr
- 顶层/辅助/模式/OpNode 保持 AST 直继承（非 Stmt 非 Expr）

includes/ast/__init__.vp

@@ -9,7 +9,7 @@ from .tokens import (
 )
 # Common Section: Base Classes, Enums, Constants, Helper Functions, Dump
 from .base import (
-    AST, ASTKind, ASTCtx, OpKind, ASTFlag,
+    AST, Stmt, Expr, ASTKind, ASTCtx, OpKind, ASTFlag,
     # Constants
     CONST_INT, CONST_FLOAT, CONST_STR, CONST_BOOL, CONST_NONE, CONST_CHAR,
     FLAG_IS_ASYNC, FLAG_SIMPLE, FLAG_HAS_STAR,

includes/ast/base.vp

@@ -457,6 +457,32 @@ class AST:
         _append_child(self.children, node, self.pool)
 
 
+# ============================================================
+# Stmt - Statement Base Class
+#
+# 所有语句节点（Assign/If/For/While/Return/...）继承 Stmt。
+# isinstance(node, ast.Stmt) 可在运行时区分"语句"与"表达式"
+# （依赖 TPV isinstance 子类集合判定 + 三层 vtable 继承）。
+# 不 override kind()（继承 AST 的 0），具体节点各自返回 ASTKind 值。
+# ============================================================
+
+@t.CVTable
+class Stmt(AST):
+    """语句节点基类（Assign/If/For/While/Return/...）"""
+
+
+# ============================================================
+# Expr - Expression Base Class
+#
+# 所有表达式节点（Name/Constant/Call/BinOp/...）继承 Expr。
+# isinstance(node, ast.Expr) 可在运行时区分"表达式"与"语句"。
+# ============================================================
+
+@t.CVTable
+class Expr(AST):
+    """表达式节点基类（Name/Constant/Call/BinOp/...）"""
+
+
 # ============================================================
 # Module dump function (for ast.dump(node, buf, size))
 # ============================================================

includes/ast/exprs.vp

@@ -3,7 +3,7 @@ from stdint import *
 import memhub
 import string
 from .base import (
-    AST, ASTKind, ASTCtx, OpKind,
+    AST, Expr, 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
@@ -14,7 +14,7 @@ from .base import (
 # Name node
 # ============================================================
 
-class Name(AST):
+class Name(Expr):
     """Name(id: str, ctx: ASTCtx)"""
     id:  str
     ctx: t.CInt
@@ -57,7 +57,7 @@ class Name(AST):
 # Constant nodes (subtype marked by const_kind)
 # ============================================================
 
-class Constant(AST):
+class Constant(Expr):
     """Constant(int_val/float_val/str_val, const_kind)"""
     int_val:    t.CInt64T
     float_val:  t.CDouble
@@ -126,7 +126,7 @@ class Constant(AST):
 # BinOp Node
 # ============================================================
 
-class BinOp(AST):
+class BinOp(Expr):
     """BinOp(left: AST, op: OpKind, right: AST)"""
     left:  AST | t.CPtr
     op:    t.CInt
@@ -174,7 +174,7 @@ class BinOp(AST):
 # UnaryOp Node
 # ============================================================
 
-class UnaryOp(AST):
+class UnaryOp(Expr):
     """UnaryOp(op: OpKind, operand: AST)"""
     op:      t.CInt
     operand: AST | t.CPtr
@@ -215,7 +215,7 @@ class UnaryOp(AST):
 # Compare Node
 # ============================================================
 
-class Compare(AST):
+class Compare(Expr):
     """Compare(left: AST, ops: list[CInt], comparators: list[AST | CPtr])"""
     left:        AST | t.CPtr
     ops:         t.CPtr
@@ -265,7 +265,7 @@ class Compare(AST):
 # Call Node
 # ============================================================
 
-class Call(AST):
+class Call(Expr):
     """Call(func: AST, args: list[AST | CPtr], keywords: list[AST | CPtr])"""
     func:     AST | t.CPtr
     args:     list[AST | t.CPtr] | t.CPtr
@@ -314,7 +314,7 @@ class Call(AST):
 # BoolOp Node
 # ============================================================
 
-class BoolOp(AST):
+class BoolOp(Expr):
     """BoolOp(op: CInt, values: list[AST | CPtr])"""
     op:     t.CInt
     values: list[AST | t.CPtr] | t.CPtr
@@ -355,7 +355,7 @@ class BoolOp(AST):
 # Lambda Node
 # ============================================================
 
-class Lambda(AST):
+class Lambda(Expr):
     """Lambda(args: AST, body: AST)"""
     args: AST | t.CPtr
     body: AST | t.CPtr
@@ -399,7 +399,7 @@ class Lambda(AST):
 # IfExp Node
 # ============================================================
 
-class IfExp(AST):
+class IfExp(Expr):
     """IfExp(test: AST, body: AST, orelse: AST)"""
     test:   AST | t.CPtr
     body:   AST | t.CPtr
@@ -452,7 +452,7 @@ class IfExp(AST):
 # Dict Node
 # ============================================================
 
-class Dict(AST):
+class Dict(Expr):
     """Dict(keys: list[AST | CPtr], values: list[AST | CPtr])"""
     keys:   list[AST | t.CPtr] | t.CPtr
     values: list[AST | t.CPtr] | t.CPtr
@@ -494,7 +494,7 @@ class Dict(AST):
 # Set Node
 # ============================================================
 
-class Set(AST):
+class Set(Expr):
     """Set(elts: list[AST | CPtr])"""
     elts: list[AST | t.CPtr] | t.CPtr
 
@@ -529,7 +529,7 @@ class Set(AST):
 # ListComp Node
 # ============================================================
 
-class ListComp(AST):
+class ListComp(Expr):
     """ListComp(elt: AST, generators: list[AST | CPtr])"""
     elt:        AST | t.CPtr
     generators: list[AST | t.CPtr] | t.CPtr
@@ -573,7 +573,7 @@ class ListComp(AST):
 # SetComp Node
 # ============================================================
 
-class SetComp(AST):
+class SetComp(Expr):
     """SetComp(elt: AST, generators: list[AST | CPtr])"""
     elt:        AST | t.CPtr
     generators: list[AST | t.CPtr] | t.CPtr
@@ -617,7 +617,7 @@ class SetComp(AST):
 # DictComp Node
 # ============================================================
 
-class DictComp(AST):
+class DictComp(Expr):
     """DictComp(key: AST, value: AST, generators: list[AST | CPtr])"""
     key:        AST | t.CPtr
     value:      AST | t.CPtr
@@ -668,7 +668,7 @@ class DictComp(AST):
 # GeneratorExp Node
 # ============================================================
 
-class GeneratorExp(AST):
+class GeneratorExp(Expr):
     """GeneratorExp(elt: AST, generators: list[AST | CPtr])"""
     elt:        AST | t.CPtr
     generators: list[AST | t.CPtr] | t.CPtr
@@ -712,7 +712,7 @@ class GeneratorExp(AST):
 # Await Node
 # ============================================================
 
-class Await(AST):
+class Await(Expr):
     """Await(value: AST)"""
     value: AST | t.CPtr
 
@@ -747,7 +747,7 @@ class Await(AST):
 # Yield Node
 # ============================================================
 
-class Yield(AST):
+class Yield(Expr):
     """Yield(value: AST)"""
     value: AST | t.CPtr
 
@@ -782,7 +782,7 @@ class Yield(AST):
 # YieldFrom Node
 # ============================================================
 
-class YieldFrom(AST):
+class YieldFrom(Expr):
     """YieldFrom(value: AST)"""
     value: AST | t.CPtr
 
@@ -817,7 +817,7 @@ class YieldFrom(AST):
 # FormattedValue Node
 # ============================================================
 
-class FormattedValue(AST):
+class FormattedValue(Expr):
     """FormattedValue(value: AST, conversion: CInt, format_spec: AST)"""
     value:       AST | t.CPtr
     conversion:  t.CInt
@@ -867,7 +867,7 @@ class FormattedValue(AST):
 # JoinedStr Node
 # ============================================================
 
-class JoinedStr(AST):
+class JoinedStr(Expr):
     """JoinedStr(values: list[AST | CPtr])"""
     values: list[AST | t.CPtr] | t.CPtr
 
@@ -902,7 +902,7 @@ class JoinedStr(AST):
 # Attribute Node
 # ============================================================
 
-class Attribute(AST):
+class Attribute(Expr):
     """Attribute(value: AST, attr: str, ctx: CInt)"""
     value: AST | t.CPtr
     attr:  str
@@ -947,7 +947,7 @@ class Attribute(AST):
 # Subscript Node
 # ============================================================
 
-class Subscript(AST):
+class Subscript(Expr):
     """Subscript(value: AST, slice: AST, ctx: CInt)"""
     value: AST | t.CPtr
     slice: AST | t.CPtr
@@ -995,7 +995,7 @@ class Subscript(AST):
 # Starred Node
 # ============================================================
 
-class Starred(AST):
+class Starred(Expr):
     """Starred(value: AST, ctx: CInt)"""
     value: AST | t.CPtr
     ctx:   t.CInt
@@ -1036,7 +1036,7 @@ class Starred(AST):
 # List Node
 # ============================================================
 
-class List(AST):
+class List(Expr):
     """List(elts: list[AST | CPtr], ctx: CInt)"""
     elts: list[AST | t.CPtr] | t.CPtr
     ctx:  t.CInt
@@ -1075,7 +1075,7 @@ class List(AST):
 # Tuple Node
 # ============================================================
 
-class Tuple(AST):
+class Tuple(Expr):
     """Tuple(elts: list[AST | CPtr], ctx: CInt)"""
     elts: list[AST | t.CPtr] | t.CPtr
     ctx:  t.CInt
@@ -1114,7 +1114,7 @@ class Tuple(AST):
 # Slice Node
 # ============================================================
 
-class Slice(AST):
+class Slice(Expr):
     """Slice(lower: AST, upper: AST, step: AST)"""
     lower: AST | t.CPtr
     upper: AST | t.CPtr
@@ -1167,7 +1167,7 @@ class Slice(AST):
 # NamedExpr Node
 # ============================================================
 
-class NamedExpr(AST):
+class NamedExpr(Expr):
     """NamedExpr(target: AST, value: AST)"""
     target: AST | t.CPtr
     value:  AST | t.CPtr

includes/ast/stmts.vp

@@ -3,7 +3,7 @@ from stdint import *
 import memhub
 import string
 from .base import (
-    AST, ASTKind, ASTCtx, OpKind,
+    AST, Stmt, ASTKind, ASTCtx, OpKind,
     _init_ast, _copy_str, _set_parent_list,
     _emit, _emit_str, _emit_int, _dump_list,
     FLAG_IS_ASYNC,
@@ -45,7 +45,7 @@ class Module(AST):
 # Assign Node
 # ============================================================
 
-class Assign(AST):
+class Assign(Stmt):
     """Assign(targets: list[AST | t.CPtr], value: AST)"""
     targets: list[AST | t.CPtr] | t.CPtr
     value:   AST | t.CPtr
@@ -87,7 +87,7 @@ class Assign(AST):
 # If Node
 # ============================================================
 
-class If(AST):
+class If(Stmt):
     """If(test: AST, orelse: list[AST | t.CPtr])"""
     test:   AST | t.CPtr
     orelse: list[AST | t.CPtr] | t.CPtr
@@ -133,7 +133,7 @@ class If(AST):
 # For Node
 # ============================================================
 
-class For(AST):
+class For(Stmt):
     """For(target: AST, iter: AST, orelse: list[AST | t.CPtr], is_async: CInt)"""
     target: AST | t.CPtr
     iter:   AST | t.CPtr
@@ -191,7 +191,7 @@ class For(AST):
 # While Node
 # ============================================================
 
-class While(AST):
+class While(Stmt):
     """While(test: AST, orelse: list[AST | t.CPtr])"""
     test:   AST | t.CPtr
     orelse: list[AST | t.CPtr] | t.CPtr
@@ -235,7 +235,7 @@ class While(AST):
 # Return Node
 # ============================================================
 
-class Return(AST):
+class Return(Stmt):
     """Return(value: AST | None)"""
     value: AST | t.CPtr
 
@@ -270,7 +270,7 @@ class Return(AST):
 # Expr Node (expression statement)
 # ============================================================
 
-class Expr(AST):
+class Expr(Stmt):
     """Expr(value: AST)"""
     value: AST | t.CPtr
 
@@ -305,7 +305,7 @@ class Expr(AST):
 # FunctionDef Node
 # ============================================================
 
-class FunctionDef(AST):
+class FunctionDef(Stmt):
     """FunctionDef(name: str, args: AST,
                    decorator_list: list[AST | t.CPtr], returns: AST, flags: CInt,
                    type_params: list[str] | t.CPtr = None)
@@ -494,7 +494,7 @@ class FunctionType(AST):
 # ClassDef Node
 # ============================================================
 
-class ClassDef(AST):
+class ClassDef(Stmt):
     """ClassDef(name: str, bases: list[AST | t.CPtr], keywords: list[AST | t.CPtr],
                 decorator_list: list[AST | t.CPtr], type_params: list[str] | t.CPtr)
 
@@ -557,7 +557,7 @@ class ClassDef(AST):
 # Delete Node
 # ============================================================
 
-class Delete(AST):
+class Delete(Stmt):
     """Delete(targets: list[AST | t.CPtr])"""
     targets: list[AST | t.CPtr] | t.CPtr
 
@@ -592,7 +592,7 @@ class Delete(AST):
 # AugAssign Node
 # ============================================================
 
-class AugAssign(AST):
+class AugAssign(Stmt):
     """AugAssign(target: AST, op: CInt, value: AST)"""
     target: AST | t.CPtr
     op:     t.CInt
@@ -640,7 +640,7 @@ class AugAssign(AST):
 # AnnAssign Node
 # ============================================================
 
-class AnnAssign(AST):
+class AnnAssign(Stmt):
     """AnnAssign(target: AST, annotation: AST, value: AST, simple: CInt)"""
     target:     AST | t.CPtr
     annotation: AST | t.CPtr
@@ -697,7 +697,7 @@ class AnnAssign(AST):
 # With Node
 # ============================================================
 
-class With(AST):
+class With(Stmt):
     """With(items: list[AST | t.CPtr], is_async: CInt)"""
     items: list[AST | t.CPtr] | t.CPtr
     flags: t.CInt
@@ -741,7 +741,7 @@ class With(AST):
 # Raise Node
 # ============================================================
 
-class Raise(AST):
+class Raise(Stmt):
     """Raise(exc: AST, cause: AST)"""
     exc:   AST | t.CPtr
     cause: AST | t.CPtr
@@ -785,7 +785,7 @@ class Raise(AST):
 # Try Node
 # ============================================================
 
-class Try(AST):
+class Try(Stmt):
     """Try(handlers: list[AST | t.CPtr],
           orelse: list[AST | t.CPtr], finalbody: list[AST | t.CPtr])"""
     handlers:  list[AST | t.CPtr] | t.CPtr
@@ -837,7 +837,7 @@ class Try(AST):
 # Assert Node
 # ============================================================
 
-class Assert(AST):
+class Assert(Stmt):
     """Assert(test: AST, msg: AST)"""
     test: AST | t.CPtr
     msg:  AST | t.CPtr
@@ -881,7 +881,7 @@ class Assert(AST):
 # Global Node
 # ============================================================
 
-class Global(AST):
+class Global(Stmt):
     """Global(names: list[AST | t.CPtr])"""
     names: list[AST | t.CPtr] | t.CPtr
 
@@ -916,7 +916,7 @@ class Global(AST):
 # Nonlocal Node
 # ============================================================
 
-class Nonlocal(AST):
+class Nonlocal(Stmt):
     """Nonlocal(names: list[AST | t.CPtr])"""
     names: list[AST | t.CPtr] | t.CPtr
 
@@ -951,7 +951,7 @@ class Nonlocal(AST):
 # Pass Node
 # ============================================================
 
-class Pass(AST):
+class Pass(Stmt):
     """Pass()"""
 
     def __new__(self, pool: memhub.MemManager | t.CPtr):
@@ -979,7 +979,7 @@ class Pass(AST):
 # Break Node
 # ============================================================
 
-class Break(AST):
+class Break(Stmt):
     """Break()"""
 
     def __new__(self, pool: memhub.MemManager | t.CPtr):
@@ -1007,7 +1007,7 @@ class Break(AST):
 # Continue Node
 # ============================================================
 
-class Continue(AST):
+class Continue(Stmt):
     """Continue()"""
 
     def __new__(self, pool: memhub.MemManager | t.CPtr):
@@ -1035,7 +1035,7 @@ class Continue(AST):
 # Import Node
 # ============================================================
 
-class Import(AST):
+class Import(Stmt):
     """Import(names: list[AST | t.CPtr])"""
     names: list[AST | t.CPtr] | t.CPtr
 
@@ -1070,7 +1070,7 @@ class Import(AST):
 # ImportFrom Node
 # ============================================================
 
-class ImportFrom(AST):
+class ImportFrom(Stmt):
     """ImportFrom(module: str, names: list[AST | t.CPtr], level: CInt)"""
     module: str
     names:  list[AST | t.CPtr] | t.CPtr
@@ -1117,7 +1117,7 @@ class ImportFrom(AST):
 # Match Node
 # ============================================================
 
-class Match(AST):
+class Match(Stmt):
     """Match(subject: AST, cases: list[AST | t.CPtr])"""
     subject: AST | t.CPtr
     cases:   list[AST | t.CPtr] | t.CPtr