v/vlib/v/ast/ast.v

710 lines
10 KiB
V
Raw Normal View History

2020-01-23 21:04:46 +01:00
// Copyright (c) 2019-2020 Alexander Medvednikov. All rights reserved.
2019-12-22 02:34:37 +01:00
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module ast
import (
v.token
v.table
2019-12-22 02:34:37 +01:00
)
pub type TypeDecl = AliasTypeDecl | SumTypeDecl | FnTypeDecl
pub type Expr = InfixExpr | IfExpr | StringLiteral | IntegerLiteral | CharLiteral |
FloatLiteral | Ident | CallExpr | BoolLiteral | StructInit | ArrayInit | SelectorExpr | PostfixExpr |
AssignExpr | PrefixExpr | MethodCallExpr | IndexExpr | RangeExpr | MatchExpr |
CastExpr | EnumVal | Assoc | SizeOf | None | MapInit | IfGuardExpr | ParExpr | OrExpr |
2020-03-21 07:01:06 +01:00
ConcatExpr | Type | AsCast | TypeOf | StringInterLiteral
2019-12-28 14:11:05 +01:00
pub type Stmt = GlobalDecl | FnDecl | Return | Module | Import | ExprStmt |
ForStmt | StructDecl | ForCStmt | ForInStmt | CompIf | ConstDecl | Attr | BranchStmt |
HashStmt | AssignStmt | EnumDecl | TypeDecl | DeferStmt | GotoLabel | GotoStmt |
LineComment | MultiLineComment | AssertStmt | UnsafeStmt | GoStmt
// pub type Type = StructType | ArrayType
// pub struct StructType {
// fields []Field
// }
// pub struct ArrayType {}
pub struct Type {
2020-03-02 10:53:38 +01:00
pub:
typ table.Type
2020-03-02 10:53:38 +01:00
}
2020-01-06 16:13:12 +01:00
// | IncDecStmt k
2019-12-28 14:11:05 +01:00
// Stand-alone expression in a statement list.
pub struct ExprStmt {
pub:
expr Expr
typ table.Type
2019-12-28 14:11:05 +01:00
}
2019-12-22 02:34:37 +01:00
2019-12-26 11:21:41 +01:00
pub struct IntegerLiteral {
pub:
val string
}
2019-12-24 18:54:43 +01:00
2019-12-27 10:03:29 +01:00
pub struct FloatLiteral {
pub:
2019-12-28 09:43:22 +01:00
// val f64
2019-12-27 10:03:29 +01:00
val string
}
2019-12-24 18:54:43 +01:00
pub struct StringLiteral {
pub:
val string
}
2019-12-22 02:34:37 +01:00
2020-03-21 07:01:06 +01:00
// 'name: $name'
pub struct StringInterLiteral {
pub:
vals []string
exprs []Expr
mut:
expr_types []table.Type
}
2020-02-04 09:54:15 +01:00
pub struct CharLiteral {
pub:
val string
}
pub struct BoolLiteral {
pub:
val bool
}
// `foo.bar`
pub struct SelectorExpr {
pub:
2020-03-07 04:45:35 +01:00
pos token.Position
expr Expr
field string
mut:
expr_type table.Type
}
2019-12-28 11:02:06 +01:00
// module declaration
pub struct Module {
pub:
2019-12-28 09:43:22 +01:00
name string
path string
expr Expr
}
pub struct Field {
pub:
name string
// type_idx int
mut:
typ table.Type
2020-02-17 22:50:04 +01:00
// typ2 Type
}
pub struct ConstDecl {
pub:
fields []Field
exprs []Expr
is_pub bool
}
pub struct StructDecl {
pub:
2020-02-22 14:13:19 +01:00
pos token.Position
name string
fields []Field
is_pub bool
mut_pos int // mut:
pub_pos int // pub:
pub_mut_pos int // pub mut:
is_c bool
}
pub struct StructInit {
pub:
2020-03-19 09:40:21 +01:00
pos token.Position
typ table.Type
fields []string
exprs []Expr
mut:
expr_types []table.Type
expected_types []table.Type
}
// import statement
pub struct Import {
pub:
pos token.Position
mod string
alias string
2019-12-31 19:42:16 +01:00
// expr Expr
}
2019-12-27 13:57:49 +01:00
pub struct FnDecl {
pub:
2020-03-05 16:13:14 +01:00
name string
stmts []Stmt
return_type table.Type
args []table.Arg
2020-03-05 16:13:14 +01:00
is_deprecated bool
is_pub bool
is_variadic bool
receiver Field
is_method bool
rec_mut bool // is receiver mutable
is_c bool
2020-03-06 16:31:40 +01:00
no_body bool // just a definition `fn C.malloc()`
2020-03-21 19:52:19 +01:00
pos token.Position
2019-12-29 07:24:17 +01:00
}
pub struct BranchStmt {
pub:
tok token.Token
}
2019-12-29 07:24:17 +01:00
pub struct CallExpr {
pub:
// tok token.Token
pos token.Position
mut:
// func Expr
name string
args []CallArg
is_c bool
muts []bool
or_block OrExpr
return_type table.Type
}
pub struct MethodCallExpr {
pub:
// tok token.Token
2020-03-10 23:21:26 +01:00
pos token.Position
expr Expr // `user` in `user.register()`
name string
args []CallArg
2020-03-10 23:21:26 +01:00
or_block OrExpr
mut:
2020-03-10 23:21:26 +01:00
expr_type table.Type // type of `user`
receiver_type table.Type // User
return_type table.Type
}
pub struct CallArg {
pub:
2020-03-15 00:46:08 +01:00
is_mut bool
expr Expr
mut:
typ table.Type
expected_type table.Type
2019-12-27 13:57:49 +01:00
}
pub struct Return {
pub:
2020-03-06 13:43:22 +01:00
pos token.Position
exprs []Expr
2020-03-16 07:42:45 +01:00
mut:
types []table.Type
2019-12-27 13:57:49 +01:00
}
2019-12-22 02:34:37 +01:00
/*
pub enum Expr {
Binary(InfixExpr)
2019-12-22 02:34:37 +01:00
If(IfExpr)
Integer(IntegerExpr)
}
*/
2019-12-24 18:54:43 +01:00
/*
2019-12-22 02:34:37 +01:00
pub struct Stmt {
pos int
//end int
}
2019-12-24 18:54:43 +01:00
*/
2019-12-28 09:43:22 +01:00
pub struct Var {
2019-12-24 18:54:43 +01:00
pub:
name string
expr Expr
is_mut bool
mut:
typ table.Type
pos token.Position
2019-12-24 18:54:43 +01:00
}
pub struct GlobalDecl {
pub:
name string
expr Expr
mut:
typ table.Type
}
2019-12-30 12:10:46 +01:00
pub struct File {
2019-12-24 18:54:43 +01:00
pub:
2020-02-17 22:50:04 +01:00
path string
mod Module
imports []Import
stmts []Stmt
scope &Scope
}
pub struct IdentFn {
pub mut:
typ table.Type
}
pub struct IdentVar {
pub mut:
2020-03-13 05:57:51 +01:00
typ table.Type
is_mut bool
is_static bool
is_optional bool
}
pub type IdentInfo = IdentFn | IdentVar
pub enum IdentKind {
unresolved
blank_ident
variable
constant
function
2019-12-24 18:54:43 +01:00
}
2019-12-28 14:11:05 +01:00
2019-12-22 02:34:37 +01:00
// A single identifier
2019-12-28 14:11:05 +01:00
pub struct Ident {
pub:
value string
is_c bool
tok_kind token.Kind
pos token.Position
mut:
name string
kind IdentKind
info IdentInfo
2019-12-22 02:34:37 +01:00
}
2020-02-07 14:49:14 +01:00
pub fn (i &Ident) var_info() IdentVar {
2020-02-06 17:38:02 +01:00
match i.info {
IdentVar {
return it
}
else {
// return IdentVar{}
panic('Ident.var_info(): info is not IdentVar variant')
}
}
}
pub struct InfixExpr {
2019-12-22 02:34:37 +01:00
pub:
2019-12-28 19:16:04 +01:00
// op BinaryOp
op token.Kind
pos token.Position
left Expr
right Expr
2020-03-07 04:45:35 +01:00
mut:
2020-03-07 00:34:14 +01:00
left_type table.Type
right_type table.Type
2019-12-22 02:34:37 +01:00
}
/*
// renamed to PrefixExpr
pub struct UnaryExpr {
pub:
// tok_kind token.Kind
2019-12-28 09:43:22 +01:00
// op BinaryOp
op token.Kind
2019-12-28 09:43:22 +01:00
left Expr
}
*/
2020-02-07 14:49:14 +01:00
2020-01-06 16:13:12 +01:00
pub struct PostfixExpr {
pub:
op token.Kind
expr Expr
2020-02-04 07:37:38 +01:00
pos token.Position
2020-01-06 16:13:12 +01:00
}
pub struct PrefixExpr {
pub:
op token.Kind
right Expr
}
2020-01-07 12:14:10 +01:00
pub struct IndexExpr {
pub:
// op token.Kind
pos token.Position
left Expr
index Expr // [0], [start..end] etc
mut:
container_type table.Type // array, map, fixed array
2020-01-07 12:14:10 +01:00
}
2019-12-28 19:16:04 +01:00
pub struct IfExpr {
pub:
tok_kind token.Kind
branches []IfBranch
left Expr // `a` in `a := if ...`
pos token.Position
mut:
is_expr bool
typ table.Type
has_else bool
}
pub struct IfBranch {
pub:
cond Expr
stmts []Stmt
pos token.Position
}
pub struct MatchExpr {
pub:
tok_kind token.Kind
cond Expr
branches []MatchBranch
pos token.Position
mut:
is_expr bool // returns a value
return_type table.Type
cond_type table.Type // type of `x` in `match x {`
expected_type table.Type // for debugging only
is_sum_type bool
}
2020-03-04 11:59:45 +01:00
pub struct MatchBranch {
pub:
exprs []Expr
stmts []Stmt
pos token.Position
}
pub struct CompIf {
pub:
2020-03-22 13:55:39 +01:00
// cond Expr
val string
stmts []Stmt
2020-03-22 11:53:08 +01:00
pos token.Position
mut:
else_stmts []Stmt
2019-12-22 02:34:37 +01:00
}
pub struct ForStmt {
pub:
2020-02-19 11:06:36 +01:00
cond Expr
stmts []Stmt
is_inf bool // `for {}`
pos token.Position
2020-01-07 00:14:19 +01:00
}
pub struct ForInStmt {
pub:
2020-03-21 10:22:16 +01:00
key_var string
val_var string
cond Expr
is_range bool
high Expr // `10` in `for i in 0..10 {`
stmts []Stmt
pos token.Position
mut:
element_type table.Type
kind table.Kind // array/map/string
2020-01-07 00:14:19 +01:00
}
pub struct ForCStmt {
pub:
init Stmt // i := 0;
has_init bool
cond Expr // i < 10;
2020-03-06 13:43:22 +01:00
// inc Stmt // i++;
inc Expr // i++;
stmts []Stmt
pos token.Position
}
2019-12-28 19:16:04 +01:00
pub struct ReturnStmt {
2020-03-18 15:39:26 +01:00
pub:
tok_kind token.Kind // or pos
2019-12-28 09:43:22 +01:00
results []Expr
pos token.Position
2019-12-22 02:34:37 +01:00
}
2020-02-04 09:54:15 +01:00
// #include etc
pub struct HashStmt {
pub:
2020-03-05 00:43:02 +01:00
val string
2020-02-04 09:54:15 +01:00
}
2020-02-10 14:42:57 +01:00
// filter(), map()
pub struct Lambda {
pub:
name string
}
2019-12-28 19:16:04 +01:00
pub struct AssignStmt {
pub:
2020-03-16 07:42:45 +01:00
left []Ident
right []Expr
op token.Kind
pos token.Position
mut:
left_types []table.Type
right_types []table.Type
2019-12-28 19:16:04 +01:00
}
2020-02-06 17:38:02 +01:00
pub struct AsCast {
pub:
2020-03-18 13:55:46 +01:00
expr Expr
typ table.Type
pos token.Position
2020-03-18 13:55:46 +01:00
mut:
expr_type table.Type
}
// e.g. `[unsafe_fn]`
pub struct Attr {
pub:
name string
}
2019-12-28 19:16:04 +01:00
pub struct EnumVal {
pub:
2020-02-25 15:02:34 +01:00
enum_name string
val string
2020-03-15 00:46:08 +01:00
mod string // for full path `mod_Enum_val`
2020-02-25 15:02:34 +01:00
pos token.Position
2020-03-15 02:51:31 +01:00
mut:
typ table.Type
}
pub struct EnumDecl {
pub:
name string
is_pub bool
vals []string
}
pub struct AliasTypeDecl {
pub:
2020-03-07 22:37:03 +01:00
name string
is_pub bool
parent_type table.Type
}
pub struct SumTypeDecl {
pub:
2020-03-07 22:37:03 +01:00
name string
is_pub bool
sub_types []table.Type
}
pub struct FnTypeDecl {
pub:
name string
is_pub bool
typ table.Type
}
2020-02-17 22:50:04 +01:00
pub struct DeferStmt {
2020-02-11 10:26:46 +01:00
pub:
2020-02-17 22:50:04 +01:00
stmts []Stmt
2020-02-11 10:26:46 +01:00
}
2020-02-26 20:45:03 +01:00
pub struct UnsafeStmt {
pub:
stmts []Stmt
}
2020-02-28 14:41:19 +01:00
// `(3+4)`
pub struct ParExpr {
pub:
expr Expr
}
2020-01-06 16:13:12 +01:00
pub struct AssignExpr {
pub:
2020-03-16 07:42:45 +01:00
op token.Kind
pos token.Position
left Expr
val Expr
mut:
2020-03-16 07:42:45 +01:00
left_type table.Type
right_type table.Type
2020-01-06 16:13:12 +01:00
}
pub struct GoStmt {
pub:
expr Expr
}
2020-02-17 22:50:04 +01:00
pub struct GotoLabel {
2020-02-17 14:15:42 +01:00
pub:
2020-02-17 22:50:04 +01:00
name string
2020-02-17 14:15:42 +01:00
}
pub struct GotoStmt {
pub:
2020-02-17 22:50:04 +01:00
name string
2020-02-17 14:15:42 +01:00
}
2019-12-30 09:38:12 +01:00
pub struct ArrayInit {
pub:
pos token.Position
exprs []Expr
mut:
2020-03-04 02:50:32 +01:00
elem_type table.Type
typ table.Type
2019-12-30 09:38:12 +01:00
}
2020-02-22 14:13:19 +01:00
pub struct MapInit {
pub:
2020-03-07 16:23:10 +01:00
pos token.Position
keys []Expr
vals []Expr
2020-02-22 14:13:19 +01:00
mut:
2020-03-07 16:23:10 +01:00
typ table.Type
2020-03-07 08:13:00 +01:00
key_type table.Type
value_type table.Type
2020-02-22 14:13:19 +01:00
}
2020-02-02 14:31:54 +01:00
// s[10..20]
pub struct RangeExpr {
pub:
2020-03-06 22:24:39 +01:00
low Expr
high Expr
has_high bool
has_low bool
2020-02-02 14:31:54 +01:00
}
pub struct CastExpr {
pub:
expr Expr // `buf`
arg Expr // `n` in `string(buf, n)`
typ table.Type // `string`
mut:
expr_type table.Type // `byteptr`
has_arg bool
}
pub struct AssertStmt {
pub:
expr Expr
}
// `if [x := opt()] {`
pub struct IfGuardExpr {
pub:
2020-03-17 16:40:41 +01:00
var_name string
expr Expr
mut:
expr_type table.Type
}
// `or { ... }`
pub struct OrExpr {
pub:
stmts []Stmt
// var_name string
// expr Expr
}
pub struct Assoc {
pub:
var_name string
fields []string
exprs []Expr
pos token.Position
2020-03-19 09:52:33 +01:00
mut:
typ table.Type
}
2020-02-18 18:13:34 +01:00
pub struct SizeOf {
pub:
typ table.Type
2020-02-18 18:13:34 +01:00
type_name string
}
2020-03-19 12:15:39 +01:00
pub struct TypeOf {
pub:
expr Expr
}
2020-02-18 20:20:15 +01:00
pub struct LineComment {
pub:
text string
}
pub struct MultiLineComment {
pub:
text string
}
2020-03-01 14:57:54 +01:00
pub struct ConcatExpr {
pub:
vals []Expr
}
2020-02-19 19:54:36 +01:00
pub struct None {
pub:
foo int // todo
}
/*
enum BinaryOp {
sum
difference
product
quotient
remainder
bitwise_and
bitwise_or
bitwise_xor
left_shift
right_shift
equality
inequality
less_than
less_than_or_equal
more_than
more_than_or_equal
in_check
//These are suffixed with `bool` to prevent conflict with the keyword `or`
and_bool
or_bool
}
*/
2020-03-18 01:19:23 +01:00
2020-03-18 01:19:23 +01:00
[inline]
pub fn expr_is_blank_ident(expr Expr) bool {
match expr {
Ident {
return it.kind == .blank_ident
}
else {
return false
}
}
}
[inline]
pub fn expr_is_call(expr Expr) bool {
return match expr {
CallExpr{
2020-03-18 01:19:23 +01:00
true
}
MethodCallExpr{
2020-03-18 01:19:23 +01:00
true
}
else {
false}
2020-03-18 01:19:23 +01:00
}
}