v2.ast #

fn StringInterFormat.from_u8(c u8) !StringInterFormat

fn StringLiteralKind.from_string_tinyv(s string) !StringLiteralKind

Todo: allow overriding this method in main v compilerthat is why this method was renamed from from_string

type Expr = ArrayInitExpr
	| AsCastExpr
	| AssocExpr
	| BasicLiteral
	| CallExpr
	| CallOrCastExpr
	| CastExpr
	| ComptimeExpr
	| EmptyExpr
	| FieldInit
	| FnLiteral
	| GenericArgOrIndexExpr
	| GenericArgs
	| Ident
	| IfExpr
	| IfGuardExpr
	| IndexExpr
	| InfixExpr
	| InitExpr
	| Keyword
	| KeywordOperator
	| LambdaExpr
	| LockExpr
	| MapInitExpr
	| MatchExpr
	| ModifierExpr
	| OrExpr
	| ParenExpr
	| PostfixExpr
	| PrefixExpr
	| RangeExpr
	| SelectExpr
	| SelectorExpr
	| SqlExpr
	| StringInterLiteral
	| StringLiteral
	| Tuple
	| Type
	| UnsafeExpr

fn (expr Expr) name() string

Todo: fix this, should be only what is needed

fn (expr Expr) pos() token.Pos

type Stmt = AsmStmt
	| AssertStmt
	| AssignStmt
	| BlockStmt
	| ComptimeStmt
	| ConstDecl
	| DeferStmt
	| Directive
	| EmptyStmt
	| EnumDecl
	| ExprStmt
	| FlowControlStmt
	| FnDecl
	| ForInStmt
	| ForStmt
	| GlobalDecl
	| ImportStmt
	| InterfaceDecl
	| LabelStmt
	| ModuleStmt
	| ReturnStmt
	| StructDecl
	| TypeDecl
	| []Attribute

Todo: decide if this going to be done like this (FieldInit)

type Type = AnonStructType
	| ArrayFixedType
	| ArrayType
	| ChannelType
	| FnType
	| GenericType
	| MapType
	| NilType
	| NoneType
	| OptionType
	| ResultType
	| ThreadType
	| TupleType

Todo: (re)implement nested sumtype like TS (was removed from v)currently need to cast to type in parser.type. Should I leave like this or add these directly to Expr until nesting is implemented?

fn (t Type) name() string

fn (attributes []Attribute) has(name string) bool

fn (exprs []Expr) name_list() string

enum Language {
	v
	c
	js
}

fn (lang Language) str() string

enum StringInterFormat {
	unformatted
	binary
	character
	decimal
	exponent
	exponent_short
	float
	hex
	octal
	pointer_address
	string
}

fn (sif StringInterFormat) str() string

enum StringLiteralKind {
	c
	js
	raw
	v
}

fn (s StringLiteralKind) str() string

struct AnonStructType {
pub:
	generic_params []Expr
	embedded       []Expr
	fields         []FieldDecl
}

pub fn (expr Expr) str() string { return match expr { Ident { expr.name } SelectorExpr { expr.lhs.str() + '.' + expr.rhs.name } else { 'missing Expr.str() for ${expr.type_name()}' // expr.str() } } }

struct ArrayFixedType {
pub:
	len       Expr
	elem_type Expr
}

struct ArrayInitExpr {
pub:
	typ   Expr = ast.empty_expr
	exprs []Expr
	init  Expr = ast.empty_expr
	cap   Expr = ast.empty_expr
	len   Expr = ast.empty_expr
	pos   token.Pos
}

Expressions

struct ArrayType {
pub:
	elem_type Expr
}

Type Nodes

struct AsCastExpr {
pub:
	expr Expr
	typ  Expr
	pos  token.Pos
}

struct AsmStmt {
pub:
	arch string
}

Statements

struct AssertStmt {
pub:
	expr  Expr
	extra Expr = ast.empty_expr
}

struct AssignStmt {
pub:
	op  token.Token
	lhs []Expr
	rhs []Expr
	pos token.Pos
}

struct AssocExpr {
pub:
	typ    Expr
	expr   Expr
	fields []FieldInit
}

struct Attribute {
pub:
	name          string
	value         Expr
	comptime_cond Expr
}

struct BasicLiteral {
pub:
	kind  token.Token
	value string
}

struct BlockStmt {
pub:
	stmts []Stmt
}

struct CallExpr {
pub:
	lhs  Expr
	args []Expr
	pos  token.Pos
}

struct CallOrCastExpr {
pub:
	lhs  Expr
	expr Expr
	pos  token.Pos
}

struct CastExpr {
pub:
	typ  Expr
	expr Expr
	pos  token.Pos
}

struct ChannelType {
pub:
	cap       Expr
	elem_type Expr
}

struct ComptimeExpr {
pub:
	expr Expr
	pos  token.Pos
}

struct ComptimeStmt {
pub:
	stmt Stmt
}

struct ConstDecl {
pub:
	is_public bool
	fields    []FieldInit
}

struct DeferStmt {
pub:
	stmts []Stmt
}

struct Directive {
pub:
	name  string
	value string
}

#flag / #include

struct EnumDecl {
pub:
	attributes []Attribute
	is_public  bool
	name       string
	as_type    Expr = ast.empty_expr
	fields     []FieldDecl
}

struct ExprStmt {
pub:
	expr Expr
}

struct FieldDecl {
pub:
	name       string
	typ        Expr = ast.empty_expr // can be empty as used for const (unless we use something else)
	value      Expr = ast.empty_expr
	attributes []Attribute
}

struct FieldInit {
pub:
	name  string
	value Expr
}

struct File {
pub:
	attributes []Attribute
	mod        string
	name       string
	stmts      []Stmt
	imports    []ImportStmt
}

File (AST container)

struct FlowControlStmt {
pub:
	op    token.Token
	label string
}

struct FnDecl {
pub:
	attributes []Attribute
	is_public  bool
	is_method  bool
	is_static  bool
	receiver   Parameter
	language   Language = .v
	name       string
	typ        FnType
	stmts      []Stmt
	pos        token.Pos
}

enum FnArributes { method static }

struct FnLiteral {
pub:
	typ           FnType
	captured_vars []Expr
	stmts         []Stmt
}

anon fn / closure

struct FnType {
pub:
	generic_params []Expr
	params         []Parameter
	return_type    Expr = ast.empty_expr
}

fn (ft &FnType) str() string

struct ForInStmt {
pub:
	// key   		 string
	// value 		 string
	// value_is_mut bool
	// expr	     Expr
	// TODO:
	key   Expr = ast.empty_expr
	value Expr
	expr  Expr
}

Note: used as the initializer for ForStmt

struct ForStmt {
pub:
	init  Stmt = ast.empty_stmt // initialization
	cond  Expr = ast.empty_expr // condition
	post  Stmt = ast.empty_stmt // post iteration (afterthought)
	stmts []Stmt
}

struct GenericArgOrIndexExpr {
pub:
	lhs  Expr
	expr Expr
}

struct GenericArgs {
pub:
	lhs  Expr
	args []Expr // concrete types
}

struct GenericType {
pub:
	name   Expr
	params []Expr
}

struct GlobalDecl {
pub:
	attributes []Attribute
	fields     []FieldDecl
}

struct Ident {
pub:
	pos  token.Pos
	name string
}

fn (ident &Ident) str() string

struct IfExpr {
pub:
	cond      Expr = ast.empty_expr
	else_expr Expr = ast.empty_expr
	stmts     []Stmt
}

struct IfGuardExpr {
pub:
	stmt AssignStmt
}

struct ImportStmt {
pub:
	name       string
	alias      string
	is_aliased bool
	symbols    []Expr
}

struct IndexExpr {
pub:
	lhs      Expr
	expr     Expr
	is_gated bool
}

struct InfixExpr {
pub:
	op  token.Token
	lhs Expr
	rhs Expr
	pos token.Pos
}

struct InitExpr {
pub:
	typ    Expr
	fields []FieldInit
}

struct InterfaceDecl {
pub:
	is_public      bool
	attributes     []Attribute
	name           string
	generic_params []Expr
	embedded       []Expr
	fields         []FieldDecl
}

struct Keyword {
pub:
	tok token.Token
}

struct KeywordOperator {
pub:
	op    token.Token
	exprs []Expr
}

struct LabelStmt {
pub:
	name string
	stmt Stmt = ast.empty_stmt
}

struct LambdaExpr {
pub:
	args []Ident
	expr Expr
}

struct LockExpr {
pub:
	lock_exprs  []Expr
	rlock_exprs []Expr
	stmts       []Stmt
}

struct MapInitExpr {
pub:
	typ  Expr = ast.empty_expr
	keys []Expr
	vals []Expr
	pos  token.Pos
}

struct MapType {
pub:
	key_type   Expr
	value_type Expr
}

struct MatchBranch {
pub:
	cond  []Expr
	stmts []Stmt
	pos   token.Pos
}

struct MatchExpr {
pub:
	expr     Expr
	branches []MatchBranch
	pos      token.Pos
}

fn (match_expr &MatchExpr) desugar() Expr

Note: this is just a very naive example of how it could possibly work.actual implementation may work during AST -> IR (or not). it may also need type information which we don't have here. as I said, just an example.

struct ModifierExpr {
pub:
	kind token.Token
	expr Expr
}

Todo: possibly merge modifiers into a bitfield wheremultiple modifiers are used. this could also be used for struct decl mut:, pub mut: etc. consider this [flag] pub enum Modifier { .atomic .global .mutable .public .shared .static .volatile }

struct ModuleStmt {
pub:
	name string
}

struct NilType {}

struct NoneType {}

struct OptionType {
pub:
	base_type Expr = ast.empty_expr
}

struct OrExpr {
pub:
	expr  Expr
	stmts []Stmt
	pos   token.Pos
}

pub fn (expr ModifierExpr) unwrap() Expr { return expr.expr }

fn (or_expr &OrExpr) desugar() Expr

struct Parameter {
pub:
	name   string
	typ    Expr
	is_mut bool
	pos    token.Pos
}

struct ParenExpr {
pub:
	expr Expr
}

struct PostfixExpr {
pub:
	op   token.Token
	expr Expr
}

struct PrefixExpr {
pub:
	op   token.Token
	expr Expr
	pos  token.Pos
}

struct RangeExpr {
pub:
	op    token.Token // `..` exclusive | `...` inclusive
	start Expr
	end   Expr
}

struct ResultType {
pub:
	base_type Expr = ast.empty_expr
}

struct ReturnStmt {
pub:
	exprs []Expr
}

struct SelectExpr {
pub:
	pos   token.Pos
	stmt  Stmt
	stmts []Stmt
	next  Expr = ast.empty_expr
}

struct SelectorExpr {
pub:
	lhs Expr
	rhs Ident
	pos token.Pos
}

fn (se SelectorExpr) leftmost() Expr

fn (se SelectorExpr) name() string

pub fn (expr Expr) str() string { return 'Expr.str() - $expr.type_name()' }

struct SqlExpr {
pub:
	expr Expr
}

struct StringInter {
pub:
	format    StringInterFormat
	width     int
	precision int
	expr      Expr
	// TEMP: prob removed once individual
	// fields are set, precision etc
	format_expr Expr = ast.empty_expr
}

struct StringInterLiteral {
pub:
	kind   StringLiteralKind
	values []string
	inters []StringInter
}

struct StringLiteral {
pub:
	kind  StringLiteralKind
	value string
}

Note: I'm using two nodes StringLiteral & StringInterLiteralto avoid the extra array allocations when not needed.

struct StructDecl {
pub:
	attributes     []Attribute
	is_public      bool
	embedded       []Expr
	language       Language = .v
	name           string
	generic_params []Expr
	fields         []FieldDecl
	pos            token.Pos
}

struct ThreadType {
pub:
	elem_type Expr = ast.empty_expr
}

struct Tuple {
pub:
	exprs []Expr
}

struct TupleType {
pub:
	types []Expr
}

struct TypeDecl {
pub:
	is_public      bool
	language       Language
	name           string
	generic_params []Expr
	base_type      Expr = ast.empty_expr
	variants       []Expr
}

struct UnsafeExpr {
pub:
	stmts []Stmt
}