std/jule/sema ​

fn AnalyzePackage(mut files: []&ast::AST, mut importer: Importer, flags: Flag): (&Package, []build::Log)

fn AnalyzeFile(mut f: &ast::AST, mut importer: Importer, flags: Flag): (&SymTab, []build::Log)

struct EnumItem {
    Token: &token::Token
    Ident: str
    Value: &Value
}

struct Enum {
    Token:   &token::Token
    Public:  bool
    Ident:   str
    TypeSym: &TypeSym
    Items:   []&EnumItem
}

struct TypeEnumItem {
    Token:   &token::Token
    Ident:   str
    TypeSym: &TypeSym
}

struct TypeEnum {
    Token:  &token::Token
    Public: bool
    Ident:  str
    Items:  []&TypeEnumItem
}

struct Data {
    Type:      &Type
    Mutable:   bool
    Reference: bool
    Lvalue:    bool
    IsRune:    bool
    Model:     Expr

    // True if kind is declaration such as:
    //  - &Enum
    //  - &Struct
    //  - int type
    //  - bool type
    Decl: bool

    // Constant expression data.
    Constant: &constant::Const
}

struct Value {
    Expr: &ast::Expr
    Data: &Data
}

struct OperandExpr {
    Type:  &Type
    Model: Expr
}

struct BinaryExpr {
    Left:  &OperandExpr
    Right: &OperandExpr
    Op:    &token::Token
}

struct UnaryExpr {
    Expr:  Expr
    Op:    &token::Token
}

struct StructArgExpr {
    Field: &FieldIns
    Expr:  Expr
}

struct StructLitExpr {
    Token: &token::Token
    Strct: &StructIns
    Args:  []&StructArgExpr
}

struct AllocStructLitExpr {
    Lit: &StructLitExpr
}

struct CastingExpr {
    Token: &token::Token
    Expr:  &Data
    Type:  &Type
}

struct FnCallExpr {
    Token:    &token::Token
    Func:     &FnIns
    IsCo:     bool
    Expr:     Expr
    Args:     []Expr
    Except:   &Scope
    Assigned: bool
}

struct BuiltinErrorCallExpr {
    Func: &FnIns
    Err:  &Data
}

struct SliceExpr {
    ElemType: &Type
    Elems:    []Expr
}

struct IndexingExpr {
    Token: &token::Token
    Expr:  &Data
    Index: &Data
}

struct AnonFnExpr {
    Captured: []&Var
    Func:     &FnIns
    Global:   bool
}

struct KeyValPairExpr {
    Key: Expr
    Val: Expr
}

struct MapExpr {
    Kind:    &Map
    Entries: []&KeyValPairExpr
}

struct SlicingExpr {
    Token: &token::Token
    Expr:  Expr
    Left:  Expr
    Right: Expr
}

struct TraitSubIdentExpr {
    Token:  &token::Token
    Expr:   Expr
    Method: &Fn
    Trt:    &Trait
}

struct StructSubIdentExpr {
    Token:  &token::Token
    Expr:   &Data
    Method: &FnIns
    Field:  &FieldIns
    Owner:  &StructIns
}

struct ArrayExpr {
    Kind:  &Arr
    Elems: []Expr
}

struct TupleExpr {
    Datas: []&Data
}

struct BuiltinOutCallExpr {
    Expr:  Expr
}

struct BuiltinOutlnCallExpr {
    Expr:  Expr
}

struct BuiltinNewCallExpr {
    Type: &Type
    Init: Expr
}

struct BuiltinPanicCallExpr {
    Token: &token::Token
    Expr:  Expr
}

struct BuiltinMakeCallExpr {
    Type: &Type
    Size: Expr
}

struct BuiltinAppendCallExpr {
    Dest:     Expr
    Elements: Expr
}

struct BuiltinLenCallExpr {
    Expr: &Data
}

struct BuiltinCapCallExpr {
    Expr: &Data
}

struct BuiltinDeleteCallExpr {
    Dest: &Data
    Key:  &Data
}

struct SizeofExpr {
    Expr:  Expr
}

struct AlignofExpr {
    Expr:  Expr
}

struct StrConstructorCallExpr {
    Expr:  Expr
}

struct RuneExpr {
    Code: rune
}

struct BackendEmitExpr {
    Code: str
}

struct FreeExpr {
    Expr: Expr
}

struct RetType {
    TypeSym: &TypeSym
    Idents:  []&token::Token
    Named:   bool // Whether any return type uses name.
}

struct Param {
    Token:     &token::Token
    Mutable:   bool
    Variadic:  bool
    Reference: bool
    TypeSym:   &TypeSym
    Ident:     str
}

struct Fn {
    Token:       &token::Token
    Global:      bool
    Unsafety:    bool
    Public:      bool
    Binded:      bool
    Statically:  bool
    Exceptional: bool
    Ident:       str
    Directives:  []&ast::Directive
    Scope:       &ast::ScopeTree
    Generics:    []&ast::GenericDecl
    Result:      &RetType
    Params:      []&Param
    Owner:       &Struct

    // Function instances for each unique type combination of function call.
    // Nil if function is never used.
    Instances: []&FnIns
}

struct ParamIns {
    Decl: &Param
    Type: &Type
}

struct FnIns {
    Owner:    &StructIns
    Decl:     &Fn
    Generics: []&InsGeneric
    Params:   []&ParamIns
    Result:   &Type
    Scope:    &Scope
    Refers:   &ReferenceStack
    Anon:     bool
}

struct Impl {
    Base:    &TypeDecl
    Dest:    &TypeDecl
    Methods: []&Fn
    Statics: []&Var
}

struct ImportInfo {
    // Declaration.
	Decl: &ast::UseDecl

	// Absolute path.
	Path: str

	// Use declaration path string.
	// Quotes are not included.
	LinkPath: str

	// Package alias identifier.
	Alias: str

	// True if imported with Importer.GetImport function.
	Duplicate: bool

	// Is binded use declaration.
	Binded: bool

	// Is standard library package.
	Std: bool

	// Nil if package is cpp header.
	Package: &Package

	// Module identity.
	ModId: int
}

struct Package {
    Files: []&SymTab
}

struct Scope {
    Parent:   &Scope
    Unsafety: bool
    Deferred: bool
    Stmts:    []Stmt

    // Data of the child scope starting from the root scope.
    // For the root scope, counting starts from 0. So the root scope will be 0.
    // It increases by one for each child scope.
    ChildIndex: int

    // If the scope is a child scope,
    // it contains the data of the statement in which it was appear.
    StmtIndex: int
}

struct If {
    Expr:  Expr
    Scope: &Scope
}

struct Else {
    Scope: &Scope
}

struct Conditional {
    Elifs:   []&If
    Default: &Else
}

struct InfIter {
    Scope: &Scope
}

struct WhileIter {
    Expr:  Expr
    Next:  Stmt
    Scope: &Scope
}

struct RangeIter {
    Expr:  Expr
    Scope: &Scope
    KeyA:  &Var
    KeyB:  &Var
}

struct Contst {
    It: uintptr
}

struct Breakst {
    It:   uintptr
    Mtch: uintptr
}

struct Label {
    Ident: str
    Scope: &Scope // Owner scope.
    Index: int    // Index of statement.
}

struct GotoSt {
    Ident: str
    Token: &token::Token
    Label: &Label
    Scope: &Scope // Owner scope.
    Index: int    // Index of statement.
}

struct Postfix {
    Expr: Expr
    Op:   str
}

struct Assign {
    Left:  &OperandExpr
    Right: &OperandExpr
    Op:    &token::Token
}

struct MultiAssign {
    Decls: []&Var
    Left:  []&Data
    Right: Expr
    Op:    &token::Token
}

struct Match {
    Scope:     &Scope // Owner scope.
    Expr:      &Data
    TypeMatch: bool
    Comptime:  bool
    Cases:     []&Case
    Default:   &Case
}

struct Case {
    Owner: &Match
    Scope: &Scope
    Exprs: []&Data
    Next:  &Case
}

struct FallSt {
    DestCase: uintptr
}

struct RetSt {
    Func: &FnIns
    Vars: []&Var
    Expr: Expr
}

struct Recover {
    Handler:     &FnIns
    HandlerExpr: Expr
    Scope:       &Scope
    ScopeOwner:  &FnIns
}

struct ReferenceStack {}

struct Field {
    Owner:   &Struct
    Token:   &token::Token
    Public:  bool
    Mutable: bool
    Ident:   str
    TypeSym: &TypeSym
    Default: &ast::Expr
}

struct Struct {
    Depends:    []&Struct
    Uses:       []&Struct
    Token:      &token::Token::Token
    Ident:      str
    Fields:     []&Field
    Methods:    []&Fn
    Binded:     bool
    Directives: []&ast::Directive
    Generics:   []&ast::GenericDecl
    Implements: []&Trait
    Instances:  []&StructIns
}

struct FieldIns {
    Owner:   &StructIns
    Decl:    &Field
    Type:    &Type
    Default: &Data
}

struct StructIns {
    Checked:    bool
    Decl:       &Struct
    Generics:   []&InsGeneric
    Fields:     []&FieldIns
    Statics:    []&Var
    Methods:    []&Fn
    Mutable:    bool
    Comparable: bool
    Refers:     &ReferenceStack
}

struct Pass {
    Token: &token::Token::Token
    Text:  str
}

struct SymTab {
    File:         &token::Token::Fileset         // Owner fileset of this symbol table.
    Passes:       []Pass        // All passed flags with jule:pass directive.
    Imports:      []&ImportInfo // Imported packages.
    Vars:         []&Var        // Variables.
    TypeAliases:  []&TypeAlias  // Type aliases.
    Structs:      []&Struct     // Structures.
    Funcs:        []&Fn         // Functions.
    Traits:       []&Trait      // Traits.
    Enums:        []&Enum       // Enums.
    TypeEnums:    []&TypeEnum   // Type enums.
    Impls:        []&Impl       // Implementations.
}

struct Trait {
    Token:       &token::Token
    Ident:       str
    Public:      bool
    Mutable:     bool
    Methods:     []&Fn
    Inherits:    []&TypeSym
    Implemented: []&Struct
}

struct InsGeneric {
    Type:       &Type
    Constraint: []&Type
}

struct TypeAlias {
    Scope:    &ast::ScopeTree
    Public:   bool
    Binded:   bool
    Used:     bool
    Generic:  bool
    Token:    &token::Token
    Ident:    str
    TypeSym:  &TypeSym
    Refers:   []any
    Generics: []&TypeAlias
}

struct Type {
    CppIdent:  str
    Generic:   bool
    Variadic:  bool
    Kind:      Kind
}

struct TypeSym {
    Decl: &TypeDecl
    Type: &TypeDecl
}

struct Prim {
    Kind: str
}

struct Slc {
    Elem: &Type
}

struct Tuple {
    Types: []&Type
}

struct Map {
    Key: &Type
    Val: &Type
}

struct Arr {
    Elem: &Type
}

struct Ptr {
    Elem: &Type
}

struct Var {
    Scope:         &Scope
    Token:         &token::Token
    Ident:         str
    Binded:        bool
    Constant:      bool
    Mutable:       bool
    Public:        bool
    Used:          bool
    Statically:    bool
    Reference:     bool
    Checked:       bool
    TypeSym:       &TypeSym
    Value:         &Value
    Refers:        &ReferenceStack
    Directives:    []&ast::Directive

    // The -2 means this variable is not one of the return variables.
    // The -1 means this variable is just the single return variable one.
    // The 0..n means this variable is the nth variable of the return variables.
    RetOrder: int = -2

    // This variable depended to these variables for initialization expression.
    // Nil if not global variable.
    Depends: []&Var
}

struct FuncPattern {}

trait Lookup {
    // Select imported package.
    // Returns nil reference if did not found any match.
    fn SelectPackage(mut self, selector: fn(&ImportInfo): bool): &ImportInfo

    // Find variable by identifier and binded state.
    // Returns nil reference if did not found any match.
    fn FindVar(mut self, ident: str, binded: bool): &Var

    // Find type alias by identifier and binded state.
    // Returns nil reference if did not found any match.
    fn FindTypeAlias(mut self, ident: str, binded: bool): &TypeAlias

    // Find structure by identifier and binded state.
    // Returns nil reference if did not found any match.
    fn FindStruct(mut self, ident: str, binded: bool): &Struct

    // Find function by identifier and binded state.
    // Returns nil reference if did not found any match.
    fn FindFn(mut self, ident: str, binded: bool): &Fn

    // Find trait by identifier.
    // Returns nil reference if did not found any match.
    fn FindTrait(mut self, ident: str): &Trait

    // Find enum by identifier.
    // Returns nil reference if did not found any match.
    fn FindEnum(mut self, ident: str): &Enum

    // Find type enum by identifier.
    // Returns nil reference if did not found any match.
    fn FindTypeEnum(mut self, ident: str): &TypeEnum
}

trait Importer {
    // Set current module path.
    // Path should be valid directory.
    // Set to empty string if module is not exist.
    fn SetModPath(mut self, path: str)
    // Returns current module path.
    // Path should be valid directory.
    // Returns empty string if module is not exist.
    fn GetModPath(self): str
    // Returns module path by identity.
    fn ModById(self, id: int): str
    // Returns &ImportInfo by path.
    // This function accepted as returns already imported and checked package.
    // If returns not-nil value, will be used instead of ImportPackage
    // if possible and package content is not checked by Sema.
    fn GetImport(mut self, path: str): &ImportInfo
    // Path is the directory path of package to import.
    // Should return abstract syntax tree of package files.
    // Logs accepts as error.
    // Updated module to package's module if exist when updateMod is true.
    fn ImportPackage(mut self, path: str, updateMod: bool): ([]&AST, []Log)
    // Invoked after the package is imported.
    // Sets module identitity of imported package to current module.
    fn imported(mut self, mut &ImportInfo)
}

trait Kind {
    fn Str(self): str
    fn Equal(&self, other: &Type): bool
}

enum Flag

enum Stmt: type

enum Expr: type