ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-08-05 15:18:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1476 from odin-lang/odin-ast-changes

Browse Source 
Replace `any` with `union` for subtyping in `core:odin/ast`
This commit is contained in:
gingerBill
2022-03-04 10:39:38 +00:00
committed by GitHub
parent bee475c38a 1abd95094d
commit 2e8f2e6dbc
6 changed files with 603 additions and 348 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/odin/ast/ast.odin
+173 -2
View File
@@ -34,7 +34,7 @@ Node :: struct {
pos: tokenizer.Pos, pos: tokenizer.Pos,
end: tokenizer.Pos, end: tokenizer.Pos,
state_flags: Node_State_Flags, state_flags: Node_State_Flags,
derived: any, derived: Any_Node,
} }
Comment_Group :: struct { Comment_Group :: struct {
@@ -88,9 +88,11 @@ File :: struct {
Expr :: struct { Expr :: struct {
using expr_base: Node, using expr_base: Node,
derived_expr: Any_Expr,
} }
Stmt :: struct { Stmt :: struct {
using stmt_base: Node, using stmt_base: Node,
derived_stmt: Any_Stmt,
} }
Decl :: struct { Decl :: struct {
using decl_base: Stmt, using decl_base: Stmt,
@@ -541,7 +543,7 @@ unparen_expr :: proc(expr: ^Expr) -> (val: ^Expr) {
return return
} }
for { for {
e, ok := val.derived.(Paren_Expr) e, ok := val.derived.(^Paren_Expr)
if !ok || e.expr == nil { if !ok || e.expr == nil {
break break
} }
@@ -759,3 +761,172 @@ Matrix_Type :: struct {
column_count: ^Expr, column_count: ^Expr,
elem: ^Expr, elem: ^Expr,
} }
Any_Node :: union {
^Package,
^File,
^Comment_Group,
^Bad_Expr,
^Ident,
^Implicit,
^Undef,
^Basic_Lit,
^Basic_Directive,
^Ellipsis,
^Proc_Lit,
^Comp_Lit,
^Tag_Expr,
^Unary_Expr,
^Binary_Expr,
^Paren_Expr,
^Selector_Expr,
^Implicit_Selector_Expr,
^Selector_Call_Expr,
^Index_Expr,
^Deref_Expr,
^Slice_Expr,
^Matrix_Index_Expr,
^Call_Expr,
^Field_Value,
^Ternary_If_Expr,
^Ternary_When_Expr,
^Or_Else_Expr,
^Or_Return_Expr,
^Type_Assertion,
^Type_Cast,
^Auto_Cast,
^Inline_Asm_Expr,
^Proc_Group,
^Typeid_Type,
^Helper_Type,
^Distinct_Type,
^Poly_Type,
^Proc_Type,
^Pointer_Type,
^Multi_Pointer_Type,
^Array_Type,
^Dynamic_Array_Type,
^Struct_Type,
^Union_Type,
^Enum_Type,
^Bit_Set_Type,
^Map_Type,
^Relative_Type,
^Matrix_Type,
^Bad_Stmt,
^Empty_Stmt,
^Expr_Stmt,
^Tag_Stmt,
^Assign_Stmt,
^Block_Stmt,
^If_Stmt,
^When_Stmt,
^Return_Stmt,
^Defer_Stmt,
^For_Stmt,
^Range_Stmt,
^Inline_Range_Stmt,
^Case_Clause,
^Switch_Stmt,
^Type_Switch_Stmt,
^Branch_Stmt,
^Using_Stmt,
^Bad_Decl,
^Value_Decl,
^Package_Decl,
^Import_Decl,
^Foreign_Block_Decl,
^Foreign_Import_Decl,
^Attribute,
^Field,
^Field_List,
}
Any_Expr :: union {
^Bad_Expr,
^Ident,
^Implicit,
^Undef,
^Basic_Lit,
^Basic_Directive,
^Ellipsis,
^Proc_Lit,
^Comp_Lit,
^Tag_Expr,
^Unary_Expr,
^Binary_Expr,
^Paren_Expr,
^Selector_Expr,
^Implicit_Selector_Expr,
^Selector_Call_Expr,
^Index_Expr,
^Deref_Expr,
^Slice_Expr,
^Matrix_Index_Expr,
^Call_Expr,
^Field_Value,
^Ternary_If_Expr,
^Ternary_When_Expr,
^Or_Else_Expr,
^Or_Return_Expr,
^Type_Assertion,
^Type_Cast,
^Auto_Cast,
^Inline_Asm_Expr,
^Proc_Group,
^Typeid_Type,
^Helper_Type,
^Distinct_Type,
^Poly_Type,
^Proc_Type,
^Pointer_Type,
^Multi_Pointer_Type,
^Array_Type,
^Dynamic_Array_Type,
^Struct_Type,
^Union_Type,
^Enum_Type,
^Bit_Set_Type,
^Map_Type,
^Relative_Type,
^Matrix_Type,
}
Any_Stmt :: union {
^Bad_Stmt,
^Empty_Stmt,
^Expr_Stmt,
^Tag_Stmt,
^Assign_Stmt,
^Block_Stmt,
^If_Stmt,
^When_Stmt,
^Return_Stmt,
^Defer_Stmt,
^For_Stmt,
^Range_Stmt,
^Inline_Range_Stmt,
^Case_Clause,
^Switch_Stmt,
^Type_Switch_Stmt,
^Branch_Stmt,
^Using_Stmt,
^Bad_Decl,
^Value_Decl,
^Package_Decl,
^Import_Decl,
^Foreign_Block_Decl,
^Foreign_Import_Decl,
}
core/odin/ast/clone.odin
+117 -83
View File
@@ -1,16 +1,25 @@
package odin_ast package odin_ast
import "core:intrinsics"
import "core:mem" import "core:mem"
import "core:fmt" import "core:fmt"
import "core:reflect"
import "core:odin/tokenizer" import "core:odin/tokenizer"
_ :: intrinsics
new :: proc($T: typeid, pos, end: tokenizer.Pos) -> ^T { new :: proc($T: typeid, pos, end: tokenizer.Pos) -> ^T {
n, _ := mem.new(T) n, _ := mem.new(T)
n.pos = pos n.pos = pos
n.end = end n.end = end
n.derived = n^ n.derived = n
base: ^Node = n // dummy check base: ^Node = n // dummy check
_ = base // "Use" type to make -vet happy _ = base // "Use" type to make -vet happy
when intrinsics.type_has_field(T, "derived_expr") {
n.derived_expr = n
}
when intrinsics.type_has_field(T, "derived_stmt") {
n.derived_stmt = n
}
return n return n
} }
@@ -59,232 +68,257 @@ clone_node :: proc(node: ^Node) -> ^Node {
return nil return nil
} }
size := size_of(Node) size := size_of(Node)
align := align_of(Node) align := align_of(Node)
ti := type_info_of(node.derived.id) ti := reflect.union_variant_type_info(node.derived)
if ti != nil { if ti != nil {
size = ti.size elem := ti.variant.(reflect.Type_Info_Pointer).elem
align = ti.align size = elem.size
align = elem.align
} }
switch in node.derived { #partial switch in node.derived {
case Package, File: case ^Package, ^File:
panic("Cannot clone this node type") panic("Cannot clone this node type")
} }
res := cast(^Node)mem.alloc(size, align) res := cast(^Node)mem.alloc(size, align)
src: rawptr = node src: rawptr = node
if node.derived != nil { if node.derived != nil {
src = node.derived.data src = (^rawptr)(&node.derived)^
} }
mem.copy(res, src, size) mem.copy(res, src, size)
res.derived.data = rawptr(res) res_ptr_any: any
res.derived.id = node.derived.id res_ptr_any.data = &res
res_ptr_any.id = ti.id
switch r in &res.derived { reflect.set_union_value(res.derived, res_ptr_any)
case Bad_Expr:
case Ident:
case Implicit:
case Undef:
case Basic_Lit:
case Ellipsis: res_ptr := reflect.deref(res_ptr_any)
if de := reflect.struct_field_value_by_name(res_ptr, "derived_expr", true); de != nil {
reflect.set_union_value(de, res_ptr_any)
}
if ds := reflect.struct_field_value_by_name(res_ptr, "derived_stmt", true); ds != nil {
reflect.set_union_value(ds, res_ptr_any)
}
if res.derived != nil do switch r in res.derived {
case ^Package, ^File:
case ^Bad_Expr:
case ^Ident:
case ^Implicit:
case ^Undef:
case ^Basic_Lit:
case ^Basic_Directive:
case ^Comment_Group:
case ^Ellipsis:
r.expr = clone(r.expr) r.expr = clone(r.expr)
case Proc_Lit: case ^Proc_Lit:
r.type = auto_cast clone(r.type) r.type = auto_cast clone(r.type)
r.body = clone(r.body) r.body = clone(r.body)
case Comp_Lit: case ^Comp_Lit:
r.type = clone(r.type) r.type = clone(r.type)
r.elems = clone(r.elems) r.elems = clone(r.elems)
case Tag_Expr: case ^Tag_Expr:
r.expr = clone(r.expr) r.expr = clone(r.expr)
case Unary_Expr: case ^Unary_Expr:
r.expr = clone(r.expr) r.expr = clone(r.expr)
case Binary_Expr: case ^Binary_Expr:
r.left = clone(r.left) r.left = clone(r.left)
r.right = clone(r.right) r.right = clone(r.right)
case Paren_Expr: case ^Paren_Expr:
r.expr = clone(r.expr) r.expr = clone(r.expr)
case Selector_Expr: case ^Selector_Expr:
r.expr = clone(r.expr) r.expr = clone(r.expr)
r.field = auto_cast clone(r.field) r.field = auto_cast clone(r.field)
case Implicit_Selector_Expr: case ^Implicit_Selector_Expr:
r.field = auto_cast clone(r.field) r.field = auto_cast clone(r.field)
case Selector_Call_Expr: case ^Selector_Call_Expr:
r.expr = clone(r.expr) r.expr = clone(r.expr)
r.call = auto_cast clone(r.call) r.call = auto_cast clone(r.call)
case Index_Expr: case ^Index_Expr:
r.expr = clone(r.expr) r.expr = clone(r.expr)
r.index = clone(r.index) r.index = clone(r.index)
case Matrix_Index_Expr: case ^Matrix_Index_Expr:
r.expr = clone(r.expr) r.expr = clone(r.expr)
r.row_index = clone(r.row_index) r.row_index = clone(r.row_index)
r.column_index = clone(r.column_index) r.column_index = clone(r.column_index)
case Deref_Expr: case ^Deref_Expr:
r.expr = clone(r.expr) r.expr = clone(r.expr)
case Slice_Expr: case ^Slice_Expr:
r.expr = clone(r.expr) r.expr = clone(r.expr)
r.low = clone(r.low) r.low = clone(r.low)
r.high = clone(r.high) r.high = clone(r.high)
case Call_Expr: case ^Call_Expr:
r.expr = clone(r.expr) r.expr = clone(r.expr)
r.args = clone(r.args) r.args = clone(r.args)
case Field_Value: case ^Field_Value:
r.field = clone(r.field) r.field = clone(r.field)
r.value = clone(r.value) r.value = clone(r.value)
case Ternary_If_Expr: case ^Ternary_If_Expr:
r.x = clone(r.x) r.x = clone(r.x)
r.cond = clone(r.cond) r.cond = clone(r.cond)
r.y = clone(r.y) r.y = clone(r.y)
case Ternary_When_Expr: case ^Ternary_When_Expr:
r.x = clone(r.x) r.x = clone(r.x)
r.cond = clone(r.cond) r.cond = clone(r.cond)
r.y = clone(r.y) r.y = clone(r.y)
case Or_Else_Expr: case ^Or_Else_Expr:
r.x = clone(r.x) r.x = clone(r.x)
r.y = clone(r.y) r.y = clone(r.y)
case Or_Return_Expr: case ^Or_Return_Expr:
r.expr = clone(r.expr) r.expr = clone(r.expr)
case Type_Assertion: case ^Type_Assertion:
r.expr = clone(r.expr) r.expr = clone(r.expr)
r.type = clone(r.type) r.type = clone(r.type)
case Type_Cast: case ^Type_Cast:
r.type = clone(r.type) r.type = clone(r.type)
r.expr = clone(r.expr) r.expr = clone(r.expr)
case Auto_Cast: case ^Auto_Cast:
r.expr = clone(r.expr) r.expr = clone(r.expr)
case Inline_Asm_Expr: case ^Inline_Asm_Expr:
r.param_types = clone(r.param_types) r.param_types = clone(r.param_types)
r.return_type = clone(r.return_type) r.return_type = clone(r.return_type)
r.constraints_string = clone(r.constraints_string) r.constraints_string = clone(r.constraints_string)
r.asm_string = clone(r.asm_string) r.asm_string = clone(r.asm_string)
case Bad_Stmt: case ^Bad_Stmt:
// empty // empty
case Empty_Stmt: case ^Empty_Stmt:
// empty // empty
case Expr_Stmt: case ^Expr_Stmt:
r.expr = clone(r.expr) r.expr = clone(r.expr)
case Tag_Stmt: case ^Tag_Stmt:
r.stmt = clone(r.stmt) r.stmt = clone(r.stmt)
case Assign_Stmt: case ^Assign_Stmt:
r.lhs = clone(r.lhs) r.lhs = clone(r.lhs)
r.rhs = clone(r.rhs) r.rhs = clone(r.rhs)
case Block_Stmt: case ^Block_Stmt:
r.label = clone(r.label) r.label = clone(r.label)
r.stmts = clone(r.stmts) r.stmts = clone(r.stmts)
case If_Stmt: case ^If_Stmt:
r.label = clone(r.label) r.label = clone(r.label)
r.init = clone(r.init) r.init = clone(r.init)
r.cond = clone(r.cond) r.cond = clone(r.cond)
r.body = clone(r.body) r.body = clone(r.body)
r.else_stmt = clone(r.else_stmt) r.else_stmt = clone(r.else_stmt)
case When_Stmt: case ^When_Stmt:
r.cond = clone(r.cond) r.cond = clone(r.cond)
r.body = clone(r.body) r.body = clone(r.body)
r.else_stmt = clone(r.else_stmt) r.else_stmt = clone(r.else_stmt)
case Return_Stmt: case ^Return_Stmt:
r.results = clone(r.results) r.results = clone(r.results)
case Defer_Stmt: case ^Defer_Stmt:
r.stmt = clone(r.stmt) r.stmt = clone(r.stmt)
case For_Stmt: case ^For_Stmt:
r.label = clone(r.label) r.label = clone(r.label)
r.init = clone(r.init) r.init = clone(r.init)
r.cond = clone(r.cond) r.cond = clone(r.cond)
r.post = clone(r.post) r.post = clone(r.post)
r.body = clone(r.body) r.body = clone(r.body)
case Range_Stmt: case ^Range_Stmt:
r.label = clone(r.label) r.label = clone(r.label)
r.vals = clone(r.vals) r.vals = clone(r.vals)
r.expr = clone(r.expr) r.expr = clone(r.expr)
r.body = clone(r.body) r.body = clone(r.body)
case Case_Clause: case ^Inline_Range_Stmt:
r.label = clone(r.label)
r.val0 = clone(r.val0)
r.val1 = clone(r.val1)
r.expr = clone(r.expr)
r.body = clone(r.body)
case ^Case_Clause:
r.list = clone(r.list) r.list = clone(r.list)
r.body = clone(r.body) r.body = clone(r.body)
case Switch_Stmt: case ^Switch_Stmt:
r.label = clone(r.label) r.label = clone(r.label)
r.init = clone(r.init) r.init = clone(r.init)
r.cond = clone(r.cond) r.cond = clone(r.cond)
r.body = clone(r.body) r.body = clone(r.body)
case Type_Switch_Stmt: case ^Type_Switch_Stmt:
r.label = clone(r.label) r.label = clone(r.label)
r.tag = clone(r.tag) r.tag = clone(r.tag)
r.expr = clone(r.expr) r.expr = clone(r.expr)
r.body = clone(r.body) r.body = clone(r.body)
case Branch_Stmt: case ^Branch_Stmt:
r.label = auto_cast clone(r.label) r.label = auto_cast clone(r.label)
case Using_Stmt: case ^Using_Stmt:
r.list = clone(r.list) r.list = clone(r.list)
case Bad_Decl: case ^Bad_Decl:
case Value_Decl: case ^Value_Decl:
r.attributes = clone(r.attributes) r.attributes = clone(r.attributes)
r.names = clone(r.names) r.names = clone(r.names)
r.type = clone(r.type) r.type = clone(r.type)
r.values = clone(r.values) r.values = clone(r.values)
case Package_Decl: case ^Package_Decl:
case Import_Decl: case ^Import_Decl:
case Foreign_Block_Decl: case ^Foreign_Block_Decl:
r.attributes = clone(r.attributes) r.attributes = clone(r.attributes)
r.foreign_library = clone(r.foreign_library) r.foreign_library = clone(r.foreign_library)
r.body = clone(r.body) r.body = clone(r.body)
case Foreign_Import_Decl: case ^Foreign_Import_Decl:
r.name = auto_cast clone(r.name) r.name = auto_cast clone(r.name)
case Proc_Group: case ^Proc_Group:
r.args = clone(r.args) r.args = clone(r.args)
case Attribute: case ^Attribute:
r.elems = clone(r.elems) r.elems = clone(r.elems)
case Field: case ^Field:
r.names = clone(r.names) r.names = clone(r.names)
r.type = clone(r.type) r.type = clone(r.type)
r.default_value = clone(r.default_value) r.default_value = clone(r.default_value)
case Field_List: case ^Field_List:
r.list = clone(r.list) r.list = clone(r.list)
case Typeid_Type: case ^Typeid_Type:
r.specialization = clone(r.specialization) r.specialization = clone(r.specialization)
case Helper_Type: case ^Helper_Type:
r.type = clone(r.type) r.type = clone(r.type)
case Distinct_Type: case ^Distinct_Type:
r.type = clone(r.type) r.type = clone(r.type)
case Poly_Type: case ^Poly_Type:
r.type = auto_cast clone(r.type) r.type = auto_cast clone(r.type)
r.specialization = clone(r.specialization) r.specialization = clone(r.specialization)
case Proc_Type: case ^Proc_Type:
r.params = auto_cast clone(r.params) r.params = auto_cast clone(r.params)
r.results = auto_cast clone(r.results) r.results = auto_cast clone(r.results)
case Pointer_Type: case ^Pointer_Type:
r.elem = clone(r.elem) r.elem = clone(r.elem)
case Multi_Pointer_Type: case ^Multi_Pointer_Type:
r.elem = clone(r.elem) r.elem = clone(r.elem)
case Array_Type: case ^Array_Type:
r.len = clone(r.len) r.len = clone(r.len)
r.elem = clone(r.elem) r.elem = clone(r.elem)
case Dynamic_Array_Type: case ^Dynamic_Array_Type:
r.elem = clone(r.elem) r.elem = clone(r.elem)
case Struct_Type: case ^Struct_Type:
r.poly_params = auto_cast clone(r.poly_params) r.poly_params = auto_cast clone(r.poly_params)
r.align = clone(r.align) r.align = clone(r.align)
r.fields = auto_cast clone(r.fields) r.fields = auto_cast clone(r.fields)
case Union_Type: case ^Union_Type:
r.poly_params = auto_cast clone(r.poly_params) r.poly_params = auto_cast clone(r.poly_params)
r.align = clone(r.align) r.align = clone(r.align)
r.variants = clone(r.variants) r.variants = clone(r.variants)
case Enum_Type: case ^Enum_Type:
r.base_type = clone(r.base_type) r.base_type = clone(r.base_type)
r.fields = clone(r.fields) r.fields = clone(r.fields)
case Bit_Set_Type: case ^Bit_Set_Type:
r.elem = clone(r.elem) r.elem = clone(r.elem)
r.underlying = clone(r.underlying) r.underlying = clone(r.underlying)
case Map_Type: case ^Map_Type:
r.key = clone(r.key) r.key = clone(r.key)
r.value = clone(r.value) r.value = clone(r.value)
case Matrix_Type: case ^Matrix_Type:
r.row_count = clone(r.row_count) r.row_count = clone(r.row_count)
r.column_count = clone(r.column_count) r.column_count = clone(r.column_count)
r.elem = clone(r.elem) r.elem = clone(r.elem)
case ^Relative_Type:
r.tag = clone(r.tag)
r.type = clone(r.type)
case: case:
fmt.panicf("Unhandled node kind: %T", r) fmt.panicf("Unhandled node kind: %v", r)
} }
return res return res
core/odin/ast/walk.odin
+77 -77
View File
@@ -59,64 +59,64 @@ walk :: proc(v: ^Visitor, node: ^Node) {
} }
switch n in &node.derived { switch n in &node.derived {
case File: case ^File:
if n.docs != nil { if n.docs != nil {
walk(v, n.docs) walk(v, n.docs)
} }
walk_stmt_list(v, n.decls[:]) walk_stmt_list(v, n.decls[:])
case Package: case ^Package:
for _, f in n.files { for _, f in n.files {
walk(v, f) walk(v, f)
} }
case Comment_Group: case ^Comment_Group:
// empty // empty
case Bad_Expr: case ^Bad_Expr:
case Ident: case ^Ident:
case Implicit: case ^Implicit:
case Undef: case ^Undef:
case Basic_Lit: case ^Basic_Lit:
case Basic_Directive: case ^Basic_Directive:
case Ellipsis: case ^Ellipsis:
if n.expr != nil { if n.expr != nil {
walk(v, n.expr) walk(v, n.expr)
} }
case Proc_Lit: case ^Proc_Lit:
walk(v, n.type) walk(v, n.type)
walk(v, n.body) walk(v, n.body)
walk_expr_list(v, n.where_clauses) walk_expr_list(v, n.where_clauses)
case Comp_Lit: case ^Comp_Lit:
if n.type != nil { if n.type != nil {
walk(v, n.type) walk(v, n.type)
} }
walk_expr_list(v, n.elems) walk_expr_list(v, n.elems)
case Tag_Expr: case ^Tag_Expr:
walk(v, n.expr) walk(v, n.expr)
case Unary_Expr: case ^Unary_Expr:
walk(v, n.expr) walk(v, n.expr)
case Binary_Expr: case ^Binary_Expr:
walk(v, n.left) walk(v, n.left)
walk(v, n.right) walk(v, n.right)
case Paren_Expr: case ^Paren_Expr:
walk(v, n.expr) walk(v, n.expr)
case Selector_Expr: case ^Selector_Expr:
walk(v, n.expr) walk(v, n.expr)
walk(v, n.field) walk(v, n.field)
case Implicit_Selector_Expr: case ^Implicit_Selector_Expr:
walk(v, n.field) walk(v, n.field)
case Selector_Call_Expr: case ^Selector_Call_Expr:
walk(v, n.expr) walk(v, n.expr)
walk(v, n.call) walk(v, n.call)
case Index_Expr: case ^Index_Expr:
walk(v, n.expr) walk(v, n.expr)
walk(v, n.index) walk(v, n.index)
case Matrix_Index_Expr: case ^Matrix_Index_Expr:
walk(v, n.expr) walk(v, n.expr)
walk(v, n.row_index) walk(v, n.row_index)
walk(v, n.column_index) walk(v, n.column_index)
case Deref_Expr: case ^Deref_Expr:
walk(v, n.expr) walk(v, n.expr)
case Slice_Expr: case ^Slice_Expr:
walk(v, n.expr) walk(v, n.expr)
if n.low != nil { if n.low != nil {
walk(v, n.low) walk(v, n.low)
@@ -124,57 +124,57 @@ walk :: proc(v: ^Visitor, node: ^Node) {
if n.high != nil { if n.high != nil {
walk(v, n.high) walk(v, n.high)
} }
case Call_Expr: case ^Call_Expr:
walk(v, n.expr) walk(v, n.expr)
walk_expr_list(v, n.args) walk_expr_list(v, n.args)
case Field_Value: case ^Field_Value:
walk(v, n.field) walk(v, n.field)
walk(v, n.value) walk(v, n.value)
case Ternary_If_Expr: case ^Ternary_If_Expr:
walk(v, n.x) walk(v, n.x)
walk(v, n.cond) walk(v, n.cond)
walk(v, n.y) walk(v, n.y)
case Ternary_When_Expr: case ^Ternary_When_Expr:
walk(v, n.x) walk(v, n.x)
walk(v, n.cond) walk(v, n.cond)
walk(v, n.y) walk(v, n.y)
case Or_Else_Expr: case ^Or_Else_Expr:
walk(v, n.x) walk(v, n.x)
walk(v, n.y) walk(v, n.y)
case Or_Return_Expr: case ^Or_Return_Expr:
walk(v, n.expr) walk(v, n.expr)
case Type_Assertion: case ^Type_Assertion:
walk(v, n.expr) walk(v, n.expr)
if n.type != nil { if n.type != nil {
walk(v, n.type) walk(v, n.type)
} }
case Type_Cast: case ^Type_Cast:
walk(v, n.type) walk(v, n.type)
walk(v, n.expr) walk(v, n.expr)
case Auto_Cast: case ^Auto_Cast:
walk(v, n.expr) walk(v, n.expr)
case Inline_Asm_Expr: case ^Inline_Asm_Expr:
walk_expr_list(v, n.param_types) walk_expr_list(v, n.param_types)
walk(v, n.return_type) walk(v, n.return_type)
walk(v, n.constraints_string) walk(v, n.constraints_string)
walk(v, n.asm_string) walk(v, n.asm_string)
case Bad_Stmt: case ^Bad_Stmt:
case Empty_Stmt: case ^Empty_Stmt:
case Expr_Stmt: case ^Expr_Stmt:
walk(v, n.expr) walk(v, n.expr)
case Tag_Stmt: case ^Tag_Stmt:
walk(v, n.stmt) walk(v, n.stmt)
case Assign_Stmt: case ^Assign_Stmt:
walk_expr_list(v, n.lhs) walk_expr_list(v, n.lhs)
walk_expr_list(v, n.rhs) walk_expr_list(v, n.rhs)
case Block_Stmt: case ^Block_Stmt:
if n.label != nil { if n.label != nil {
walk(v, n.label) walk(v, n.label)
} }
walk_stmt_list(v, n.stmts) walk_stmt_list(v, n.stmts)
case If_Stmt: case ^If_Stmt:
if n.label != nil { if n.label != nil {
walk(v, n.label) walk(v, n.label)
} }
@@ -186,17 +186,17 @@ walk :: proc(v: ^Visitor, node: ^Node) {
if n.else_stmt != nil { if n.else_stmt != nil {
walk(v, n.else_stmt) walk(v, n.else_stmt)
} }
case When_Stmt: case ^When_Stmt:
walk(v, n.cond) walk(v, n.cond)
walk(v, n.body) walk(v, n.body)
if n.else_stmt != nil { if n.else_stmt != nil {
walk(v, n.else_stmt) walk(v, n.else_stmt)
} }
case Return_Stmt: case ^Return_Stmt:
walk_expr_list(v, n.results) walk_expr_list(v, n.results)
case Defer_Stmt: case ^Defer_Stmt:
walk(v, n.stmt) walk(v, n.stmt)
case For_Stmt: case ^For_Stmt:
if n.label != nil { if n.label != nil {
walk(v, n.label) walk(v, n.label)
} }
@@ -210,7 +210,7 @@ walk :: proc(v: ^Visitor, node: ^Node) {
walk(v, n.post) walk(v, n.post)
} }
walk(v, n.body) walk(v, n.body)
case Range_Stmt: case ^Range_Stmt:
if n.label != nil { if n.label != nil {
walk(v, n.label) walk(v, n.label)
} }
@@ -221,7 +221,7 @@ walk :: proc(v: ^Visitor, node: ^Node) {
} }
walk(v, n.expr) walk(v, n.expr)
walk(v, n.body) walk(v, n.body)
case Inline_Range_Stmt: case ^Inline_Range_Stmt:
if n.label != nil { if n.label != nil {
walk(v, n.label) walk(v, n.label)
} }
@@ -233,10 +233,10 @@ walk :: proc(v: ^Visitor, node: ^Node) {
} }
walk(v, n.expr) walk(v, n.expr)
walk(v, n.body) walk(v, n.body)
case Case_Clause: case ^Case_Clause:
walk_expr_list(v, n.list) walk_expr_list(v, n.list)
walk_stmt_list(v, n.body) walk_stmt_list(v, n.body)
case Switch_Stmt: case ^Switch_Stmt:
if n.label != nil { if n.label != nil {
walk(v, n.label) walk(v, n.label)
} }
@@ -247,7 +247,7 @@ walk :: proc(v: ^Visitor, node: ^Node) {
walk(v, n.cond) walk(v, n.cond)
} }
walk(v, n.body) walk(v, n.body)
case Type_Switch_Stmt: case ^Type_Switch_Stmt:
if n.label != nil { if n.label != nil {
walk(v, n.label) walk(v, n.label)
} }
@@ -258,16 +258,16 @@ walk :: proc(v: ^Visitor, node: ^Node) {
walk(v, n.expr) walk(v, n.expr)
} }
walk(v, n.body) walk(v, n.body)
case Branch_Stmt: case ^Branch_Stmt:
if n.label != nil { if n.label != nil {
walk(v, n.label) walk(v, n.label)
} }
case Using_Stmt: case ^Using_Stmt:
walk_expr_list(v, n.list) walk_expr_list(v, n.list)
case Bad_Decl: case ^Bad_Decl:
case Value_Decl: case ^Value_Decl:
if n.docs != nil { if n.docs != nil {
walk(v, n.docs) walk(v, n.docs)
} }
@@ -280,21 +280,21 @@ walk :: proc(v: ^Visitor, node: ^Node) {
if n.comment != nil { if n.comment != nil {
walk(v, n.comment) walk(v, n.comment)
} }
case Package_Decl: case ^Package_Decl:
if n.docs != nil { if n.docs != nil {
walk(v, n.docs) walk(v, n.docs)
} }
if n.comment != nil { if n.comment != nil {
walk(v, n.comment) walk(v, n.comment)
} }
case Import_Decl: case ^Import_Decl:
if n.docs != nil { if n.docs != nil {
walk(v, n.docs) walk(v, n.docs)
} }
if n.comment != nil { if n.comment != nil {
walk(v, n.comment) walk(v, n.comment)
} }
case Foreign_Block_Decl: case ^Foreign_Block_Decl:
if n.docs != nil { if n.docs != nil {
walk(v, n.docs) walk(v, n.docs)
} }
@@ -303,7 +303,7 @@ walk :: proc(v: ^Visitor, node: ^Node) {
walk(v, n.foreign_library) walk(v, n.foreign_library)
} }
walk(v, n.body) walk(v, n.body)
case Foreign_Import_Decl: case ^Foreign_Import_Decl:
if n.docs != nil { if n.docs != nil {
walk(v, n.docs) walk(v, n.docs)
} }
@@ -313,11 +313,11 @@ walk :: proc(v: ^Visitor, node: ^Node) {
walk(v, n.comment) walk(v, n.comment)
} }
case Proc_Group: case ^Proc_Group:
walk_expr_list(v, n.args) walk_expr_list(v, n.args)
case Attribute: case ^Attribute:
walk_expr_list(v, n.elems) walk_expr_list(v, n.elems)
case Field: case ^Field:
if n.docs != nil { if n.docs != nil {
walk(v, n.docs) walk(v, n.docs)
} }
@@ -331,31 +331,31 @@ walk :: proc(v: ^Visitor, node: ^Node) {
if n.comment != nil { if n.comment != nil {
walk(v, n.comment) walk(v, n.comment)
} }
case Field_List: case ^Field_List:
for x in n.list { for x in n.list {
walk(v, x) walk(v, x)
} }
case Typeid_Type: case ^Typeid_Type:
if n.specialization != nil { if n.specialization != nil {
walk(v, n.specialization) walk(v, n.specialization)
} }
case Helper_Type: case ^Helper_Type:
walk(v, n.type) walk(v, n.type)
case Distinct_Type: case ^Distinct_Type:
walk(v, n.type) walk(v, n.type)
case Poly_Type: case ^Poly_Type:
walk(v, n.type) walk(v, n.type)
if n.specialization != nil { if n.specialization != nil {
walk(v, n.specialization) walk(v, n.specialization)
} }
case Proc_Type: case ^Proc_Type:
walk(v, n.params) walk(v, n.params)
walk(v, n.results) walk(v, n.results)
case Pointer_Type: case ^Pointer_Type:
walk(v, n.elem) walk(v, n.elem)
case Multi_Pointer_Type: case ^Multi_Pointer_Type:
walk(v, n.elem) walk(v, n.elem)
case Array_Type: case ^Array_Type:
if n.tag != nil { if n.tag != nil {
walk(v, n.tag) walk(v, n.tag)
} }
@@ -363,12 +363,12 @@ walk :: proc(v: ^Visitor, node: ^Node) {
walk(v, n.len) walk(v, n.len)
} }
walk(v, n.elem) walk(v, n.elem)
case Dynamic_Array_Type: case ^Dynamic_Array_Type:
if n.tag != nil { if n.tag != nil {
walk(v, n.tag) walk(v, n.tag)
} }
walk(v, n.elem) walk(v, n.elem)
case Struct_Type: case ^Struct_Type:
if n.poly_params != nil { if n.poly_params != nil {
walk(v, n.poly_params) walk(v, n.poly_params)
} }
@@ -377,7 +377,7 @@ walk :: proc(v: ^Visitor, node: ^Node) {
} }
walk_expr_list(v, n.where_clauses) walk_expr_list(v, n.where_clauses)
walk(v, n.fields) walk(v, n.fields)
case Union_Type: case ^Union_Type:
if n.poly_params != nil { if n.poly_params != nil {
walk(v, n.poly_params) walk(v, n.poly_params)
} }
@@ -386,23 +386,23 @@ walk :: proc(v: ^Visitor, node: ^Node) {
} }
walk_expr_list(v, n.where_clauses) walk_expr_list(v, n.where_clauses)
walk_expr_list(v, n.variants) walk_expr_list(v, n.variants)
case Enum_Type: case ^Enum_Type:
if n.base_type != nil { if n.base_type != nil {
walk(v, n.base_type) walk(v, n.base_type)
} }
walk_expr_list(v, n.fields) walk_expr_list(v, n.fields)
case Bit_Set_Type: case ^Bit_Set_Type:
walk(v, n.elem) walk(v, n.elem)
if n.underlying != nil { if n.underlying != nil {
walk(v, n.underlying) walk(v, n.underlying)
} }
case Map_Type: case ^Map_Type:
walk(v, n.key) walk(v, n.key)
walk(v, n.value) walk(v, n.value)
case Relative_Type: case ^Relative_Type:
walk(v, n.tag) walk(v, n.tag)
walk(v, n.type) walk(v, n.type)
case Matrix_Type: case ^Matrix_Type:
walk(v, n.row_count) walk(v, n.row_count)
walk(v, n.column_count) walk(v, n.column_count)
walk(v, n.elem) walk(v, n.elem)
core/odin/parser/parser.odin
+90 -90
View File
@@ -195,10 +195,10 @@ parse_file :: proc(p: ^Parser, file: ^ast.File) -> bool {
for p.curr_tok.kind != .EOF { for p.curr_tok.kind != .EOF {
stmt := parse_stmt(p) stmt := parse_stmt(p)
if stmt != nil { if stmt != nil {
if _, ok := stmt.derived.(ast.Empty_Stmt); !ok { if _, ok := stmt.derived.(^ast.Empty_Stmt); !ok {
append(&p.file.decls, stmt) append(&p.file.decls, stmt)
if es, es_ok := stmt.derived.(ast.Expr_Stmt); es_ok && es.expr != nil { if es, es_ok := stmt.derived.(^ast.Expr_Stmt); es_ok && es.expr != nil {
if _, pl_ok := es.expr.derived.(ast.Proc_Lit); pl_ok { if _, pl_ok := es.expr.derived.(^ast.Proc_Lit); pl_ok {
error(p, stmt.pos, "procedure literal evaluated but not used") error(p, stmt.pos, "procedure literal evaluated but not used")
} }
} }
@@ -459,7 +459,7 @@ is_blank_ident_token :: proc(tok: tokenizer.Token) -> bool {
return false return false
} }
is_blank_ident_node :: proc(node: ^ast.Node) -> bool { is_blank_ident_node :: proc(node: ^ast.Node) -> bool {
if ident, ok := node.derived.(ast.Ident); ok { if ident, ok := node.derived.(^ast.Ident); ok {
return is_blank_ident(ident.name) return is_blank_ident(ident.name)
} }
return true return true
@@ -502,34 +502,34 @@ is_semicolon_optional_for_node :: proc(p: ^Parser, node: ^ast.Node) -> bool {
return true return true
} }
switch n in node.derived { #partial switch n in node.derived {
case ast.Empty_Stmt, ast.Block_Stmt: case ^ast.Empty_Stmt, ^ast.Block_Stmt:
return true return true
case ast.If_Stmt, ast.When_Stmt, case ^ast.If_Stmt, ^ast.When_Stmt,
ast.For_Stmt, ast.Range_Stmt, ast.Inline_Range_Stmt, ^ast.For_Stmt, ^ast.Range_Stmt, ^ast.Inline_Range_Stmt,
ast.Switch_Stmt, ast.Type_Switch_Stmt: ^ast.Switch_Stmt, ^ast.Type_Switch_Stmt:
return true return true
case ast.Helper_Type: case ^ast.Helper_Type:
return is_semicolon_optional_for_node(p, n.type) return is_semicolon_optional_for_node(p, n.type)
case ast.Distinct_Type: case ^ast.Distinct_Type:
return is_semicolon_optional_for_node(p, n.type) return is_semicolon_optional_for_node(p, n.type)
case ast.Pointer_Type: case ^ast.Pointer_Type:
return is_semicolon_optional_for_node(p, n.elem) return is_semicolon_optional_for_node(p, n.elem)
case ast.Struct_Type, ast.Union_Type, ast.Enum_Type: case ^ast.Struct_Type, ^ast.Union_Type, ^ast.Enum_Type:
// Require semicolon within a procedure body // Require semicolon within a procedure body
return p.curr_proc == nil return p.curr_proc == nil
case ast.Proc_Lit: case ^ast.Proc_Lit:
return true return true
case ast.Package_Decl, ast.Import_Decl, ast.Foreign_Import_Decl: case ^ast.Package_Decl, ^ast.Import_Decl, ^ast.Foreign_Import_Decl:
return true return true
case ast.Foreign_Block_Decl: case ^ast.Foreign_Block_Decl:
return is_semicolon_optional_for_node(p, n.body) return is_semicolon_optional_for_node(p, n.body)
case ast.Value_Decl: case ^ast.Value_Decl:
if n.is_mutable { if n.is_mutable {
return false return false
} }
@@ -641,10 +641,10 @@ parse_stmt_list :: proc(p: ^Parser) -> []^ast.Stmt {
p.curr_tok.kind != .EOF { p.curr_tok.kind != .EOF {
stmt := parse_stmt(p) stmt := parse_stmt(p)
if stmt != nil { if stmt != nil {
if _, ok := stmt.derived.(ast.Empty_Stmt); !ok { if _, ok := stmt.derived.(^ast.Empty_Stmt); !ok {
append(&list, stmt) append(&list, stmt)
if es, es_ok := stmt.derived.(ast.Expr_Stmt); es_ok && es.expr != nil { if es, es_ok := stmt.derived.(^ast.Expr_Stmt); es_ok && es.expr != nil {
if _, pl_ok := es.expr.derived.(ast.Proc_Lit); pl_ok { if _, pl_ok := es.expr.derived.(^ast.Proc_Lit); pl_ok {
error(p, stmt.pos, "procedure literal evaluated but not used") error(p, stmt.pos, "procedure literal evaluated but not used")
} }
} }
@@ -722,7 +722,7 @@ convert_stmt_to_expr :: proc(p: ^Parser, stmt: ^ast.Stmt, kind: string) -> ^ast.
if stmt == nil { if stmt == nil {
return nil return nil
} }
if es, ok := stmt.derived.(ast.Expr_Stmt); ok { if es, ok := stmt.derived.(^ast.Expr_Stmt); ok {
return es.expr return es.expr
} }
error(p, stmt.pos, "expected %s, found a simple statement", kind) error(p, stmt.pos, "expected %s, found a simple statement", kind)
@@ -864,7 +864,7 @@ parse_for_stmt :: proc(p: ^Parser) -> ^ast.Stmt {
if p.curr_tok.kind != .Semicolon { if p.curr_tok.kind != .Semicolon {
cond = parse_simple_stmt(p, {Stmt_Allow_Flag.In}) cond = parse_simple_stmt(p, {Stmt_Allow_Flag.In})
if as, ok := cond.derived.(ast.Assign_Stmt); ok && as.op.kind == .In { if as, ok := cond.derived.(^ast.Assign_Stmt); ok && as.op.kind == .In {
is_range = true is_range = true
} }
} }
@@ -906,7 +906,7 @@ parse_for_stmt :: proc(p: ^Parser) -> ^ast.Stmt {
if is_range { if is_range {
assign_stmt := cond.derived.(ast.Assign_Stmt) assign_stmt := cond.derived.(^ast.Assign_Stmt)
vals := assign_stmt.lhs[:] vals := assign_stmt.lhs[:]
rhs: ^ast.Expr rhs: ^ast.Expr
@@ -987,7 +987,7 @@ parse_switch_stmt :: proc(p: ^Parser) -> ^ast.Stmt {
tag = as tag = as
} else { } else {
tag = parse_simple_stmt(p, {Stmt_Allow_Flag.In}) tag = parse_simple_stmt(p, {Stmt_Allow_Flag.In})
if as, ok := tag.derived.(ast.Assign_Stmt); ok && as.op.kind == .In { if as, ok := tag.derived.(^ast.Assign_Stmt); ok && as.op.kind == .In {
is_type_switch = true is_type_switch = true
} else if parse_control_statement_semicolon_separator(p) { } else if parse_control_statement_semicolon_separator(p) {
init = tag init = tag
@@ -1074,14 +1074,14 @@ parse_attribute :: proc(p: ^Parser, tok: tokenizer.Token, open_kind, close_kind:
skip_possible_newline(p) skip_possible_newline(p)
decl := parse_stmt(p) decl := parse_stmt(p)
switch d in &decl.derived { #partial switch d in decl.derived_stmt {
case ast.Value_Decl: case ^ast.Value_Decl:
if d.docs == nil { d.docs = docs } if d.docs == nil { d.docs = docs }
append(&d.attributes, attribute) append(&d.attributes, attribute)
case ast.Foreign_Block_Decl: case ^ast.Foreign_Block_Decl:
if d.docs == nil { d.docs = docs } if d.docs == nil { d.docs = docs }
append(&d.attributes, attribute) append(&d.attributes, attribute)
case ast.Foreign_Import_Decl: case ^ast.Foreign_Import_Decl:
if d.docs == nil { d.docs = docs } if d.docs == nil { d.docs = docs }
append(&d.attributes, attribute) append(&d.attributes, attribute)
case: case:
@@ -1095,11 +1095,11 @@ parse_attribute :: proc(p: ^Parser, tok: tokenizer.Token, open_kind, close_kind:
parse_foreign_block_decl :: proc(p: ^Parser) -> ^ast.Stmt { parse_foreign_block_decl :: proc(p: ^Parser) -> ^ast.Stmt {
decl := parse_stmt(p) decl := parse_stmt(p)
switch in decl.derived { #partial switch in decl.derived_stmt {
case ast.Empty_Stmt, ast.Bad_Stmt, ast.Bad_Decl: case ^ast.Empty_Stmt, ^ast.Bad_Stmt, ^ast.Bad_Decl:
// Ignore // Ignore
return nil return nil
case ast.When_Stmt, ast.Value_Decl: case ^ast.When_Stmt, ^ast.Value_Decl:
return decl return decl
} }
@@ -1303,13 +1303,13 @@ parse_stmt :: proc(p: ^Parser) -> ^ast.Stmt {
case .Defer: case .Defer:
tok := advance_token(p) tok := advance_token(p)
stmt := parse_stmt(p) stmt := parse_stmt(p)
switch s in stmt.derived { #partial switch s in stmt.derived_stmt {
case ast.Empty_Stmt: case ^ast.Empty_Stmt:
error(p, s.pos, "empty statement after defer (e.g. ';')") error(p, s.pos, "empty statement after defer (e.g. ';')")
case ast.Defer_Stmt: case ^ast.Defer_Stmt:
error(p, s.pos, "you cannot defer a defer statement") error(p, s.pos, "you cannot defer a defer statement")
stmt = s.stmt stmt = s.stmt
case ast.Return_Stmt: case ^ast.Return_Stmt:
error(p, s.pos, "you cannot defer a return statement") error(p, s.pos, "you cannot defer a return statement")
} }
ds := ast.new(ast.Defer_Stmt, tok.pos, stmt.end) ds := ast.new(ast.Defer_Stmt, tok.pos, stmt.end)
@@ -1381,8 +1381,8 @@ parse_stmt :: proc(p: ^Parser) -> ^ast.Stmt {
expect_token_after(p, .Colon, "identifier list") expect_token_after(p, .Colon, "identifier list")
decl := parse_value_decl(p, list, docs) decl := parse_value_decl(p, list, docs)
if decl != nil { if decl != nil {
switch d in &decl.derived { #partial switch d in decl.derived_stmt {
case ast.Value_Decl: case ^ast.Value_Decl:
d.is_using = true d.is_using = true
return decl return decl
} }
@@ -1413,9 +1413,9 @@ parse_stmt :: proc(p: ^Parser) -> ^ast.Stmt {
return stmt return stmt
case "partial": case "partial":
stmt := parse_stmt(p) stmt := parse_stmt(p)
switch s in &stmt.derived { #partial switch s in stmt.derived_stmt {
case ast.Switch_Stmt: s.partial = true case ^ast.Switch_Stmt: s.partial = true
case ast.Type_Switch_Stmt: s.partial = true case ^ast.Type_Switch_Stmt: s.partial = true
case: error(p, stmt.pos, "#partial can only be applied to a switch statement") case: error(p, stmt.pos, "#partial can only be applied to a switch statement")
} }
return stmt return stmt
@@ -1560,11 +1560,11 @@ parse_body :: proc(p: ^Parser) -> ^ast.Block_Stmt {
} }
convert_stmt_to_body :: proc(p: ^Parser, stmt: ^ast.Stmt) -> ^ast.Stmt { convert_stmt_to_body :: proc(p: ^Parser, stmt: ^ast.Stmt) -> ^ast.Stmt {
switch s in stmt.derived { #partial switch s in stmt.derived_stmt {
case ast.Block_Stmt: case ^ast.Block_Stmt:
error(p, stmt.pos, "expected a normal statement rather than a block statement") error(p, stmt.pos, "expected a normal statement rather than a block statement")
return stmt return stmt
case ast.Empty_Stmt: case ^ast.Empty_Stmt:
error(p, stmt.pos, "expected a non-empty statement") error(p, stmt.pos, "expected a non-empty statement")
} }
@@ -1641,10 +1641,10 @@ convert_to_ident_list :: proc(p: ^Parser, list: []Expr_And_Flags, ignore_flags,
id: ^ast.Expr = ident.expr id: ^ast.Expr = ident.expr
switch n in ident.expr.derived { #partial switch n in ident.expr.derived_expr {
case ast.Ident: case ^ast.Ident:
case ast.Bad_Expr: case ^ast.Bad_Expr:
case ast.Poly_Type: case ^ast.Poly_Type:
if allow_poly_names { if allow_poly_names {
if n.specialization == nil { if n.specialization == nil {
break break
@@ -1806,21 +1806,21 @@ check_procedure_name_list :: proc(p: ^Parser, names: []^ast.Expr) -> bool {
return false return false
} }
_, first_is_polymorphic := names[0].derived.(ast.Poly_Type) _, first_is_polymorphic := names[0].derived.(^ast.Poly_Type)
any_polymorphic_names := first_is_polymorphic any_polymorphic_names := first_is_polymorphic
for i := 1; i < len(names); i += 1 { for i := 1; i < len(names); i += 1 {
name := names[i] name := names[i]
if first_is_polymorphic { if first_is_polymorphic {
if _, ok := name.derived.(ast.Poly_Type); ok { if _, ok := name.derived.(^ast.Poly_Type); ok {
any_polymorphic_names = true any_polymorphic_names = true
} else { } else {
error(p, name.pos, "mixture of polymorphic and non-polymorphic identifiers") error(p, name.pos, "mixture of polymorphic and non-polymorphic identifiers")
return any_polymorphic_names return any_polymorphic_names
} }
} else { } else {
if _, ok := name.derived.(ast.Poly_Type); ok { if _, ok := name.derived.(^ast.Poly_Type); ok {
any_polymorphic_names = true any_polymorphic_names = true
error(p, name.pos, "mixture of polymorphic and non-polymorphic identifiers") error(p, name.pos, "mixture of polymorphic and non-polymorphic identifiers")
return any_polymorphic_names return any_polymorphic_names
@@ -1885,7 +1885,7 @@ parse_field_list :: proc(p: ^Parser, follow: tokenizer.Token_Kind, allowed_flags
if type == nil { if type == nil {
return false return false
} }
_, ok := type.derived.(ast.Ellipsis) _, ok := type.derived.(^ast.Ellipsis)
return ok return ok
} }
@@ -1903,7 +1903,7 @@ parse_field_list :: proc(p: ^Parser, follow: tokenizer.Token_Kind, allowed_flags
type = parse_var_type(p, allowed_flags) type = parse_var_type(p, allowed_flags)
tt := ast.unparen_expr(type) tt := ast.unparen_expr(type)
if is_signature && !any_polymorphic_names { if is_signature && !any_polymorphic_names {
if ti, ok := tt.derived.(ast.Typeid_Type); ok && ti.specialization != nil { if ti, ok := tt.derived.(^ast.Typeid_Type); ok && ti.specialization != nil {
error(p, tt.pos, "specialization of typeid is not allowed without polymorphic names") error(p, tt.pos, "specialization of typeid is not allowed without polymorphic names")
} }
} }
@@ -1979,7 +1979,7 @@ parse_field_list :: proc(p: ^Parser, follow: tokenizer.Token_Kind, allowed_flags
p.curr_tok.kind != .EOF { p.curr_tok.kind != .EOF {
prefix_flags := parse_field_prefixes(p) prefix_flags := parse_field_prefixes(p)
param := parse_var_type(p, allowed_flags & {.Typeid_Token, .Ellipsis}) param := parse_var_type(p, allowed_flags & {.Typeid_Token, .Ellipsis})
if _, ok := param.derived.(ast.Ellipsis); ok { if _, ok := param.derived.(^ast.Ellipsis); ok {
if seen_ellipsis { if seen_ellipsis {
error(p, param.pos, "extra variadic parameter after ellipsis") error(p, param.pos, "extra variadic parameter after ellipsis")
} }
@@ -2006,8 +2006,8 @@ parse_field_list :: proc(p: ^Parser, follow: tokenizer.Token_Kind, allowed_flags
names := make([]^ast.Expr, 1) names := make([]^ast.Expr, 1)
names[0] = ast.new(ast.Ident, tok.pos, end_pos(tok)) names[0] = ast.new(ast.Ident, tok.pos, end_pos(tok))
switch ident in &names[0].derived { #partial switch ident in names[0].derived_expr {
case ast.Ident: case ^ast.Ident:
ident.name = tok.text ident.name = tok.text
case: case:
unreachable() unreachable()
@@ -2137,12 +2137,12 @@ parse_proc_type :: proc(p: ^Parser, tok: tokenizer.Token) -> ^ast.Proc_Type {
loop: for param in params.list { loop: for param in params.list {
if param.type != nil { if param.type != nil {
if _, ok := param.type.derived.(ast.Poly_Type); ok { if _, ok := param.type.derived.(^ast.Poly_Type); ok {
is_generic = true is_generic = true
break loop break loop
} }
for name in param.names { for name in param.names {
if _, ok := name.derived.(ast.Poly_Type); ok { if _, ok := name.derived.(^ast.Poly_Type); ok {
is_generic = true is_generic = true
break loop break loop
} }
@@ -2179,13 +2179,13 @@ parse_inlining_operand :: proc(p: ^Parser, lhs: bool, tok: tokenizer.Token) -> ^
} }
} }
switch e in &ast.unparen_expr(expr).derived { #partial switch e in ast.unparen_expr(expr).derived_expr {
case ast.Proc_Lit: case ^ast.Proc_Lit:
if e.inlining != .None && e.inlining != pi { if e.inlining != .None && e.inlining != pi {
error(p, expr.pos, "both 'inline' and 'no_inline' cannot be applied to a procedure literal") error(p, expr.pos, "both 'inline' and 'no_inline' cannot be applied to a procedure literal")
} }
e.inlining = pi e.inlining = pi
case ast.Call_Expr: case ^ast.Call_Expr:
if e.inlining != .None && e.inlining != pi { if e.inlining != .None && e.inlining != pi {
error(p, expr.pos, "both 'inline' and 'no_inline' cannot be applied to a procedure call") error(p, expr.pos, "both 'inline' and 'no_inline' cannot be applied to a procedure call")
} }
@@ -2276,9 +2276,9 @@ parse_operand :: proc(p: ^Parser, lhs: bool) -> ^ast.Expr {
bd.name = name.text bd.name = name.text
original_type := parse_type(p) original_type := parse_type(p)
type := ast.unparen_expr(original_type) type := ast.unparen_expr(original_type)
switch t in &type.derived { #partial switch t in type.derived_expr {
case ast.Array_Type: t.tag = bd case ^ast.Array_Type: t.tag = bd
case ast.Dynamic_Array_Type: t.tag = bd case ^ast.Dynamic_Array_Type: t.tag = bd
case: case:
error(p, original_type.pos, "expected an array type after #%s", name.text) error(p, original_type.pos, "expected an array type after #%s", name.text)
} }
@@ -2290,10 +2290,10 @@ parse_operand :: proc(p: ^Parser, lhs: bool) -> ^ast.Expr {
tag.name = name.text tag.name = name.text
original_expr := parse_expr(p, lhs) original_expr := parse_expr(p, lhs)
expr := ast.unparen_expr(original_expr) expr := ast.unparen_expr(original_expr)
switch t in &expr.derived { #partial switch t in expr.derived_expr {
case ast.Comp_Lit: case ^ast.Comp_Lit:
t.tag = tag t.tag = tag
case ast.Array_Type: case ^ast.Array_Type:
t.tag = tag t.tag = tag
error(p, tok.pos, "#%s has been replaced with #sparse for non-contiguous enumerated array types", name.text) error(p, tok.pos, "#%s has been replaced with #sparse for non-contiguous enumerated array types", name.text)
case: case:
@@ -2308,8 +2308,8 @@ parse_operand :: proc(p: ^Parser, lhs: bool) -> ^ast.Expr {
tag.name = name.text tag.name = name.text
original_type := parse_type(p) original_type := parse_type(p)
type := ast.unparen_expr(original_type) type := ast.unparen_expr(original_type)
switch t in &type.derived { #partial switch t in type.derived_expr {
case ast.Array_Type: case ^ast.Array_Type:
t.tag = tag t.tag = tag
case: case:
error(p, tok.pos, "expected an enumerated array type after #%s", name.text) error(p, tok.pos, "expected an enumerated array type after #%s", name.text)
@@ -2689,7 +2689,7 @@ parse_operand :: proc(p: ^Parser, lhs: bool) -> ^ast.Expr {
variants: [dynamic]^ast.Expr variants: [dynamic]^ast.Expr
for p.curr_tok.kind != .Close_Brace && p.curr_tok.kind != .EOF { for p.curr_tok.kind != .Close_Brace && p.curr_tok.kind != .EOF {
type := parse_type(p) type := parse_type(p)
if _, ok := type.derived.(ast.Bad_Expr); !ok { if _, ok := type.derived.(^ast.Bad_Expr); !ok {
append(&variants, type) append(&variants, type)
} }
if !allow_token(p, .Comma) { if !allow_token(p, .Comma) {
@@ -2864,19 +2864,19 @@ is_literal_type :: proc(expr: ^ast.Expr) -> bool {
if val == nil { if val == nil {
return false return false
} }
switch _ in val.derived { #partial switch _ in val.derived_expr {
case ast.Bad_Expr, case ^ast.Bad_Expr,
ast.Ident, ^ast.Ident,
ast.Selector_Expr, ^ast.Selector_Expr,
ast.Array_Type, ^ast.Array_Type,
ast.Struct_Type, ^ast.Struct_Type,
ast.Union_Type, ^ast.Union_Type,
ast.Enum_Type, ^ast.Enum_Type,
ast.Dynamic_Array_Type, ^ast.Dynamic_Array_Type,
ast.Map_Type, ^ast.Map_Type,
ast.Bit_Set_Type, ^ast.Bit_Set_Type,
ast.Matrix_Type, ^ast.Matrix_Type,
ast.Call_Expr: ^ast.Call_Expr:
return true return true
} }
return false return false
@@ -2998,7 +2998,7 @@ parse_call_expr :: proc(p: ^Parser, operand: ^ast.Expr) -> ^ast.Expr {
ce.close = close.pos ce.close = close.pos
o := ast.unparen_expr(operand) o := ast.unparen_expr(operand)
if se, ok := o.derived.(ast.Selector_Expr); ok && se.op.kind == .Arrow_Right { if se, ok := o.derived.(^ast.Selector_Expr); ok && se.op.kind == .Arrow_Right {
sce := ast.new(ast.Selector_Call_Expr, ce.pos, ce.end) sce := ast.new(ast.Selector_Call_Expr, ce.pos, ce.end)
sce.expr = o sce.expr = o
sce.call = ce sce.call = ce
@@ -3428,13 +3428,13 @@ parse_simple_stmt :: proc(p: ^Parser, flags: Stmt_Allow_Flags) -> ^ast.Stmt {
stmt := parse_stmt(p) stmt := parse_stmt(p)
if stmt != nil { if stmt != nil {
switch n in &stmt.derived { #partial switch n in stmt.derived_stmt {
case ast.Block_Stmt: n.label = label case ^ast.Block_Stmt: n.label = label
case ast.If_Stmt: n.label = label case ^ast.If_Stmt: n.label = label
case ast.For_Stmt: n.label = label case ^ast.For_Stmt: n.label = label
case ast.Switch_Stmt: n.label = label case ^ast.Switch_Stmt: n.label = label
case ast.Type_Switch_Stmt: n.label = label case ^ast.Type_Switch_Stmt: n.label = label
case ast.Range_Stmt: n.label = label case ^ast.Range_Stmt: n.label = label
} }
} }
core/odin/printer/visit.odin
+132 -94
View File
@@ -342,16 +342,16 @@ visit_decl :: proc(p: ^Printer, decl: ^ast.Decl, called_in_stmt := false) {
return return
} }
switch v in &decl.derived { #partial switch v in decl.derived_stmt {
case Expr_Stmt: case ^Expr_Stmt:
move_line(p, decl.pos) move_line(p, decl.pos)
visit_expr(p, v.expr) visit_expr(p, v.expr)
if p.config.semicolons { if p.config.semicolons {
push_generic_token(p, .Semicolon, 0) push_generic_token(p, .Semicolon, 0)
} }
case When_Stmt: case ^When_Stmt:
visit_stmt(p, cast(^Stmt)decl) visit_stmt(p, cast(^Stmt)decl)
case Foreign_Import_Decl: case ^Foreign_Import_Decl:
if len(v.attributes) > 0 { if len(v.attributes) > 0 {
sort.sort(sort_attribute(&v.attributes)) sort.sort(sort_attribute(&v.attributes))
move_line(p, v.attributes[0].pos) move_line(p, v.attributes[0].pos)
@@ -370,7 +370,7 @@ visit_decl :: proc(p: ^Printer, decl: ^ast.Decl, called_in_stmt := false) {
for path in v.fullpaths { for path in v.fullpaths {
push_ident_token(p, path, 0) push_ident_token(p, path, 0)
} }
case Foreign_Block_Decl: case ^Foreign_Block_Decl:
if len(v.attributes) > 0 { if len(v.attributes) > 0 {
sort.sort(sort_attribute(&v.attributes)) sort.sort(sort_attribute(&v.attributes))
move_line(p, v.attributes[0].pos) move_line(p, v.attributes[0].pos)
@@ -383,7 +383,7 @@ visit_decl :: proc(p: ^Printer, decl: ^ast.Decl, called_in_stmt := false) {
visit_expr(p, v.foreign_library) visit_expr(p, v.foreign_library)
visit_stmt(p, v.body) visit_stmt(p, v.body)
case Import_Decl: case ^Import_Decl:
move_line(p, decl.pos) move_line(p, decl.pos)
if v.name.text != "" { if v.name.text != "" {
@@ -395,7 +395,7 @@ visit_decl :: proc(p: ^Printer, decl: ^ast.Decl, called_in_stmt := false) {
push_ident_token(p, v.fullpath, 1) push_ident_token(p, v.fullpath, 1)
} }
case Value_Decl: case ^Value_Decl:
if len(v.attributes) > 0 { if len(v.attributes) > 0 {
sort.sort(sort_attribute(&v.attributes)) sort.sort(sort_attribute(&v.attributes))
move_line(p, v.attributes[0].pos) move_line(p, v.attributes[0].pos)
@@ -446,10 +446,10 @@ visit_decl :: proc(p: ^Printer, decl: ^ast.Decl, called_in_stmt := false) {
add_semicolon := true add_semicolon := true
for value in v.values { for value in v.values {
switch a in value.derived { #partial switch a in value.derived {
case Union_Type, Enum_Type, Struct_Type: case ^Union_Type, ^Enum_Type, ^Struct_Type:
add_semicolon = false || called_in_stmt add_semicolon = false || called_in_stmt
case Proc_Lit: case ^Proc_Lit:
add_semicolon = false add_semicolon = false
} }
} }
@@ -516,23 +516,34 @@ visit_stmt :: proc(p: ^Printer, stmt: ^ast.Stmt, block_type: Block_Type = .Gener
return return
} }
switch v in stmt.derived {
case Import_Decl:
visit_decl(p, cast(^Decl)stmt, true)
return
case Value_Decl:
visit_decl(p, cast(^Decl)stmt, true)
return
case Foreign_Import_Decl:
visit_decl(p, cast(^Decl)stmt, true)
return
case Foreign_Block_Decl:
visit_decl(p, cast(^Decl)stmt, true)
return
}
switch v in stmt.derived { switch v in stmt.derived_stmt {
case Using_Stmt: case ^Bad_Stmt:
case ^Bad_Decl:
case ^Package_Decl:
case ^Empty_Stmt:
push_generic_token(p, .Semicolon, 0)
case ^Tag_Stmt:
push_generic_token(p, .Hash, 1)
push_generic_token(p, v.op.kind, 1, v.op.text)
visit_stmt(p, v.stmt)
case ^Import_Decl:
visit_decl(p, cast(^Decl)stmt, true)
return
case ^Value_Decl:
visit_decl(p, cast(^Decl)stmt, true)
return
case ^Foreign_Import_Decl:
visit_decl(p, cast(^Decl)stmt, true)
return
case ^Foreign_Block_Decl:
visit_decl(p, cast(^Decl)stmt, true)
return
case ^Using_Stmt:
move_line(p, v.pos) move_line(p, v.pos)
push_generic_token(p, .Using, 1) push_generic_token(p, .Using, 1)
@@ -542,7 +553,7 @@ visit_stmt :: proc(p: ^Printer, stmt: ^ast.Stmt, block_type: Block_Type = .Gener
if p.config.semicolons { if p.config.semicolons {
push_generic_token(p, .Semicolon, 0) push_generic_token(p, .Semicolon, 0)
} }
case Block_Stmt: case ^Block_Stmt:
move_line(p, v.pos) move_line(p, v.pos)
if v.pos.line == v.end.line { if v.pos.line == v.end.line {
@@ -572,7 +583,7 @@ visit_stmt :: proc(p: ^Printer, stmt: ^ast.Stmt, block_type: Block_Type = .Gener
visit_end_brace(p, v.end) visit_end_brace(p, v.end)
} }
} }
case If_Stmt: case ^If_Stmt:
move_line(p, v.pos) move_line(p, v.pos)
if v.label != nil { if v.label != nil {
@@ -595,7 +606,7 @@ visit_stmt :: proc(p: ^Printer, stmt: ^ast.Stmt, block_type: Block_Type = .Gener
uses_do := false uses_do := false
if check_stmt, ok := v.body.derived.(Block_Stmt); ok && check_stmt.uses_do { if check_stmt, ok := v.body.derived.(^Block_Stmt); ok && check_stmt.uses_do {
uses_do = true uses_do = true
} }
@@ -626,7 +637,7 @@ visit_stmt :: proc(p: ^Printer, stmt: ^ast.Stmt, block_type: Block_Type = .Gener
visit_stmt(p, v.else_stmt) visit_stmt(p, v.else_stmt)
} }
case Switch_Stmt: case ^Switch_Stmt:
move_line(p, v.pos) move_line(p, v.pos)
if v.label != nil { if v.label != nil {
@@ -654,7 +665,7 @@ visit_stmt :: proc(p: ^Printer, stmt: ^ast.Stmt, block_type: Block_Type = .Gener
visit_expr(p, v.cond) visit_expr(p, v.cond)
visit_stmt(p, v.body) visit_stmt(p, v.body)
case Case_Clause: case ^Case_Clause:
move_line(p, v.pos) move_line(p, v.pos)
if !p.config.indent_cases { if !p.config.indent_cases {
@@ -678,7 +689,7 @@ visit_stmt :: proc(p: ^Printer, stmt: ^ast.Stmt, block_type: Block_Type = .Gener
if !p.config.indent_cases { if !p.config.indent_cases {
indent(p) indent(p)
} }
case Type_Switch_Stmt: case ^Type_Switch_Stmt:
move_line(p, v.pos) move_line(p, v.pos)
hint_current_line(p, {.Switch_Stmt}) hint_current_line(p, {.Switch_Stmt})
@@ -696,7 +707,7 @@ visit_stmt :: proc(p: ^Printer, stmt: ^ast.Stmt, block_type: Block_Type = .Gener
visit_stmt(p, v.tag) visit_stmt(p, v.tag)
visit_stmt(p, v.body) visit_stmt(p, v.body)
case Assign_Stmt: case ^Assign_Stmt:
move_line(p, v.pos) move_line(p, v.pos)
hint_current_line(p, {.Assign}) hint_current_line(p, {.Assign})
@@ -710,13 +721,13 @@ visit_stmt :: proc(p: ^Printer, stmt: ^ast.Stmt, block_type: Block_Type = .Gener
if block_stmt && p.config.semicolons { if block_stmt && p.config.semicolons {
push_generic_token(p, .Semicolon, 0) push_generic_token(p, .Semicolon, 0)
} }
case Expr_Stmt: case ^Expr_Stmt:
move_line(p, v.pos) move_line(p, v.pos)
visit_expr(p, v.expr) visit_expr(p, v.expr)
if block_stmt && p.config.semicolons { if block_stmt && p.config.semicolons {
push_generic_token(p, .Semicolon, 0) push_generic_token(p, .Semicolon, 0)
} }
case For_Stmt: case ^For_Stmt:
// this should be simplified // this should be simplified
move_line(p, v.pos) move_line(p, v.pos)
@@ -753,7 +764,7 @@ visit_stmt :: proc(p: ^Printer, stmt: ^ast.Stmt, block_type: Block_Type = .Gener
visit_stmt(p, v.body) visit_stmt(p, v.body)
case Inline_Range_Stmt: case ^Inline_Range_Stmt:
move_line(p, v.pos) move_line(p, v.pos)
if v.label != nil { if v.label != nil {
@@ -779,7 +790,7 @@ visit_stmt :: proc(p: ^Printer, stmt: ^ast.Stmt, block_type: Block_Type = .Gener
visit_expr(p, v.expr) visit_expr(p, v.expr)
visit_stmt(p, v.body) visit_stmt(p, v.body)
case Range_Stmt: case ^Range_Stmt:
move_line(p, v.pos) move_line(p, v.pos)
if v.label != nil { if v.label != nil {
@@ -805,7 +816,7 @@ visit_stmt :: proc(p: ^Printer, stmt: ^ast.Stmt, block_type: Block_Type = .Gener
visit_expr(p, v.expr) visit_expr(p, v.expr)
visit_stmt(p, v.body) visit_stmt(p, v.body)
case Return_Stmt: case ^Return_Stmt:
move_line(p, v.pos) move_line(p, v.pos)
push_generic_token(p, .Return, 1) push_generic_token(p, .Return, 1)
@@ -817,7 +828,7 @@ visit_stmt :: proc(p: ^Printer, stmt: ^ast.Stmt, block_type: Block_Type = .Gener
if block_stmt && p.config.semicolons { if block_stmt && p.config.semicolons {
push_generic_token(p, .Semicolon, 0) push_generic_token(p, .Semicolon, 0)
} }
case Defer_Stmt: case ^Defer_Stmt:
move_line(p, v.pos) move_line(p, v.pos)
push_generic_token(p, .Defer, 0) push_generic_token(p, .Defer, 0)
@@ -826,7 +837,7 @@ visit_stmt :: proc(p: ^Printer, stmt: ^ast.Stmt, block_type: Block_Type = .Gener
if p.config.semicolons { if p.config.semicolons {
push_generic_token(p, .Semicolon, 0) push_generic_token(p, .Semicolon, 0)
} }
case When_Stmt: case ^When_Stmt:
move_line(p, v.pos) move_line(p, v.pos)
push_generic_token(p, .When, 1) push_generic_token(p, .When, 1)
visit_expr(p, v.cond) visit_expr(p, v.cond)
@@ -846,7 +857,7 @@ visit_stmt :: proc(p: ^Printer, stmt: ^ast.Stmt, block_type: Block_Type = .Gener
visit_stmt(p, v.else_stmt) visit_stmt(p, v.else_stmt)
} }
case Branch_Stmt: case ^Branch_Stmt:
move_line(p, v.pos) move_line(p, v.pos)
push_generic_token(p, v.tok.kind, 0) push_generic_token(p, v.tok.kind, 0)
@@ -918,8 +929,15 @@ visit_expr :: proc(p: ^Printer, expr: ^ast.Expr, options := List_Options{}) {
set_source_position(p, expr.pos) set_source_position(p, expr.pos)
switch v in expr.derived { switch v in expr.derived_expr {
case Inline_Asm_Expr: case ^Bad_Expr:
case ^Tag_Expr:
push_generic_token(p, .Hash, 1)
push_generic_token(p, v.op.kind, 1, v.op.text)
visit_expr(p, v.expr)
case ^Inline_Asm_Expr:
push_generic_token(p, v.tok.kind, 1, v.tok.text) push_generic_token(p, v.tok.kind, 1, v.tok.text)
push_generic_token(p, .Open_Paren, 1) push_generic_token(p, .Open_Paren, 1)
@@ -936,42 +954,42 @@ visit_expr :: proc(p: ^Printer, expr: ^ast.Expr, options := List_Options{}) {
push_generic_token(p, .Comma, 0) push_generic_token(p, .Comma, 0)
visit_expr(p, v.constraints_string) visit_expr(p, v.constraints_string)
push_generic_token(p, .Close_Brace, 0) push_generic_token(p, .Close_Brace, 0)
case Undef: case ^Undef:
push_generic_token(p, .Undef, 1) push_generic_token(p, .Undef, 1)
case Auto_Cast: case ^Auto_Cast:
push_generic_token(p, v.op.kind, 1) push_generic_token(p, v.op.kind, 1)
visit_expr(p, v.expr) visit_expr(p, v.expr)
case Ternary_If_Expr: case ^Ternary_If_Expr:
visit_expr(p, v.x) visit_expr(p, v.x)
push_generic_token(p, v.op1.kind, 1) push_generic_token(p, v.op1.kind, 1)
visit_expr(p, v.cond) visit_expr(p, v.cond)
push_generic_token(p, v.op2.kind, 1) push_generic_token(p, v.op2.kind, 1)
visit_expr(p, v.y) visit_expr(p, v.y)
case Ternary_When_Expr: case ^Ternary_When_Expr:
visit_expr(p, v.x) visit_expr(p, v.x)
push_generic_token(p, v.op1.kind, 1) push_generic_token(p, v.op1.kind, 1)
visit_expr(p, v.cond) visit_expr(p, v.cond)
push_generic_token(p, v.op2.kind, 1) push_generic_token(p, v.op2.kind, 1)
visit_expr(p, v.y) visit_expr(p, v.y)
case Or_Else_Expr: case ^Or_Else_Expr:
visit_expr(p, v.x) visit_expr(p, v.x)
push_generic_token(p, v.token.kind, 1) push_generic_token(p, v.token.kind, 1)
visit_expr(p, v.y) visit_expr(p, v.y)
case Or_Return_Expr: case ^Or_Return_Expr:
visit_expr(p, v.expr) visit_expr(p, v.expr)
push_generic_token(p, v.token.kind, 1) push_generic_token(p, v.token.kind, 1)
case Selector_Call_Expr: case ^Selector_Call_Expr:
visit_expr(p, v.call.expr) visit_expr(p, v.call.expr)
push_generic_token(p, .Open_Paren, 1) push_generic_token(p, .Open_Paren, 1)
visit_exprs(p, v.call.args, {.Add_Comma}) visit_exprs(p, v.call.args, {.Add_Comma})
push_generic_token(p, .Close_Paren, 0) push_generic_token(p, .Close_Paren, 0)
case Ellipsis: case ^Ellipsis:
push_generic_token(p, .Ellipsis, 1) push_generic_token(p, .Ellipsis, 1)
visit_expr(p, v.expr) visit_expr(p, v.expr)
case Relative_Type: case ^Relative_Type:
visit_expr(p, v.tag) visit_expr(p, v.tag)
visit_expr(p, v.type) visit_expr(p, v.type)
case Slice_Expr: case ^Slice_Expr:
visit_expr(p, v.expr) visit_expr(p, v.expr)
push_generic_token(p, .Open_Bracket, 0) push_generic_token(p, .Open_Bracket, 0)
visit_expr(p, v.low) visit_expr(p, v.low)
@@ -981,37 +999,37 @@ visit_expr :: proc(p: ^Printer, expr: ^ast.Expr, options := List_Options{}) {
visit_expr(p, v.high) visit_expr(p, v.high)
} }
push_generic_token(p, .Close_Bracket, 0) push_generic_token(p, .Close_Bracket, 0)
case Ident: case ^Ident:
if .Enforce_Poly_Names in options { if .Enforce_Poly_Names in options {
push_generic_token(p, .Dollar, 1) push_generic_token(p, .Dollar, 1)
push_ident_token(p, v.name, 0) push_ident_token(p, v.name, 0)
} else { } else {
push_ident_token(p, v.name, 1) push_ident_token(p, v.name, 1)
} }
case Deref_Expr: case ^Deref_Expr:
visit_expr(p, v.expr) visit_expr(p, v.expr)
push_generic_token(p, v.op.kind, 0) push_generic_token(p, v.op.kind, 0)
case Type_Cast: case ^Type_Cast:
push_generic_token(p, v.tok.kind, 1) push_generic_token(p, v.tok.kind, 1)
push_generic_token(p, .Open_Paren, 0) push_generic_token(p, .Open_Paren, 0)
visit_expr(p, v.type) visit_expr(p, v.type)
push_generic_token(p, .Close_Paren, 0) push_generic_token(p, .Close_Paren, 0)
merge_next_token(p) merge_next_token(p)
visit_expr(p, v.expr) visit_expr(p, v.expr)
case Basic_Directive: case ^Basic_Directive:
push_generic_token(p, v.tok.kind, 1) push_generic_token(p, v.tok.kind, 1)
push_ident_token(p, v.name, 0) push_ident_token(p, v.name, 0)
case Distinct_Type: case ^Distinct_Type:
push_generic_token(p, .Distinct, 1) push_generic_token(p, .Distinct, 1)
visit_expr(p, v.type) visit_expr(p, v.type)
case Dynamic_Array_Type: case ^Dynamic_Array_Type:
visit_expr(p, v.tag) visit_expr(p, v.tag)
push_generic_token(p, .Open_Bracket, 1) push_generic_token(p, .Open_Bracket, 1)
push_generic_token(p, .Dynamic, 0) push_generic_token(p, .Dynamic, 0)
push_generic_token(p, .Close_Bracket, 0) push_generic_token(p, .Close_Bracket, 0)
merge_next_token(p) merge_next_token(p)
visit_expr(p, v.elem) visit_expr(p, v.elem)
case Bit_Set_Type: case ^Bit_Set_Type:
push_generic_token(p, .Bit_Set, 1) push_generic_token(p, .Bit_Set, 1)
push_generic_token(p, .Open_Bracket, 0) push_generic_token(p, .Open_Bracket, 0)
@@ -1023,7 +1041,7 @@ visit_expr :: proc(p: ^Printer, expr: ^ast.Expr, options := List_Options{}) {
} }
push_generic_token(p, .Close_Bracket, 0) push_generic_token(p, .Close_Bracket, 0)
case Union_Type: case ^Union_Type:
push_generic_token(p, .Union, 1) push_generic_token(p, .Union, 1)
push_poly_params(p, v.poly_params) push_poly_params(p, v.poly_params)
@@ -1045,7 +1063,7 @@ visit_expr :: proc(p: ^Printer, expr: ^ast.Expr, options := List_Options{}) {
visit_exprs(p, v.variants, {.Add_Comma, .Trailing}) visit_exprs(p, v.variants, {.Add_Comma, .Trailing})
visit_end_brace(p, v.end) visit_end_brace(p, v.end)
} }
case Enum_Type: case ^Enum_Type:
push_generic_token(p, .Enum, 1) push_generic_token(p, .Enum, 1)
hint_current_line(p, {.Enum}) hint_current_line(p, {.Enum})
@@ -1068,7 +1086,7 @@ visit_expr :: proc(p: ^Printer, expr: ^ast.Expr, options := List_Options{}) {
} }
set_source_position(p, v.end) set_source_position(p, v.end)
case Struct_Type: case ^Struct_Type:
push_generic_token(p, .Struct, 1) push_generic_token(p, .Struct, 1)
hint_current_line(p, {.Struct}) hint_current_line(p, {.Struct})
@@ -1103,7 +1121,7 @@ visit_expr :: proc(p: ^Printer, expr: ^ast.Expr, options := List_Options{}) {
} }
set_source_position(p, v.end) set_source_position(p, v.end)
case Proc_Lit: case ^Proc_Lit:
switch v.inlining { switch v.inlining {
case .None: case .None:
case .Inline: case .Inline:
@@ -1112,7 +1130,7 @@ visit_expr :: proc(p: ^Printer, expr: ^ast.Expr, options := List_Options{}) {
push_ident_token(p, "#force_no_inline", 0) push_ident_token(p, "#force_no_inline", 0)
} }
visit_proc_type(p, v.type^, true) visit_proc_type(p, v.type, true)
push_where_clauses(p, v.where_clauses) push_where_clauses(p, v.where_clauses)
@@ -1122,16 +1140,16 @@ visit_expr :: proc(p: ^Printer, expr: ^ast.Expr, options := List_Options{}) {
} else { } else {
push_generic_token(p, .Undef, 1) push_generic_token(p, .Undef, 1)
} }
case Proc_Type: case ^Proc_Type:
visit_proc_type(p, v) visit_proc_type(p, v)
case Basic_Lit: case ^Basic_Lit:
push_generic_token(p, v.tok.kind, 1, v.tok.text) push_generic_token(p, v.tok.kind, 1, v.tok.text)
case Binary_Expr: case ^Binary_Expr:
visit_binary_expr(p, v) visit_binary_expr(p, v)
case Implicit_Selector_Expr: case ^Implicit_Selector_Expr:
push_generic_token(p, .Period, 1) push_generic_token(p, .Period, 1)
push_ident_token(p, v.field.name, 0) push_ident_token(p, v.field.name, 0)
case Call_Expr: case ^Call_Expr:
visit_expr(p, v.expr) visit_expr(p, v.expr)
push_format_token(p, push_format_token(p,
@@ -1146,27 +1164,34 @@ visit_expr :: proc(p: ^Printer, expr: ^ast.Expr, options := List_Options{}) {
visit_call_exprs(p, v.args, v.ellipsis.kind == .Ellipsis) visit_call_exprs(p, v.args, v.ellipsis.kind == .Ellipsis)
push_generic_token(p, .Close_Paren, 0) push_generic_token(p, .Close_Paren, 0)
case Typeid_Type: case ^Typeid_Type:
push_generic_token(p, .Typeid, 1) push_generic_token(p, .Typeid, 1)
if v.specialization != nil { if v.specialization != nil {
push_generic_token(p, .Quo, 0) push_generic_token(p, .Quo, 0)
visit_expr(p, v.specialization) visit_expr(p, v.specialization)
} }
case Selector_Expr: case ^Selector_Expr:
visit_expr(p, v.expr) visit_expr(p, v.expr)
push_generic_token(p, v.op.kind, 0) push_generic_token(p, v.op.kind, 0)
visit_expr(p, v.field) visit_expr(p, v.field)
case Paren_Expr: case ^Paren_Expr:
push_generic_token(p, .Open_Paren, 1) push_generic_token(p, .Open_Paren, 1)
visit_expr(p, v.expr) visit_expr(p, v.expr)
push_generic_token(p, .Close_Paren, 0) push_generic_token(p, .Close_Paren, 0)
case Index_Expr: case ^Index_Expr:
visit_expr(p, v.expr) visit_expr(p, v.expr)
push_generic_token(p, .Open_Bracket, 0) push_generic_token(p, .Open_Bracket, 0)
visit_expr(p, v.index) visit_expr(p, v.index)
push_generic_token(p, .Close_Bracket, 0) push_generic_token(p, .Close_Bracket, 0)
case Proc_Group: case ^Matrix_Index_Expr:
visit_expr(p, v.expr)
push_generic_token(p, .Open_Bracket, 0)
visit_expr(p, v.row_index)
push_generic_token(p, .Comma, 0)
visit_expr(p, v.column_index)
push_generic_token(p, .Close_Bracket, 0)
case ^Proc_Group:
push_generic_token(p, v.tok.kind, 1) push_generic_token(p, v.tok.kind, 1)
if len(v.args) != 0 && v.pos.line != v.args[len(v.args) - 1].pos.line { if len(v.args) != 0 && v.pos.line != v.args[len(v.args) - 1].pos.line {
@@ -1181,7 +1206,7 @@ visit_expr :: proc(p: ^Printer, expr: ^ast.Expr, options := List_Options{}) {
push_generic_token(p, .Close_Brace, 0) push_generic_token(p, .Close_Brace, 0)
} }
case Comp_Lit: case ^Comp_Lit:
if v.type != nil { if v.type != nil {
visit_expr(p, v.type) visit_expr(p, v.type)
} }
@@ -1198,18 +1223,18 @@ visit_expr :: proc(p: ^Printer, expr: ^ast.Expr, options := List_Options{}) {
push_generic_token(p, .Close_Brace, 0) push_generic_token(p, .Close_Brace, 0)
} }
case Unary_Expr: case ^Unary_Expr:
push_generic_token(p, v.op.kind, 1) push_generic_token(p, v.op.kind, 1)
merge_next_token(p) merge_next_token(p)
visit_expr(p, v.expr) visit_expr(p, v.expr)
case Field_Value: case ^Field_Value:
visit_expr(p, v.field) visit_expr(p, v.field)
push_generic_token(p, .Eq, 1) push_generic_token(p, .Eq, 1)
visit_expr(p, v.value) visit_expr(p, v.value)
case Type_Assertion: case ^Type_Assertion:
visit_expr(p, v.expr) visit_expr(p, v.expr)
if unary, ok := v.type.derived.(Unary_Expr); ok && unary.op.text == "?" { if unary, ok := v.type.derived.(^Unary_Expr); ok && unary.op.text == "?" {
push_generic_token(p, .Period, 0) push_generic_token(p, .Period, 0)
visit_expr(p, v.type) visit_expr(p, v.type)
} else { } else {
@@ -1219,13 +1244,13 @@ visit_expr :: proc(p: ^Printer, expr: ^ast.Expr, options := List_Options{}) {
push_generic_token(p, .Close_Paren, 0) push_generic_token(p, .Close_Paren, 0)
} }
case Pointer_Type: case ^Pointer_Type:
push_generic_token(p, .Pointer, 1) push_generic_token(p, .Pointer, 1)
merge_next_token(p) merge_next_token(p)
visit_expr(p, v.elem) visit_expr(p, v.elem)
case Implicit: case ^Implicit:
push_generic_token(p, v.tok.kind, 1) push_generic_token(p, v.tok.kind, 1)
case Poly_Type: case ^Poly_Type:
push_generic_token(p, .Dollar, 1) push_generic_token(p, .Dollar, 1)
merge_next_token(p) merge_next_token(p)
visit_expr(p, v.type) visit_expr(p, v.type)
@@ -1235,22 +1260,35 @@ visit_expr :: proc(p: ^Printer, expr: ^ast.Expr, options := List_Options{}) {
merge_next_token(p) merge_next_token(p)
visit_expr(p, v.specialization) visit_expr(p, v.specialization)
} }
case Array_Type: case ^Array_Type:
visit_expr(p, v.tag) visit_expr(p, v.tag)
push_generic_token(p, .Open_Bracket, 1) push_generic_token(p, .Open_Bracket, 1)
visit_expr(p, v.len) visit_expr(p, v.len)
push_generic_token(p, .Close_Bracket, 0) push_generic_token(p, .Close_Bracket, 0)
merge_next_token(p) merge_next_token(p)
visit_expr(p, v.elem) visit_expr(p, v.elem)
case Map_Type: case ^Map_Type:
push_generic_token(p, .Map, 1) push_generic_token(p, .Map, 1)
push_generic_token(p, .Open_Bracket, 0) push_generic_token(p, .Open_Bracket, 0)
visit_expr(p, v.key) visit_expr(p, v.key)
push_generic_token(p, .Close_Bracket, 0) push_generic_token(p, .Close_Bracket, 0)
merge_next_token(p) merge_next_token(p)
visit_expr(p, v.value) visit_expr(p, v.value)
case Helper_Type: case ^Helper_Type:
visit_expr(p, v.type) visit_expr(p, v.type)
case ^Multi_Pointer_Type:
push_generic_token(p, .Open_Bracket, 1)
push_generic_token(p, .Pointer, 0)
push_generic_token(p, .Close_Bracket, 0)
visit_expr(p, v.elem)
case ^Matrix_Type:
push_generic_token(p, .Matrix, 1)
push_generic_token(p, .Open_Bracket, 0)
visit_expr(p, v.row_count)
push_generic_token(p, .Comma, 0)
visit_expr(p, v.column_count)
push_generic_token(p, .Close_Bracket, 0)
visit_expr(p, v.elem)
case: case:
panic(fmt.aprint(expr.derived)) panic(fmt.aprint(expr.derived))
} }
@@ -1348,7 +1386,7 @@ visit_field_list :: proc(p: ^Printer, list: ^ast.Field_List, options := List_Opt
} }
} }
visit_proc_type :: proc(p: ^Printer, proc_type: ast.Proc_Type, is_proc_lit := false) { visit_proc_type :: proc(p: ^Printer, proc_type: ^ast.Proc_Type, is_proc_lit := false) {
if is_proc_lit { if is_proc_lit {
push_format_token(p, Format_Token { push_format_token(p, Format_Token {
kind = .Proc, kind = .Proc,
@@ -1392,7 +1430,7 @@ visit_proc_type :: proc(p: ^Printer, proc_type: ast.Proc_Type, is_proc_lit := fa
} else if len(proc_type.results.list) == 1 { } else if len(proc_type.results.list) == 1 {
for name in proc_type.results.list[0].names { for name in proc_type.results.list[0].names {
if ident, ok := name.derived.(ast.Ident); ok { if ident, ok := name.derived.(^ast.Ident); ok {
if ident.name != "_" { if ident.name != "_" {
use_parens = true use_parens = true
} }
@@ -1410,19 +1448,19 @@ visit_proc_type :: proc(p: ^Printer, proc_type: ast.Proc_Type, is_proc_lit := fa
} }
} }
visit_binary_expr :: proc(p: ^Printer, binary: ast.Binary_Expr) { visit_binary_expr :: proc(p: ^Printer, binary: ^ast.Binary_Expr) {
move_line(p, binary.left.pos) move_line(p, binary.left.pos)
if v, ok := binary.left.derived.(ast.Binary_Expr); ok { if v, ok := binary.left.derived.(^ast.Binary_Expr); ok {
visit_binary_expr(p, v) visit_binary_expr(p, v)
} else { } else {
visit_expr(p, binary.left) visit_expr(p, binary.left)
} }
either_implicit_selector := false either_implicit_selector := false
if _, ok := binary.left.derived.(ast.Implicit_Selector_Expr); ok { if _, ok := binary.left.derived.(^ast.Implicit_Selector_Expr); ok {
either_implicit_selector = true either_implicit_selector = true
} else if _, ok := binary.right.derived.(ast.Implicit_Selector_Expr); ok { } else if _, ok := binary.right.derived.(^ast.Implicit_Selector_Expr); ok {
either_implicit_selector = true either_implicit_selector = true
} }
@@ -1439,7 +1477,7 @@ visit_binary_expr :: proc(p: ^Printer, binary: ast.Binary_Expr) {
move_line(p, binary.right.pos) move_line(p, binary.right.pos)
if v, ok := binary.right.derived.(ast.Binary_Expr); ok { if v, ok := binary.right.derived.(^ast.Binary_Expr); ok {
visit_binary_expr(p, v) visit_binary_expr(p, v)
} else { } else {
visit_expr(p, binary.right) visit_expr(p, binary.right)
@@ -1499,7 +1537,7 @@ visit_signature_list :: proc(p: ^Printer, list: ^ast.Field_List, remove_blank :=
named := false named := false
for name in field.names { for name in field.names {
if ident, ok := name.derived.(ast.Ident); ok { if ident, ok := name.derived.(^ast.Ident); ok {
//for some reason the parser uses _ to mean empty //for some reason the parser uses _ to mean empty
if ident.name != "_" || !remove_blank { if ident.name != "_" || !remove_blank {
named = true named = true
core/reflect/reflect.odin
+13 -1
View File
@@ -365,6 +365,19 @@ index :: proc(val: any, i: int, loc := #caller_location) -> any {
return nil return nil
} }
deref :: proc(val: any) -> any {
if val != nil {
ti := type_info_base(type_info_of(val.id))
if info, ok := ti.variant.(Type_Info_Pointer); ok {
return any{
(^rawptr)(val.data)^,
info.elem.id,
}
}
}
return val
}
// Struct_Tag represents the type of the string of a struct field // Struct_Tag represents the type of the string of a struct field
@@ -680,7 +693,6 @@ union_variant_typeid :: proc(a: any) -> typeid {
return nil return nil
} }
panic("expected a union to reflect.union_variant_typeid") panic("expected a union to reflect.union_variant_typeid")
} }
get_union_variant_raw_tag :: proc(a: any) -> i64 { get_union_variant_raw_tag :: proc(a: any) -> i64 {