pub suberror MpythonError {
  MpythonError(RuntimeError)
}

pub(all) struct BcBuilder {
  code : BcCode
}

pub(all) struct BcCode {
  name : String
  filename : String
  consts : Array[Value]
  names : Array[String]
  patterns : Array[Pattern]
  genexps : Array[GenExpSpec]
  ops : Array[BcOp]
  spans : Array[Span?]
}

pub(all) enum BcOp {
  Nop
  PopTop
  DupTop
  RotTwo
  RotThree
  LoadConst(Int)
  LoadName(Int)
  StoreName(Int)
  DeleteName(Int)
  LoadAttr(Int)
  StoreAttr(Int)
  DeleteAttr(Int)
  LoadSubscr
  StoreSubscr
  DeleteSubscr
  BuildTuple(Int)
  BuildList(Int)
  BuildMap(Int)
  BuildSet(Int)
  BuildSlice
  ListAppend
  ListExtend
  SetAdd
  SetUpdate
  DictSetItem
  DictUpdate
  KwListExtendFromDict
  ListToTuple
  EvalFString
  UnpackSequence(Int)
  UnpackEx(Int, Int)
  GetIter
  ForIter(Int)
  Unary(UnaryOp)
  Binary(BinaryOp)
  Compare(CompareOp)
  Jump(Int)
  JumpIfFalse(Int)
  JumpIfTrue(Int)
  JumpIfFalseOrPop(Int)
  JumpIfTrueOrPop(Int)
  UnwindJump(Int, Int)
  SetupExcept(Int)
  SetupFinally(Int)
  PopExcept
  EnterFinally(Int)
  EndExcept
  EndFinally
  CheckExceptionMatch
  LoadException
  LoadExceptionType
  LoadExceptionTypeName
  LoadExceptionTraceback
  HasPendingException
  ClearPendingException
  EnsureExceptionGroup
  ExceptStarInit
  ExceptStarMatch
  ExceptStarEndHandler
  ExceptStarRaiseRemaining
  Raise
  RaiseFrom
  Reraise
  AssertFail
  AssertFailNone
  Await
  MatchPattern(Int)
  MatchBind
  MatchRestore
  GenExpNew(Int, Int, Int)
  AsyncGenExpNew(Int, Int, Int)
  CallFunction(Int)
  CallFunctionKw(Int)
  CallFunctionVar
  MakeFunction(Int, Int, Int)
  MakeClass(Int, Int, Int)
  MakeTypeAlias(Int)
  StoreAnnotation(Int)
  AugAssignName(Int, BinaryOp)
  AugAssignAttr(Int, BinaryOp)
  AugAssignSubscr(BinaryOp)
  ImportName(Int, Int)
  FromImport(Int, Int, Int)
  CheckInFunctionScope(String)
  CheckInCoroutineScope(String)
  ReturnValue
}

pub enum BinaryOp {
  Add
  Sub
  Mul
  MatMul
  Div
  FloorDiv
  Mod
  Pow
  ShiftLeft
  ShiftRight
  BitAnd
  BitXor
  BitOr
} derive(ToJson)

pub enum BoolOp {
  And
  Or
} derive(ToJson)

pub struct BoundMethodValue {
  function : FunctionValue
  self : Value
} derive(ToJson)

pub struct ClassValue {
  name : String
  bases : Array[Value]
  dict : Array[(String, Value)]
} derive(ToJson)

pub struct CompClause {
  is_async : Bool
  targets : Array[String]
  target : Target
  iter : Expr
  filters : Array[Expr]
} derive(ToJson)

pub enum CompareOp {
  Eq
  NotEq
  Lt
  Lte
  Gt
  Gte
  In
  NotIn
  Is
  IsNot
} derive(ToJson)

pub struct Config {
  max_recursion : Int
  traceback_limit : Int
  track_spans : Bool
  bytecode_strict : Bool
  allow_filesystem_imports : Bool
  import_paths : Array[String]
  argv : Array[String]
  main_path : String?
} derive(ToJson)

pub struct ExceptHandler {
  span : Span
  is_star : Bool
  exc : Expr?
  name : String?
  body : Array[Stmt]
} derive(ToJson)

pub enum Expr {
  Literal(Literal)
  Name(String)
  Tuple(Array[Expr])
  List(Array[Expr])
  ListComp(elt~ : Expr, clauses~ : Array[CompClause], filters~ : Array[Expr])
  GenExp(elt~ : Expr, clauses~ : Array[CompClause], filters~ : Array[Expr])
  Dict(Array[(Expr, Expr)])
  DictComp(key~ : Expr, value~ : Expr, clauses~ : Array[CompClause], filters~ : Array[Expr])
  Set(Array[Expr])
  SetComp(elt~ : Expr, clauses~ : Array[CompClause], filters~ : Array[Expr])
  Lambda(params~ : Array[String], defaults~ : Array[Expr], body~ : Expr)
  IfExpr(condition~ : Expr, then_expr~ : Expr, else_expr~ : Expr)
  FString(String)
  NamedExpr(name~ : String, value~ : Expr)
  Yield(Expr?)
  YieldFrom(Expr)
  Await(Expr)
  Slice(start~ : Expr?, end~ : Expr?, step~ : Expr?)
  Attribute(value~ : Expr, attr~ : String)
  Subscript(value~ : Expr, index~ : Expr)
  Call(callee~ : Expr, args~ : Array[Expr])
  Keyword(name~ : String, value~ : Expr)
  Starred(value~ : Expr)
  DoubleStarred(value~ : Expr)
  Unary(op~ : UnaryOp, expr~ : Expr)
  Binary(op~ : BinaryOp, left~ : Expr, right~ : Expr)
  BoolOp(op~ : BoolOp, values~ : Array[Expr])
  Compare(left~ : Expr, ops~ : Array[CompareOp], comparators~ : Array[Expr])
  WithSpan(span~ : Span, expr~ : Expr)
} derive(ToJson)

pub struct FunctionValue {
  name : String
  params : Array[String]
  defaults : Array[Value]
  body : Array[Stmt]
  is_generator : Bool
  is_async : Bool
  closure : Array[(String, Value)]
} derive(ToJson)

pub(all) struct GenExpSpec {
  elt : Expr
  clauses : Array[CompClause]
  filters : Array[Expr]
}

pub struct InstanceValue {
  class : ClassValue
  dict : Array[(String, Value)]
} derive(ToJson)

pub struct Interpreter {
  config : Config
  globals : Array[(String, Value)]
  builtins : Array[(String, Value)]
  io : MockIO
}

pub enum Literal {
  None
  Bool(Bool)
  Int(
@moonbitlang/core/bigint.BigInt
BigInt)
  Float(Double)
  Complex(Double, Double)
  Str(String)
  Bytes(Array[Int])
} derive(ToJson)

pub struct MockIO {
  stdin : Array[String]
  stdin_pos : 
@moonbitlang/core/ref.Ref
Ref[Int]
  stdout : StringBuilder
  stderr : StringBuilder
}

pub struct Module {
  body : Array[Stmt]
} derive(ToJson)

pub(all) struct ParseError {
  kind : ParseErrorKind
  message : String
  span : Span
} derive(ToJson)

pub(all) enum ParseErrorKind {
  Syntax
  Indentation
  UnexpectedToken
  UnexpectedEof
} derive(ToJson)

pub enum Pattern {
  Wildcard
  Literal(Literal)
  Name(String)
  TypeCapture(type_name~ : String, name~ : String)
  Tuple(Array[Pattern])
} derive(ToJson)

pub struct RunResult {
  value : Value
  stdout : String
  stderr : String
  globals : Array[(String, Value)]
} derive(ToJson)

pub(all) struct RuntimeError {
  kind : RuntimeErrorKind
  message : String
  span : Span?
  traceback : Array[TracebackFrame]
  traceback_envs : Array[TracebackEnv]
  exc_type : String
  exc_args : Array[String]
  exc_value : Value?
  exc_cause : Value?
  exc_context : Value?
  exc_suppress_context : Bool
} derive(ToJson)

pub(all) enum RuntimeErrorKind {
  Name
  Type
  Attribute
  Index
  Key
  ZeroDivision
  NotImplemented
  Runtime
} derive(ToJson)

pub(all) struct Span {
  start : Int
  end : Int
  line : Int
  column : Int
} derive(ToJson)

pub enum Stmt {
  ExprStmt(Expr)
  Assign(target~ : Target, value~ : Expr)
  AnnAssign(target~ : Target, annotation~ : Expr, value~ : Expr?)
  AugAssign(target~ : Target, op~ : BinaryOp, value~ : Expr)
  TypeAlias(name~ : String, type_params~ : Array[String], value~ : Expr)
  Return(Expr?)
  Yield(Expr?)
  YieldFrom(Expr)
  If(condition~ : Expr, body~ : Array[Stmt], else_body~ : Array[Stmt])
  Match(subject~ : Expr, cases~ : Array[(Pattern, Expr?, Array[Stmt])])
  While(condition~ : Expr, body~ : Array[Stmt], else_body~ : Array[Stmt])
  For(target~ : Target, iter~ : Expr, body~ : Array[Stmt], else_body~ : Array[Stmt])
  AsyncFor(target~ : Target, iter~ : Expr, body~ : Array[Stmt], else_body~ : Array[Stmt])
  Break
  Continue
  Function(name~ : String, decorators~ : Array[Expr], type_params~ : Array[String], params~ : Array[String], defaults~ : Array[Expr], annotations~ : Array[(String, Expr)], return_annotation~ : Expr?, body~ : Array[Stmt], is_generator~ : Bool, is_async~ : Bool)
  Pass
  Global(Array[String])
  Nonlocal(Array[String])
  Assert(condition~ : Expr, message~ : Expr?)
  Raise(exc~ : Expr?, cause~ : Expr?)
  Del(Array[Target])
  Import(module_name~ : String, alias_name~ : String?)
  FromImport(module_name~ : String, names~ : Array[(String, String?)])
  With(context~ : Expr, target~ : String?, body~ : Array[Stmt])
  AsyncWith(context~ : Expr, target~ : String?, body~ : Array[Stmt])
  Try(body~ : Array[Stmt], handlers~ : Array[ExceptHandler], else_body~ : Array[Stmt], finally_body~ : Array[Stmt])
  Class(name~ : String, decorators~ : Array[Expr], type_params~ : Array[String], bases~ : Array[Expr], keywords~ : Array[(String, Expr)], body~ : Array[Stmt])
  WithSpan(span~ : Span, stmt~ : Stmt)
} derive(ToJson)

pub enum Target {
  Name(String)
  Tuple(Array[Target])
  List(Array[Target])
  Starred(Target)
  Attribute(value~ : Expr, attr~ : String)
  Subscript(value~ : Expr, index~ : Expr)
} derive(ToJson)

pub struct TestResult {
  passed : Int
  failed : Int
  errors : Array[String]
} derive(ToJson)

pub(all) struct TracebackEnv {
  locals : Array[(String, Value)]
  globals : Array[(String, Value)]
} derive(ToJson)

pub(all) struct TracebackFrame {
  name : String
  filename : String
  line : Int
  column : Int
  end_column : Int
} derive(ToJson)

pub enum UnaryOp {
  Pos
  Neg
  Not
  Invert
} derive(ToJson)

pub enum Value {
  None
  Bool(Bool)
  Int(
@moonbitlang/core/bigint.BigInt
BigInt)
  Float(Double)
  Complex(Double, Double)
  Str(String)
  Bytes(Array[Int])
  ByteArray(Array[Int])
  MemoryView(Array[Int])
  List(Array[Value])
  Tuple(Array[Value])
  Dict(Array[(Value, Value)])
  Set(Array[Value])
  Function(FunctionValue)
  Class(ClassValue)
  Instance(InstanceValue)
  BoundMethod(BoundMethodValue)
} derive(ToJson)

fn bc_disassemble(code : BcCode) -> String

fn bc_exec(code : BcCode, locals : Array[(String, Value)], globals : Array[(String, Value)], builtins : Array[(String, Value)], io : MockIO) -> Result[Value, RuntimeError]

fn bc_patch_jump(code : BcCode, pc : Int, target : Int) -> Unit

fn compile_module_to_bc(program : Module, filename : String) -> Result[BcCode, RuntimeError]

fn compile_stmts_to_bc(body : Array[Stmt], name : String, filename : String) -> Result[BcCode, RuntimeError]

fn compile_stmts_to_bc_with_future(body : Array[Stmt], name : String, filename : String, future_annotations : Bool) -> Result[BcCode, RuntimeError]

fn coroutine_await(coroutine_value : Value) -> Result[Value, RuntimeError]

fn coroutine_is_active() -> Bool

fn format_parse_error(error : ParseError) -> String

fn format_runtime_error(error : RuntimeError) -> String

fn format_runtime_error_with_traceback(error : RuntimeError, limit : Int) -> String