ASTNode Struct Reference

#include <ast.h>

Collaboration diagram for ASTNode:

Data Fields
NodeType	type
ASTNode *	next
int	line
char *	resolved_type
Type *	type_info
Token	token
Token	definition_token
union {
struct {
ASTNode *   children
}   root
struct {
char *   name
char *   generic_params
char *   args
char *   ret_type
ASTNode *   body
Type **   arg_types
char **   defaults
char **   param_names
int   arg_count
Type *   ret_type_info
int   is_varargs
int   is_inline
int   must_use
int   noinline
int   constructor
int   destructor
int   unused
int   weak
int   is_export
int   cold
int   hot
int   noreturn
int   pure
char *   section
int   is_async
int   is_comptime
int   cuda_global
int   cuda_device
int   cuda_host
char **   c_type_overrides
Attribute *   attributes
}   func
struct {
ASTNode *   statements
}   block
struct {
ASTNode *   value
}   ret
struct {
char *   name
char *   type_str
ASTNode *   init_expr
Type *   type_info
int   is_autofree
int   is_static
}   var_decl
struct {
char *   name
Type *   payload
int   tag_id
}   variant
struct {
char *   name
ASTNode *   variants
int   is_template
char *   generic_param
}   enm
struct {
char *   alias
char *   original_type
int   is_opaque
char *   defined_in_file
}   type_alias
struct {
ASTNode *   condition
ASTNode *   then_body
ASTNode *   else_body
}   if_stmt
struct {
ASTNode *   condition
ASTNode *   body
char *   loop_label
}   while_stmt
struct {
ASTNode *   init
ASTNode *   condition
ASTNode *   step
ASTNode *   body
char *   loop_label
}   for_stmt
struct {
char *   var_name
ASTNode *   start
ASTNode *   end
char *   step
int   is_inclusive
ASTNode *   body
}   for_range
struct {
ASTNode *   body
char *   loop_label
}   loop_stmt
struct {
char *   count
ASTNode *   body
}   repeat_stmt
struct {
ASTNode *   condition
ASTNode *   body
}   unless_stmt
struct {
ASTNode *   condition
ASTNode *   body
}   guard_stmt
struct {
ASTNode *   condition
ASTNode *   body
char *   loop_label
}   do_while_stmt
struct {
ASTNode *   expr
ASTNode *   cases
}   match_stmt
struct {
char *   pattern
char **   binding_names
int   binding_count
int *   binding_refs
int   is_destructuring
ASTNode *   guard
ASTNode *   body
int   is_default
}   match_case
struct {
char *   op
ASTNode *   left
ASTNode *   right
}   binary
struct {
char *   op
ASTNode *   operand
}   unary
struct {
LiteralKind   type_kind
unsigned long long   int_val
double   float_val
char *   string_val
}   literal
struct {
char *   name
char *   suggestion
}   var_ref
struct {
ASTNode *   callee
ASTNode *   args
char **   arg_names
int   arg_count
}   call
struct {
ASTNode *   target
char *   field
int   is_pointer_access
}   member
struct {
ASTNode *   array
ASTNode *   index
}   index
struct {
ASTNode *   array
ASTNode *   start
ASTNode *   end
}   slice
struct {
char *   target_type
ASTNode *   expr
}   cast
struct {
char *   struct_name
ASTNode *   fields
}   struct_init
struct {
ASTNode *   elements
int   count
}   array_literal
struct {
char *   name
ASTNode *   fields
int   is_template
char **   generic_params
int   generic_param_count
char *   parent
int   is_union
int   is_packed
int   align
int   is_incomplete
int   is_export
Attribute *   attributes
char **   used_structs
int   used_struct_count
int   is_opaque
char *   defined_in_file
}   strct
struct {
char *   name
char *   type
int   bit_width
}   field
struct {
char *   name
ASTNode *   methods
char **   generic_params
int   generic_param_count
}   trait
struct {
char *   struct_name
ASTNode *   methods
}   impl
struct {
char *   trait_name
char *   target_type
ASTNode *   methods
}   impl_trait
struct {
char *   path
int   is_system
}   include
struct {
char *   content
char **   used_symbols
int   used_symbol_count
}   raw_stmt
struct {
char *   name
ASTNode *   body
}   test_stmt
struct {
ASTNode *   condition
char *   message
}   assert_stmt
struct {
ASTNode *   stmt
}   defer_stmt
struct {
char *   plugin_name
char *   body
}   plugin_stmt
struct {
char **   names
int   count
ASTNode *   init_expr
int   is_struct_destruct
char *   struct_name
char **   field_names
int   is_guard
char *   guard_variant
ASTNode *   else_block
}   destruct
struct {
ASTNode *   cond
ASTNode *   true_expr
ASTNode *   false_expr
}   ternary
struct {
char *   code
int   is_volatile
char **   outputs
char **   output_modes
char **   inputs
char **   clobbers
int   num_outputs
int   num_inputs
int   num_clobbers
}   asm_stmt
struct {
char **   param_names
char **   param_types
char *   return_type
ASTNode *   body
int   num_params
int   lambda_id
int   is_expression
char **   captured_vars
char **   captured_types
int   num_captures
}   lambda
struct {
char *   target_type
ASTNode *   expr
}   size_of
struct {
char *   label_name
ASTNode *   goto_expr
}   goto_stmt
struct {
char *   label_name
}   label_stmt
struct {
char *   target_label
}   break_stmt
struct {
char *   target_label
}   continue_stmt
struct {
ASTNode *   expr
}   try_stmt
struct {
int   kind
Type *   target_type
}   reflection
struct {
ASTNode *   expr
}   repl_print
struct {
ASTNode *   call
ASTNode *   grid
ASTNode *   block
ASTNode *   shared_mem
ASTNode *   stream
}   cuda_launch
struct {
ASTNode *   ap
ASTNode *   last_arg
}   va_start
struct {
ASTNode *   ap
}   va_end
struct {
ASTNode *   dest
ASTNode *   src
}   va_copy
struct {
ASTNode *   ap
Type *   type_info
}   va_arg
};

Field Documentation

[union]

union { ... } ASTNode

alias

char* ASTNode::alias

align

int ASTNode::align

ap

ASTNode* ASTNode::ap

arg_count

int ASTNode::arg_count

arg_names

char** ASTNode::arg_names

arg_types

Type** ASTNode::arg_types

args [1/2]

char* ASTNode::args

args [2/2]

ASTNode* ASTNode::args

array

ASTNode* ASTNode::array

[struct]

struct { ... } ASTNode::array_literal

[struct]

struct { ... } ASTNode::asm_stmt

[struct]

struct { ... } ASTNode::assert_stmt

attributes

Attribute* ASTNode::attributes

[struct]

struct { ... } ASTNode::binary

binding_count

int ASTNode::binding_count

binding_names

char** ASTNode::binding_names

binding_refs

int* ASTNode::binding_refs

bit_width

int ASTNode::bit_width

[struct] [1/2]

struct { ... } ASTNode::block

block [2/2]

ASTNode* ASTNode::block

body [1/2]

ASTNode* ASTNode::body

body [2/2]

char* ASTNode::body

[struct]

struct { ... } ASTNode::break_stmt

c_type_overrides

char** ASTNode::c_type_overrides

[struct] [1/2]

struct { ... } ASTNode::call

call [2/2]

ASTNode* ASTNode::call

callee

ASTNode* ASTNode::callee

captured_types

char** ASTNode::captured_types

captured_vars

char** ASTNode::captured_vars

cases

ASTNode* ASTNode::cases

[struct]

struct { ... } ASTNode::cast

children

ASTNode* ASTNode::children

clobbers

char** ASTNode::clobbers

code

char* ASTNode::code

cold

int ASTNode::cold

cond

ASTNode* ASTNode::cond

condition

ASTNode* ASTNode::condition

constructor

int ASTNode::constructor

content

char* ASTNode::content

[struct]

struct { ... } ASTNode::continue_stmt

count [1/2]

char* ASTNode::count

count [2/2]

int ASTNode::count

cuda_device

int ASTNode::cuda_device

cuda_global

int ASTNode::cuda_global

cuda_host

int ASTNode::cuda_host

[struct]

struct { ... } ASTNode::cuda_launch

defaults

char** ASTNode::defaults

[struct]

struct { ... } ASTNode::defer_stmt

defined_in_file

char* ASTNode::defined_in_file

definition_token

Token ASTNode::definition_token

dest

ASTNode* ASTNode::dest

[struct]

struct { ... } ASTNode::destruct

destructor

int ASTNode::destructor

[struct]

struct { ... } ASTNode::do_while_stmt

elements

ASTNode* ASTNode::elements

else_block

ASTNode* ASTNode::else_block

else_body

ASTNode* ASTNode::else_body

end

ASTNode* ASTNode::end

[struct]

struct { ... } ASTNode::enm

expr

ASTNode* ASTNode::expr

false_expr

ASTNode* ASTNode::false_expr

field [1/2]

char* ASTNode::field

[struct] [2/2]

struct { ... } ASTNode::field

field_names

char** ASTNode::field_names

fields

ASTNode* ASTNode::fields

float_val

double ASTNode::float_val

[struct]

struct { ... } ASTNode::for_range

[struct]

struct { ... } ASTNode::for_stmt

[struct]

struct { ... } ASTNode::func

generic_param

char* ASTNode::generic_param

generic_param_count

int ASTNode::generic_param_count

generic_params [1/2]

char* ASTNode::generic_params

generic_params [2/2]

char** ASTNode::generic_params

goto_expr

ASTNode* ASTNode::goto_expr

[struct]

struct { ... } ASTNode::goto_stmt

grid

ASTNode* ASTNode::grid

guard

ASTNode* ASTNode::guard

[struct]

struct { ... } ASTNode::guard_stmt

guard_variant

char* ASTNode::guard_variant

hot

int ASTNode::hot

[struct]

struct { ... } ASTNode::if_stmt

[struct]

struct { ... } ASTNode::impl

[struct]

struct { ... } ASTNode::impl_trait

[struct]

struct { ... } ASTNode::include

index [1/2]

ASTNode* ASTNode::index

[struct] [2/2]

struct { ... } ASTNode::index

init

ASTNode* ASTNode::init

init_expr

ASTNode* ASTNode::init_expr

inputs

char** ASTNode::inputs

int_val

unsigned long long ASTNode::int_val

is_async

int ASTNode::is_async

is_autofree

int ASTNode::is_autofree

is_comptime

int ASTNode::is_comptime

is_default

int ASTNode::is_default

is_destructuring

int ASTNode::is_destructuring

is_export

int ASTNode::is_export

is_expression

int ASTNode::is_expression

is_guard

int ASTNode::is_guard

is_inclusive

int ASTNode::is_inclusive

is_incomplete

int ASTNode::is_incomplete

is_inline

int ASTNode::is_inline

is_opaque

int ASTNode::is_opaque

is_packed

int ASTNode::is_packed

is_pointer_access

int ASTNode::is_pointer_access

is_static

int ASTNode::is_static

is_struct_destruct

int ASTNode::is_struct_destruct

is_system

int ASTNode::is_system

is_template

int ASTNode::is_template

is_union

int ASTNode::is_union

is_varargs

int ASTNode::is_varargs

is_volatile

int ASTNode::is_volatile

kind

int ASTNode::kind

label_name

char* ASTNode::label_name

[struct]

struct { ... } ASTNode::label_stmt

[struct]

struct { ... } ASTNode::lambda

lambda_id

int ASTNode::lambda_id

last_arg

ASTNode* ASTNode::last_arg

left

ASTNode* ASTNode::left

line

int ASTNode::line

[struct]

struct { ... } ASTNode::literal

loop_label

char* ASTNode::loop_label

[struct]

struct { ... } ASTNode::loop_stmt

[struct]

struct { ... } ASTNode::match_case

[struct]

struct { ... } ASTNode::match_stmt

[struct]

struct { ... } ASTNode::member

message

char* ASTNode::message

methods

ASTNode* ASTNode::methods

must_use

int ASTNode::must_use

name

char* ASTNode::name

names

char** ASTNode::names

next

ASTNode* ASTNode::next

noinline

int ASTNode::noinline

noreturn

int ASTNode::noreturn

num_captures

int ASTNode::num_captures

num_clobbers

int ASTNode::num_clobbers

num_inputs

int ASTNode::num_inputs

num_outputs

int ASTNode::num_outputs

num_params

int ASTNode::num_params

op

char* ASTNode::op

operand

ASTNode* ASTNode::operand

original_type

char* ASTNode::original_type

output_modes

char** ASTNode::output_modes

outputs

char** ASTNode::outputs

param_names

char** ASTNode::param_names

param_types

char** ASTNode::param_types

parent

char* ASTNode::parent

path

char* ASTNode::path

pattern

char* ASTNode::pattern

payload

Type* ASTNode::payload

plugin_name

char* ASTNode::plugin_name

[struct]

struct { ... } ASTNode::plugin_stmt

pure

int ASTNode::pure

[struct]

struct { ... } ASTNode::raw_stmt

[struct]

struct { ... } ASTNode::reflection

[struct]

struct { ... } ASTNode::repeat_stmt

[struct]

struct { ... } ASTNode::repl_print

resolved_type

char* ASTNode::resolved_type

[struct]

struct { ... } ASTNode::ret

ret_type

char* ASTNode::ret_type

ret_type_info

Type* ASTNode::ret_type_info

return_type

char* ASTNode::return_type

right

ASTNode* ASTNode::right

[struct]

struct { ... } ASTNode::root

section

char* ASTNode::section

shared_mem

ASTNode* ASTNode::shared_mem

[struct]

struct { ... } ASTNode::size_of

[struct]

struct { ... } ASTNode::slice

src

ASTNode* ASTNode::src

start

ASTNode* ASTNode::start

statements

ASTNode* ASTNode::statements

step [1/2]

ASTNode* ASTNode::step

step [2/2]

char* ASTNode::step

stmt

ASTNode* ASTNode::stmt

[struct]

struct { ... } ASTNode::strct

stream

ASTNode* ASTNode::stream

string_val

char* ASTNode::string_val

[struct]

struct { ... } ASTNode::struct_init

struct_name

char* ASTNode::struct_name

suggestion

char* ASTNode::suggestion

tag_id

int ASTNode::tag_id

target

ASTNode* ASTNode::target

target_label

char* ASTNode::target_label

target_type [1/2]

char* ASTNode::target_type

target_type [2/2]

Type* ASTNode::target_type

[struct]

struct { ... } ASTNode::ternary

[struct]

struct { ... } ASTNode::test_stmt

then_body

ASTNode* ASTNode::then_body

token

Token ASTNode::token

[struct]

struct { ... } ASTNode::trait

trait_name

char* ASTNode::trait_name

true_expr

ASTNode* ASTNode::true_expr

[struct]

struct { ... } ASTNode::try_stmt

type [1/2]

NodeType ASTNode::type

type [2/2]

char* ASTNode::type

[struct]

struct { ... } ASTNode::type_alias

type_info

Type* ASTNode::type_info

type_kind

LiteralKind ASTNode::type_kind

type_str

char* ASTNode::type_str

[struct]

struct { ... } ASTNode::unary

[struct]

struct { ... } ASTNode::unless_stmt

unused

int ASTNode::unused

used_struct_count

int ASTNode::used_struct_count

used_structs

char** ASTNode::used_structs

used_symbol_count

int ASTNode::used_symbol_count

used_symbols

char** ASTNode::used_symbols

[struct]

struct { ... } ASTNode::va_arg

[struct]

struct { ... } ASTNode::va_copy

[struct]

struct { ... } ASTNode::va_end

[struct]

struct { ... } ASTNode::va_start

value

ASTNode* ASTNode::value

[struct]

struct { ... } ASTNode::var_decl

var_name

char* ASTNode::var_name

[struct]

struct { ... } ASTNode::var_ref

[struct]

struct { ... } ASTNode::variant

variants

ASTNode* ASTNode::variants

weak

int ASTNode::weak

[struct]

struct { ... } ASTNode::while_stmt

---

The documentation for this struct was generated from the following file:

• src/ast/ast.h