strip colons and update ast to use unions

1 files changed, 1415 insertions, 1421 deletions

diff --git a/src/analysis/analysis.odin b/src/analysis/analysis.odin
index 34e8ac1..400bde6 100644
--- a/src/analysis/analysis.odin
+++ b/src/analysis/analysis.odin
@@ -104,15 +104,15 @@ make_ast_context :: proc(file: ast.File, imports: []common.Package, package_name
 		current_package = package_name,
 		uri = uri,
 		allocator = allocator,
-	};
+	}
 
-	add_local_group(&ast_context, 0);
+	add_local_group(&ast_context, 0)
 
-	when ODIN_OS == "windows" {
-		ast_context.uri = strings.to_lower(ast_context.uri, allocator);
+	when ODIN_OS == .Windows  {
+		ast_context.uri = strings.to_lower(ast_context.uri, allocator)
 	}
 
-	return ast_context;
+	return ast_context
 }
 
 tokenizer_error_handler :: proc(pos: tokenizer.Pos, msg: string, args: ..any) {
@@ -126,205 +126,203 @@ resolve_poly_spec :: proc {
 	resolve_poly_spec_node,
 	resolve_poly_spec_array,
 	resolve_poly_spec_dynamic_array,
-};
+}
 
 resolve_poly_spec_array :: proc(ast_context: ^AstContext, call_array: $A/[]^$T, spec_array: $D/[]^$K, poly_map: ^map[string]^ast.Expr) {
 	if len(call_array) != len(spec_array) {
-		return;
+		return
 	}
 
 	for elem, i in call_array {
-		resolve_poly_spec(ast_context, elem, spec_array[i], poly_map);
+		resolve_poly_spec(ast_context, elem, spec_array[i], poly_map)
 	}
 }
 
 resolve_poly_spec_dynamic_array :: proc(ast_context: ^AstContext, call_array: $A/[dynamic]^$T, spec_array: $D/[dynamic]^$K, poly_map: ^map[string]^ast.Expr) {
 	if len(call_array) != len(spec_array) {
-		return;
+		return
 	}
 
 	for elem, i in call_array {
-		resolve_poly_spec(ast_context, elem, spec_array[i], poly_map);
+		resolve_poly_spec(ast_context, elem, spec_array[i], poly_map)
 	}
 }
 
 get_poly_node_to_expr :: proc(node: ^ast.Node) -> ^ast.Expr {
-	using ast;
+	using ast
 
-	switch v in node.derived {
-	case Ident:
-		return cast(^Expr)node;
+	#partial switch v in node.derived {
+	case ^Ident:
+		return cast(^Expr)node
 	case:
-		log.warnf("Unhandled poly to node kind %v", v);
+		log.warnf("Unhandled poly to node kind %v", v)
 	}
 
-	return nil;
+	return nil
 }
 
 resolve_poly_spec_node :: proc(ast_context: ^AstContext, call_node: ^ast.Node, spec_node: ^ast.Node, poly_map: ^map[string]^ast.Expr) {
-	using ast;
+	using ast
 
 	if call_node == nil || spec_node == nil {
-		return;
+		return
 	}
 
-	switch m in spec_node.derived {
-	case Bad_Expr:
-	case Ident:
-	case Implicit:
-	case Undef:
-	case Basic_Lit:
-	case Poly_Type:	
+	#partial switch m in spec_node.derived {
+	case ^Bad_Expr:
+	case ^Ident:
+	case ^Implicit:
+	case ^Undef:
+	case ^Basic_Lit:
+	case ^Poly_Type:	
 		if expr := get_poly_node_to_expr(call_node); expr != nil {
-			poly_map[m.type.name] = expr;
-		}
-	case Ellipsis:
-		if n, ok := call_node.derived.(Ellipsis); ok {
-			resolve_poly_spec(ast_context, n.expr, m.expr, poly_map);
-		}
-	case Tag_Expr:
-		if n, ok := call_node.derived.(Tag_Expr); ok {
-			resolve_poly_spec(ast_context, n.expr, m.expr, poly_map);
-		}
-	case Unary_Expr:
-		if n, ok := call_node.derived.(Unary_Expr); ok {
-			resolve_poly_spec(ast_context, n.expr, m.expr, poly_map);
-		}
-	case Binary_Expr:
-		if n, ok := call_node.derived.(Binary_Expr); ok {
-			resolve_poly_spec(ast_context, n.left, m.left, poly_map);
-			resolve_poly_spec(ast_context, n.right, m.right, poly_map);
-		}
-	case Paren_Expr:
-		if n, ok := call_node.derived.(Paren_Expr); ok {
-			resolve_poly_spec(ast_context, n.expr, m.expr, poly_map);
-		}
-	case Selector_Expr:
-		if n, ok := call_node.derived.(Selector_Expr); ok {
-			resolve_poly_spec(ast_context, n.expr, m.expr, poly_map);
-			resolve_poly_spec(ast_context, n.field, m.field, poly_map);
-		}
-	case Slice_Expr:
-		if n, ok := call_node.derived.(Slice_Expr); ok {
-			resolve_poly_spec(ast_context, n.expr, m.expr, poly_map);
-			resolve_poly_spec(ast_context, n.low, m.low, poly_map);
-			resolve_poly_spec(ast_context, n.high, m.high, poly_map);
-		}
-	case Distinct_Type:
-		if n, ok := call_node.derived.(Distinct_Type); ok {
-			resolve_poly_spec(ast_context, n.type, m.type, poly_map);
-		}
-	case Proc_Type:
-		if n, ok := call_node.derived.(Proc_Type); ok {
-			resolve_poly_spec(ast_context, n.params, m.params, poly_map);
-			resolve_poly_spec(ast_context, n.results, m.results, poly_map);
-		}
-	case Pointer_Type:
-		if n, ok := call_node.derived.(Pointer_Type); ok {
-			resolve_poly_spec(ast_context, n.elem, m.elem, poly_map);
-		}
-	case Array_Type:
-		if n, ok := call_node.derived.(Array_Type); ok {
-			resolve_poly_spec(ast_context, n.len, m.len, poly_map);
-			resolve_poly_spec(ast_context, n.elem, m.elem, poly_map);
-		}
-	case Dynamic_Array_Type:
-		if n, ok := call_node.derived.(Dynamic_Array_Type); ok {
-			resolve_poly_spec(ast_context, n.elem, m.elem, poly_map);
-		}
-	case Struct_Type:
-		if n, ok := call_node.derived.(Struct_Type); ok {
-			resolve_poly_spec(ast_context, n.poly_params, m.poly_params, poly_map);
-			resolve_poly_spec(ast_context, n.align, m.align, poly_map);
-			resolve_poly_spec(ast_context, n.fields, m.fields, poly_map);
-		}
-	case Field:
-		if n, ok := call_node.derived.(Field); ok {
-			resolve_poly_spec(ast_context, n.names, m.names, poly_map);
-			resolve_poly_spec(ast_context, n.type, m.type, poly_map);
-			resolve_poly_spec(ast_context, n.default_value, m.default_value, poly_map);
-		}
-	case Field_List:
-		if n, ok := call_node.derived.(Field_List); ok {
-			resolve_poly_spec(ast_context, n.list, m.list, poly_map);
-		}
-	case Field_Value:
-		if n, ok := call_node.derived.(Field_Value); ok {
-			resolve_poly_spec(ast_context, n.field, m.field, poly_map);
-			resolve_poly_spec(ast_context, n.value, m.value, poly_map);
-		}
-	case Union_Type:
-		if n, ok := call_node.derived.(Union_Type); ok {
-			resolve_poly_spec(ast_context, n.poly_params, m.poly_params, poly_map);
-			resolve_poly_spec(ast_context, n.align, m.align, poly_map);
-			resolve_poly_spec(ast_context, n.variants, m.variants, poly_map);
-		}
-	case Enum_Type:
-		if n, ok := call_node.derived.(Enum_Type); ok {
-			resolve_poly_spec(ast_context, n.base_type, m.base_type, poly_map);
-			resolve_poly_spec(ast_context, n.fields, m.fields, poly_map);
-		}
-	case Bit_Set_Type:
-		if n, ok := call_node.derived.(Bit_Set_Type); ok {
-			resolve_poly_spec(ast_context, n.elem, m.elem, poly_map);
-			resolve_poly_spec(ast_context, n.underlying, m.underlying, poly_map);
-		}
-	case Map_Type:
-		if n, ok := call_node.derived.(Map_Type); ok {
-			resolve_poly_spec(ast_context, n.key, m.key, poly_map);
-			resolve_poly_spec(ast_context, n.value, m.value, poly_map);
-		}
-	case Call_Expr:
-		if n, ok := call_node.derived.(Call_Expr); ok {
-			resolve_poly_spec(ast_context, n.expr, m.expr, poly_map);
-			resolve_poly_spec(ast_context, n.args, m.args, poly_map);
-		}
-	case Typeid_Type:
-		if n, ok := call_node.derived.(Typeid_Type); ok {
-			resolve_poly_spec(ast_context, n.specialization, m.specialization, poly_map);
+			poly_map[m.type.name] = expr
+		}
+	case ^Ellipsis:
+		if n, ok := call_node.derived.(^Ellipsis); ok {
+			resolve_poly_spec(ast_context, n.expr, m.expr, poly_map)
+		}
+	case ^Tag_Expr:
+		if n, ok := call_node.derived.(^Tag_Expr); ok {
+			resolve_poly_spec(ast_context, n.expr, m.expr, poly_map)
+		}
+	case ^Unary_Expr:
+		if n, ok := call_node.derived.(^Unary_Expr); ok {
+			resolve_poly_spec(ast_context, n.expr, m.expr, poly_map)
+		}
+	case ^Binary_Expr:
+		if n, ok := call_node.derived.(^Binary_Expr); ok {
+			resolve_poly_spec(ast_context, n.left, m.left, poly_map)
+			resolve_poly_spec(ast_context, n.right, m.right, poly_map)
+		}
+	case ^Paren_Expr:
+		if n, ok := call_node.derived.(^Paren_Expr); ok {
+			resolve_poly_spec(ast_context, n.expr, m.expr, poly_map)
+		}
+	case ^Selector_Expr:
+		if n, ok := call_node.derived.(^Selector_Expr); ok {
+			resolve_poly_spec(ast_context, n.expr, m.expr, poly_map)
+			resolve_poly_spec(ast_context, n.field, m.field, poly_map)
+		}
+	case ^Slice_Expr:
+		if n, ok := call_node.derived.(^Slice_Expr); ok {
+			resolve_poly_spec(ast_context, n.expr, m.expr, poly_map)
+			resolve_poly_spec(ast_context, n.low, m.low, poly_map)
+			resolve_poly_spec(ast_context, n.high, m.high, poly_map)
+		}
+	case ^Distinct_Type:
+		if n, ok := call_node.derived.(^Distinct_Type); ok {
+			resolve_poly_spec(ast_context, n.type, m.type, poly_map)
+		}
+	case ^Proc_Type:
+		if n, ok := call_node.derived.(^Proc_Type); ok {
+			resolve_poly_spec(ast_context, n.params, m.params, poly_map)
+			resolve_poly_spec(ast_context, n.results, m.results, poly_map)
+		}
+	case ^Pointer_Type:
+		if n, ok := call_node.derived.(^Pointer_Type); ok {
+			resolve_poly_spec(ast_context, n.elem, m.elem, poly_map)
+		}
+	case ^Array_Type:
+		if n, ok := call_node.derived.(^Array_Type); ok {
+			resolve_poly_spec(ast_context, n.len, m.len, poly_map)
+			resolve_poly_spec(ast_context, n.elem, m.elem, poly_map)
+		}
+	case ^Dynamic_Array_Type:
+		if n, ok := call_node.derived.(^Dynamic_Array_Type); ok {
+			resolve_poly_spec(ast_context, n.elem, m.elem, poly_map)
+		}
+	case ^Struct_Type:
+		if n, ok := call_node.derived.(^Struct_Type); ok {
+			resolve_poly_spec(ast_context, n.poly_params, m.poly_params, poly_map)
+			resolve_poly_spec(ast_context, n.align, m.align, poly_map)
+			resolve_poly_spec(ast_context, n.fields, m.fields, poly_map)
+		}
+	case ^Field:
+		if n, ok := call_node.derived.(^Field); ok {
+			resolve_poly_spec(ast_context, n.names, m.names, poly_map)
+			resolve_poly_spec(ast_context, n.type, m.type, poly_map)
+			resolve_poly_spec(ast_context, n.default_value, m.default_value, poly_map)
+		}
+	case ^Field_List:
+		if n, ok := call_node.derived.(^Field_List); ok {
+			resolve_poly_spec(ast_context, n.list, m.list, poly_map)
+		}
+	case ^Field_Value:
+		if n, ok := call_node.derived.(^Field_Value); ok {
+			resolve_poly_spec(ast_context, n.field, m.field, poly_map)
+			resolve_poly_spec(ast_context, n.value, m.value, poly_map)
+		}
+	case ^Union_Type:
+		if n, ok := call_node.derived.(^Union_Type); ok {
+			resolve_poly_spec(ast_context, n.poly_params, m.poly_params, poly_map)
+			resolve_poly_spec(ast_context, n.align, m.align, poly_map)
+			resolve_poly_spec(ast_context, n.variants, m.variants, poly_map)
+		}
+	case ^Enum_Type:
+		if n, ok := call_node.derived.(^Enum_Type); ok {
+			resolve_poly_spec(ast_context, n.base_type, m.base_type, poly_map)
+			resolve_poly_spec(ast_context, n.fields, m.fields, poly_map)
+		}
+	case ^Bit_Set_Type:
+		if n, ok := call_node.derived.(^Bit_Set_Type); ok {
+			resolve_poly_spec(ast_context, n.elem, m.elem, poly_map)
+			resolve_poly_spec(ast_context, n.underlying, m.underlying, poly_map)
+		}
+	case ^Map_Type:
+		if n, ok := call_node.derived.(^Map_Type); ok {
+			resolve_poly_spec(ast_context, n.key, m.key, poly_map)
+			resolve_poly_spec(ast_context, n.value, m.value, poly_map)
+		}
+	case ^Call_Expr:
+		if n, ok := call_node.derived.(^Call_Expr); ok {
+			resolve_poly_spec(ast_context, n.expr, m.expr, poly_map)
+			resolve_poly_spec(ast_context, n.args, m.args, poly_map)
+		}
+	case ^Typeid_Type:
+		if n, ok := call_node.derived.(^Typeid_Type); ok {
+			resolve_poly_spec(ast_context, n.specialization, m.specialization, poly_map)
 		}
 	case:
-		log.error("Unhandled poly node kind: %T", m);
+		log.error("Unhandled poly node kind: %T", m)
 	}
 }
 
 resolve_type_comp_literal :: proc(ast_context: ^AstContext, position_context: ^DocumentPositionContext, current_symbol: index.Symbol, current_comp_lit: ^ast.Comp_Lit) -> (index.Symbol, ^ast.Comp_Lit, bool) {
-
 	if position_context.comp_lit == current_comp_lit {
-		return current_symbol, current_comp_lit, true;
+		return current_symbol, current_comp_lit, true
 	} else if current_comp_lit == nil {
 		return {}, nil, false
 	}
 
 	if current_comp_lit == nil {
-		return {}, nil, false;
+		return {}, nil, false
 	}
 
-	element_index := 0;
+	element_index := 0
 
 	for elem, i in current_comp_lit.elems {
 		if position_in_node(elem, position_context.position) {
-			element_index = i;
+			element_index = i
 		}
 	}
 
 	for elem in current_comp_lit.elems {
-
 		if !position_in_node(elem, position_context.position) {
-			continue;
+			continue
 		}
 		
-		if field_value, ok := elem.derived.(ast.Field_Value); ok { //named
-			if comp_lit, ok := field_value.value.derived.(ast.Comp_Lit); ok {
+		if field_value, ok := elem.derived.(^ast.Field_Value); ok { //named
+			if comp_lit, ok := field_value.value.derived.(^ast.Comp_Lit); ok {
 				if s, ok := current_symbol.value.(index.SymbolStructValue); ok {
 					for name, i in s.names {
-						if name == field_value.field.derived.(ast.Ident).name {
+						if name == field_value.field.derived.(^ast.Ident).name {
 							if symbol, ok := resolve_type_expression(ast_context, s.types[i]); ok {
 								//Stop at bitset, because we don't want to enter a comp_lit of a bitset
 								if _, ok := symbol.value.(index.SymbolBitSetValue); ok {
-									return current_symbol, current_comp_lit, true;
+									return current_symbol, current_comp_lit, true
 								}
-								return resolve_type_comp_literal(ast_context, position_context, symbol, cast(^ast.Comp_Lit)field_value.value);
+								return resolve_type_comp_literal(ast_context, position_context, symbol, cast(^ast.Comp_Lit)field_value.value)
 							}
 						}
 					}
@@ -334,166 +332,166 @@ resolve_type_comp_literal :: proc(ast_context: ^AstContext, position_context: ^D
 			if s, ok := current_symbol.value.(index.SymbolStructValue); ok {
 
 				if len(s.types) <= element_index {
-					return {}, {}, false;
+					return {}, {}, false
 				}
 
 				if symbol, ok := resolve_type_expression(ast_context, s.types[element_index]); ok {
 					//Stop at bitset, because we don't want to enter a comp_lit of a bitset
 					if _, ok := symbol.value.(index.SymbolBitSetValue); ok {
-						return current_symbol, current_comp_lit, true;
+						return current_symbol, current_comp_lit, true
 					}
-					return resolve_type_comp_literal(ast_context, position_context, symbol, cast(^ast.Comp_Lit)field_value.value);
+					return resolve_type_comp_literal(ast_context, position_context, symbol, cast(^ast.Comp_Lit)field_value.value)
 				}
 			}
 		}
 	}
 
-	return current_symbol, current_comp_lit, true;
+	return current_symbol, current_comp_lit, true
 }
 
 resolve_generic_function :: proc {
 	resolve_generic_function_ast,
 	resolve_generic_function_symbol,
-};
+}
 
 resolve_generic_function_symbol :: proc(ast_context: ^AstContext, params: []^ast.Field, results: []^ast.Field) -> (index.Symbol, bool) {
-	using ast;
+	using ast
 
 	if params == nil {
-		return {}, false;
+		return {}, false
 	}
 
 	if results == nil {
-		return {}, false;
+		return {}, false
 	}
 
 	if ast_context.call == nil {
-		return {}, false;
+		return {}, false
 	}
 
-	call_expr := ast_context.call;
-	poly_map := make(map[string]^Expr, 0, context.temp_allocator);
-	i := 0;
-	count_required_params := 0;	
+	call_expr := ast_context.call
+	poly_map := make(map[string]^Expr, 0, context.temp_allocator)
+	i := 0
+	count_required_params := 0	
 
 	for param in params {
 		if param.default_value == nil {
-			count_required_params += 1;
+			count_required_params += 1
 		}
 
 		for name in param.names {
 			if len(call_expr.args) <= i {
-				break;
+				break
 			}
 
-			if poly, ok := name.derived.(Poly_Type); ok {
-				poly_map[poly.type.name] = call_expr.args[i];
+			if poly, ok := name.derived.(^Poly_Type); ok {
+				poly_map[poly.type.name] = call_expr.args[i]
 			}
 
 			if param.type == nil {
-				continue;
+				continue
 			}
 
-			if type_id, ok := param.type.derived.(Typeid_Type); ok {
+			if type_id, ok := param.type.derived.(^Typeid_Type); ok {
 				if type_id.specialization != nil && !common.node_equal(call_expr.args[i], type_id.specialization)  {
-					return {}, false;
+					return {}, false
 				}
 			}
 
-			resolve_poly_spec_node(ast_context, call_expr.args[i], param.type, &poly_map);	
+			resolve_poly_spec_node(ast_context, call_expr.args[i], param.type, &poly_map)	
 
-			i += 1;
+			i += 1
 		}
 	}
 
 	if count_required_params > len(call_expr.args) || count_required_params == 0 || len(call_expr.args) == 0 {
-		return {}, false;
+		return {}, false
 	}
 
-	function_name := "";
-	function_range: common.Range;
+	function_name := ""
+	function_range: common.Range
 
-	if ident, ok := call_expr.expr.derived.(Ident); ok {
-		function_name = ident.name;
-		function_range = common.get_token_range(ident, ast_context.file.src);
-	} else if selector, ok := call_expr.expr.derived.(Selector_Expr); ok {
-		function_name = selector.field.name;
-		function_range = common.get_token_range(selector, ast_context.file.src);
+	if ident, ok := call_expr.expr.derived.(^Ident); ok {
+		function_name = ident.name
+		function_range = common.get_token_range(ident, ast_context.file.src)
+	} else if selector, ok := call_expr.expr.derived.(^Selector_Expr); ok {
+		function_name = selector.field.name
+		function_range = common.get_token_range(selector, ast_context.file.src)
 	} else {
-		return {}, false;
+		return {}, false
 	}
 
 	symbol := index.Symbol {
 		range = function_range,
 		type = .Function,
 		name = function_name,
-	};
+	}
 
-	return_types := make([dynamic]^ast.Field, ast_context.allocator);
-	argument_types := make([dynamic]^ast.Field, ast_context.allocator);
+	return_types := make([dynamic]^ast.Field, ast_context.allocator)
+	argument_types := make([dynamic]^ast.Field, ast_context.allocator)
 
 	for result in results {
 		if result.type == nil {
-			continue;
+			continue
 		}
 
-		ident, ok := common.unwrap_pointer(result.type);
+		ident, ok := common.unwrap_pointer(result.type)
 
 		if ok {
 			if m, ok := poly_map[ident.name]; ok {
-				field := cast(^Field)index.clone_node(result, ast_context.allocator, nil);
-				field.type = m;
-				append(&return_types, field);
+				field := cast(^Field)index.clone_node(result, ast_context.allocator, nil)
+				field.type = m
+				append(&return_types, field)
 			} else {
-				append(&return_types, result);
+				append(&return_types, result)
 			}
 		} else {
-			append(&return_types, result);
+			append(&return_types, result)
 		}
 	}
 
 	for param in params {
 		if len(param.names) == 0 {
-			continue;
+			continue
 		}
 
 		//check the name for poly
-		if poly_type, ok := param.names[0].derived.(ast.Poly_Type); ok && param.type != nil {
+		if poly_type, ok := param.names[0].derived.(^ast.Poly_Type); ok && param.type != nil {
 			if m, ok := poly_map[poly_type.type.name]; ok {
-				field := cast(^Field)index.clone_node(param, ast_context.allocator, nil);
-				field.type = m;
-				append(&argument_types, field);
+				field := cast(^Field)index.clone_node(param, ast_context.allocator, nil)
+				field.type = m
+				append(&argument_types, field)
 			}
 		} else {
-			append(&argument_types, param);
+			append(&argument_types, param)
 		}
 	}
 
 	symbol.value = index.SymbolProcedureValue {
 		return_types = return_types[:],
 		arg_types = argument_types[:],
-	};
+	}
 
-	return symbol, true;
+	return symbol, true
 }
 
 resolve_generic_function_ast :: proc(ast_context: ^AstContext, proc_lit: ast.Proc_Lit) -> (index.Symbol, bool) {
 
-	using ast;
+	using ast
 
 	if proc_lit.type.params == nil {
-		return index.Symbol {}, false;
+		return index.Symbol {}, false
 	}
 
 	if proc_lit.type.results == nil {
-		return index.Symbol {}, false;
+		return index.Symbol {}, false
 	}
 
 	if ast_context.call == nil {
-		return index.Symbol {}, false;
+		return index.Symbol {}, false
 	}
 
-	return resolve_generic_function_symbol(ast_context, proc_lit.type.params.list, proc_lit.type.results.list);
+	return resolve_generic_function_symbol(ast_context, proc_lit.type.params.list, proc_lit.type.results.list)
 }
 
 is_symbol_same_typed :: proc(ast_context: ^AstContext, a, b: index.Symbol, flags: ast.Field_Flags = {}) -> bool {
@@ -503,59 +501,59 @@ is_symbol_same_typed :: proc(ast_context: ^AstContext, a, b: index.Symbol, flags
 			switch untyped.type {
 			case .Integer:
 				switch basic.ident.name {
-				case "int", "uint", "u32", "i32", "u8", "i8", "u64", "u16", "i16": return true;
-				case: return false;
+				case "int", "uint", "u32", "i32", "u8", "i8", "u64", "u16", "i16": return true
+				case: return false
 				}
 			case .Bool:
 				switch basic.ident.name {
-				case "bool", "b32", "b64": return true;
-				case: return false;
+				case "bool", "b32", "b64": return true
+				case: return false
 				}
 			case .String:
 				switch basic.ident.name {
-				case "string", "cstring": return true;
-				case: return false;
+				case "string", "cstring": return true
+				case: return false
 				}
 			case .Float:
 				switch basic.ident.name {
-				case "f32", "f64": return true;
-				case: return false;
+				case "f32", "f64": return true
+				case: return false
 				}
 			}
 		}
 	}
 
-	a_id := reflect.union_variant_typeid(a.value);
-	b_id := reflect.union_variant_typeid(b.value);
+	a_id := reflect.union_variant_typeid(a.value)
+	b_id := reflect.union_variant_typeid(b.value)
 
 	if a_id != b_id {
-		return false;
+		return false
 	}
 
 	if a.pointers != b.pointers {
-		return false;
+		return false
 	}
 
 	if .Distinct in a.flags != .Distinct in b.flags {
-		return false;
+		return false
 	}
 
 	if .Distinct in a.flags == .Distinct in b.flags && 
 	   .Distinct in a.flags &&
 	   a.name == b.name &&
 	   a.pkg == b.pkg {
-		return true;
+		return true
 	} 
 
 	#partial switch b_value in b.value {
 	case index.SymbolBasicValue:
 		if .Auto_Cast in flags {
-			return true;
+			return true
 		} else if .Any_Int in flags {
 			//Temporary - make a function that finds the base type of basic values 
 			//This code only works with non distinct ints
 			switch a.name {
-				case "int", "uint", "u32", "i32", "u8", "i8", "u64", "u16", "i16": return true;
+				case "int", "uint", "u32", "i32", "u8", "i8", "u64", "u16", "i16": return true
 			}
 		} 
 	}
@@ -564,211 +562,211 @@ is_symbol_same_typed :: proc(ast_context: ^AstContext, a, b: index.Symbol, flags
 	case index.SymbolBasicValue:
 		return a.name == b.name && a.pkg == b.pkg
 	case index.SymbolStructValue, index.SymbolEnumValue, index.SymbolUnionValue, index.SymbolBitSetValue:
-		return a.name == b.name && a.pkg == b.pkg;
+		return a.name == b.name && a.pkg == b.pkg
 	case index.SymbolSliceValue:
-		b_value := b.value.(index.SymbolSliceValue);
+		b_value := b.value.(index.SymbolSliceValue)
 
-		a_symbol: index.Symbol;
-		b_symbol: index.Symbol;
-		ok: bool;
+		a_symbol: index.Symbol
+		b_symbol: index.Symbol
+		ok: bool
 
-		a_symbol, ok = resolve_type_expression(ast_context, a_value.expr);
+		a_symbol, ok = resolve_type_expression(ast_context, a_value.expr)
 
 		if !ok {
-			return false;
+			return false
 		}
 
-		b_symbol, ok = resolve_type_expression(ast_context, b_value.expr);
+		b_symbol, ok = resolve_type_expression(ast_context, b_value.expr)
 
 		if !ok {
-			return false;
+			return false
 		}
 
-		return is_symbol_same_typed(ast_context, a_symbol, b_symbol);
+		return is_symbol_same_typed(ast_context, a_symbol, b_symbol)
 	case index.SymbolFixedArrayValue:
-		b_value := b.value.(index.SymbolFixedArrayValue);
+		b_value := b.value.(index.SymbolFixedArrayValue)
 
-		a_symbol: index.Symbol;
-		b_symbol: index.Symbol;
-		ok: bool;
+		a_symbol: index.Symbol
+		b_symbol: index.Symbol
+		ok: bool
 
-		a_symbol, ok = resolve_type_expression(ast_context, a_value.expr);
+		a_symbol, ok = resolve_type_expression(ast_context, a_value.expr)
 
 		if !ok {
-			return false;
+			return false
 		}
 
-		b_symbol, ok = resolve_type_expression(ast_context, b_value.expr);
+		b_symbol, ok = resolve_type_expression(ast_context, b_value.expr)
 
 		if !ok {
-			return false;
+			return false
 		}
 
-		return is_symbol_same_typed(ast_context, a_symbol, b_symbol);
+		return is_symbol_same_typed(ast_context, a_symbol, b_symbol)
 	case index.SymbolDynamicArrayValue:
-		b_value := b.value.(index.SymbolDynamicArrayValue);
+		b_value := b.value.(index.SymbolDynamicArrayValue)
 
-		a_symbol: index.Symbol;
-		b_symbol: index.Symbol;
-		ok: bool;
+		a_symbol: index.Symbol
+		b_symbol: index.Symbol
+		ok: bool
 
-		a_symbol, ok = resolve_type_expression(ast_context, a_value.expr);
+		a_symbol, ok = resolve_type_expression(ast_context, a_value.expr)
 
 		if !ok {
-			return false;
+			return false
 		}
 
-		b_symbol, ok = resolve_type_expression(ast_context, b_value.expr);
+		b_symbol, ok = resolve_type_expression(ast_context, b_value.expr)
 
 		if !ok {
-			return false;
+			return false
 		}
 
-		return is_symbol_same_typed(ast_context, a_symbol, b_symbol);
+		return is_symbol_same_typed(ast_context, a_symbol, b_symbol)
 	case index.SymbolMapValue:
-		b_value := b.value.(index.SymbolMapValue);
+		b_value := b.value.(index.SymbolMapValue)
 
-		a_key_symbol: index.Symbol;
-		b_key_symbol: index.Symbol;
-		a_value_symbol: index.Symbol;
-		b_value_symbol: index.Symbol;
-		ok: bool;
+		a_key_symbol: index.Symbol
+		b_key_symbol: index.Symbol
+		a_value_symbol: index.Symbol
+		b_value_symbol: index.Symbol
+		ok: bool
 
-		a_key_symbol, ok = resolve_type_expression(ast_context, a_value.key);
+		a_key_symbol, ok = resolve_type_expression(ast_context, a_value.key)
 
 		if !ok {
-			return false;
+			return false
 		}
 
-		b_key_symbol, ok = resolve_type_expression(ast_context, b_value.key);
+		b_key_symbol, ok = resolve_type_expression(ast_context, b_value.key)
 
 		if !ok {
-			return false;
+			return false
 		}
 
-		a_value_symbol, ok = resolve_type_expression(ast_context, a_value.value);
+		a_value_symbol, ok = resolve_type_expression(ast_context, a_value.value)
 
 		if !ok {
-			return false;
+			return false
 		}
 
-		b_value_symbol, ok = resolve_type_expression(ast_context, b_value.value);
+		b_value_symbol, ok = resolve_type_expression(ast_context, b_value.value)
 
 		if !ok {
-			return false;
+			return false
 		}
 
-		return is_symbol_same_typed(ast_context, a_key_symbol, b_key_symbol) && is_symbol_same_typed(ast_context, a_value_symbol, b_value_symbol); 
+		return is_symbol_same_typed(ast_context, a_key_symbol, b_key_symbol) && is_symbol_same_typed(ast_context, a_value_symbol, b_value_symbol) 
 	}
 	
-	return false;
+	return false
 }
 
 get_field_list_name_index :: proc(name: string, field_list: []^ast.Field) -> (int, bool) {
 	for field, i in field_list {
 		for field_name in field.names {
-			if ident, ok := field_name.derived.(ast.Ident); ok {
+			if ident, ok := field_name.derived.(^ast.Ident); ok {
 				if name == ident.name {
-					return i, true;
+					return i, true
 				}
 			}		
 		}
 	}
 
-	return 0, false;
+	return 0, false
 }
 
 /*
 	Figure out which function the call expression is using out of the list from proc group
 */
 resolve_function_overload :: proc(ast_context: ^AstContext, group: ast.Proc_Group) -> (index.Symbol, bool) {
-	using ast;
+	using ast
 
-	call_expr := ast_context.call;
+	call_expr := ast_context.call
 
-	candidates := make([dynamic]index.Symbol, context.temp_allocator);
+	candidates := make([dynamic]index.Symbol, context.temp_allocator)
 
 	for arg_expr in group.args {
 
 		next_fn: if f, ok := resolve_type_expression(ast_context, arg_expr); ok {
 
 			if call_expr == nil || len(call_expr.args) == 0 {
-				append(&candidates, f);
-				break next_fn;
+				append(&candidates, f)
+				break next_fn
 			}
 
 			if procedure, ok := f.value.(index.SymbolProcedureValue); ok {
 
-				count_required_params := 0;
+				count_required_params := 0
 
 				for arg in procedure.arg_types {
 					if arg.default_value == nil {
-						count_required_params += 1;
+						count_required_params += 1
 					}
 				}
 
 				if len(procedure.arg_types) < len(call_expr.args) {
-					continue;
+					continue
 				}
 
 				for arg, i in call_expr.args {
 
-					ast_context.use_locals = true;
+					ast_context.use_locals = true
 
-					call_symbol: index.Symbol;
-					arg_symbol:  index.Symbol;
-					ok:          bool;
-					i := i;
+					call_symbol: index.Symbol
+					arg_symbol:  index.Symbol
+					ok:          bool
+					i := i
 
-					if _, ok = arg.derived.(ast.Bad_Expr); ok {
-						continue;
+					if _, ok = arg.derived.(^ast.Bad_Expr); ok {
+						continue
 					}
 
 					//named parameter
-					if field, is_field := arg.derived.(ast.Field_Value); is_field {
-						call_symbol, ok = resolve_type_expression(ast_context, field.value);
+					if field, is_field := arg.derived.(^ast.Field_Value); is_field {
+						call_symbol, ok = resolve_type_expression(ast_context, field.value)
 						if !ok {
-							break next_fn;
+							break next_fn
 						}
 
-						if ident, is_ident := field.field.derived.(ast.Ident); is_ident {
-							i, ok = get_field_list_name_index(field.field.derived.(ast.Ident).name, procedure.arg_types);
+						if ident, is_ident := field.field.derived.(^ast.Ident); is_ident {
+							i, ok = get_field_list_name_index(field.field.derived.(^ast.Ident).name, procedure.arg_types)
 						} else {
-							break next_fn;
+							break next_fn
 						}
 					} else {
-						call_symbol, ok = resolve_type_expression(ast_context, arg);
+						call_symbol, ok = resolve_type_expression(ast_context, arg)
 					}
 
 					if !ok {	
-						break next_fn;
+						break next_fn
 					}
 
 					if p, ok := call_symbol.value.(index.SymbolProcedureValue); ok {
 						if len(p.return_types) != 1 {
-							break next_fn;
+							break next_fn
 						}
 						if s, ok := resolve_type_expression(ast_context, p.return_types[0].type); ok {
-							call_symbol = s;
+							call_symbol = s
 						}
 					}
 
 					if procedure.arg_types[i].type != nil {
-						arg_symbol, ok = resolve_type_expression(ast_context, procedure.arg_types[i].type);
+						arg_symbol, ok = resolve_type_expression(ast_context, procedure.arg_types[i].type)
 					} else {					
-						arg_symbol, ok = resolve_type_expression(ast_context, procedure.arg_types[i].default_value);
+						arg_symbol, ok = resolve_type_expression(ast_context, procedure.arg_types[i].default_value)
 					}
 
 					if !ok {			
-						break next_fn;
+						break next_fn
 					}
 
 					if !is_symbol_same_typed(ast_context, call_symbol, arg_symbol, procedure.arg_types[i].flags) {	
-						break next_fn;
+						break next_fn
 					} 
 				}
 	
-				append(&candidates, f);
+				append(&candidates, f)
 			}
 		}
 	}
@@ -781,300 +779,300 @@ resolve_function_overload :: proc(ast_context: ^AstContext, group: ast.Proc_Grou
 			value = index.SymbolAggregateValue {
 				symbols = candidates[:],
 			},
-		}, true;
+		}, true
 	} else if len(candidates) == 1 {
-		return candidates[0], true;
+		return candidates[0], true
 	}
 
-	return index.Symbol {}, false;
+	return index.Symbol {}, false
 }
 
 resolve_basic_lit :: proc(ast_context: ^AstContext, basic_lit: ast.Basic_Lit) -> (index.Symbol, bool) {
 	symbol := index.Symbol {
 		type = .Constant,
-	};
+	}
 
-	value: index.SymbolUntypedValue;
+	value: index.SymbolUntypedValue
 
 	if v, ok := strconv.parse_int(basic_lit.tok.text); ok {
-		value.type = .Integer;
+		value.type = .Integer
 	} else if v, ok := strconv.parse_bool(basic_lit.tok.text); ok {
-		value.type = .Bool;
+		value.type = .Bool
 	} else if v, ok := strconv.parse_f64(basic_lit.tok.text); ok {
-		value.type = .Float;
+		value.type = .Float
 	} else {
-		value.type = .String;
+		value.type = .String
 	}
 
 	symbol.pkg = ast_context.current_package
-	symbol.value = value;
+	symbol.value = value
 
-	return symbol, true;
+	return symbol, true
 }
 
 resolve_basic_directive :: proc(ast_context: ^AstContext, directive: ast.Basic_Directive, a := #caller_location) -> (index.Symbol, bool) {
 	switch directive.name {
 	case "caller_location":
-		ident := index.new_type(ast.Ident, directive.pos, directive.end, ast_context.allocator);
-		ident.name = "Source_Code_Location";
-		ast_context.current_package = ast_context.document_package;
+		ident := index.new_type(ast.Ident, directive.pos, directive.end, ast_context.allocator)
+		ident.name = "Source_Code_Location"
+		ast_context.current_package = ast_context.document_package
 		return resolve_type_identifier(ast_context, ident^)
 	}
 
-	return {}, false;
+	return {}, false
 }
 
 
 resolve_type_expression :: proc(ast_context: ^AstContext, node: ^ast.Expr) -> (index.Symbol, bool) {
 	if node == nil {
-		return {}, false;
+		return {}, false
 	}
 
-	saved_package := ast_context.current_package;
+	saved_package := ast_context.current_package
 
 	defer {
-		ast_context.current_package = saved_package;
+		ast_context.current_package = saved_package
 	}
 
 	if ast_context.recursion_counter > 15 {
-		log.error("Recursion passed 15 attempts - giving up");
-		return {}, false;
+		log.error("Recursion passed 15 attempts - giving up")
+		return {}, false
 	}
 
-	ast_context.recursion_counter += 1;
+	ast_context.recursion_counter += 1
 
 	defer {
-		ast_context.recursion_counter -= 1;
-	}
-
-	using ast;
-
-	switch v in &node.derived {
-	case Union_Type:
-		return make_symbol_union_from_ast(ast_context, v, ast_context.field_name, true), true;
-	case Enum_Type:
-		return make_symbol_enum_from_ast(ast_context, v, ast_context.field_name, true), true;
-	case Struct_Type:
-		return make_symbol_struct_from_ast(ast_context, v, ast_context.field_name, true), true;
-	case Bit_Set_Type:
-		return make_symbol_bitset_from_ast(ast_context, v, ast_context.field_name, true), true;
-	case Array_Type:
-		return make_symbol_array_from_ast(ast_context, v), true;
-	case Dynamic_Array_Type:
-		return make_symbol_dynamic_array_from_ast(ast_context, v), true;
-	case Map_Type:
-		return make_symbol_map_from_ast(ast_context, v), true;
-	case Proc_Type:
-		return make_symbol_procedure_from_ast(ast_context, node, v, ast_context.field_name), true;
-	case Basic_Directive:
-		return resolve_basic_directive(ast_context, v);
-	case Binary_Expr:
-		return resolve_first_symbol_from_binary_expression(ast_context, &v); 
-	case Ident:
-		return resolve_type_identifier(ast_context, v);
-	case Basic_Lit:
-		return resolve_basic_lit(ast_context, v);
-	case Type_Cast:
-			return resolve_type_expression(ast_context, v.type);
-	case Auto_Cast:
-		return resolve_type_expression(ast_context, v.expr);
-	case Comp_Lit:
-		return resolve_type_expression(ast_context, v.type);
-	case Unary_Expr:
+		ast_context.recursion_counter -= 1
+	}
+
+	using ast
+
+	#partial switch v in node.derived {
+	case ^Union_Type:
+		return make_symbol_union_from_ast(ast_context, v^, ast_context.field_name, true), true
+	case ^Enum_Type:
+		return make_symbol_enum_from_ast(ast_context, v^, ast_context.field_name, true), true
+	case ^Struct_Type:
+		return make_symbol_struct_from_ast(ast_context, v^, ast_context.field_name, true), true
+	case ^Bit_Set_Type:
+		return make_symbol_bitset_from_ast(ast_context, v^, ast_context.field_name, true), true
+	case ^Array_Type:
+		return make_symbol_array_from_ast(ast_context, v^), true
+	case ^Dynamic_Array_Type:
+		return make_symbol_dynamic_array_from_ast(ast_context, v^), true
+	case ^Map_Type:
+		return make_symbol_map_from_ast(ast_context, v^), true
+	case ^Proc_Type:
+		return make_symbol_procedure_from_ast(ast_context, node, v^, ast_context.field_name), true
+	case ^Basic_Directive:
+		return resolve_basic_directive(ast_context, v^)
+	case ^Binary_Expr:
+		return resolve_first_symbol_from_binary_expression(ast_context, v) 
+	case ^Ident:
+		return resolve_type_identifier(ast_context, v^)
+	case ^Basic_Lit:
+		return resolve_basic_lit(ast_context, v^)
+	case ^Type_Cast:
+			return resolve_type_expression(ast_context, v.type)
+	case ^Auto_Cast:
+		return resolve_type_expression(ast_context, v.expr)
+	case ^Comp_Lit:
+		return resolve_type_expression(ast_context, v.type)
+	case ^Unary_Expr:
 		if v.op.kind == .And {
-			symbol, ok := resolve_type_expression(ast_context, v.expr);
-			symbol.pointers += 1;
-			return symbol, ok;
+			symbol, ok := resolve_type_expression(ast_context, v.expr)
+			symbol.pointers += 1
+			return symbol, ok
 		} else {
-			return resolve_type_expression(ast_context, v.expr);
-		}
-	case Deref_Expr:
-		symbol, ok := resolve_type_expression(ast_context, v.expr);
-		symbol.pointers -= 1;
-		return symbol, ok;
-	case Paren_Expr:
-		return resolve_type_expression(ast_context, v.expr);
-	case Slice_Expr:
-		return resolve_type_expression(ast_context, v.expr);
-	case Tag_Expr:
-		return resolve_type_expression(ast_context, v.expr);
-	case Helper_Type:
-		return resolve_type_expression(ast_context, v.type);
-	case Ellipsis:
-		return resolve_type_expression(ast_context, v.expr);
-	case Implicit:
-		ident := index.new_type(Ident, v.node.pos, v.node.end, context.temp_allocator);
-		ident.name = v.tok.text;
-		return resolve_type_identifier(ast_context, ident^);
-	case Type_Assertion:
-		if unary, ok := v.type.derived.(ast.Unary_Expr); ok {
+			return resolve_type_expression(ast_context, v.expr)
+		}
+	case ^Deref_Expr:
+		symbol, ok := resolve_type_expression(ast_context, v.expr)
+		symbol.pointers -= 1
+		return symbol, ok
+	case ^Paren_Expr:
+		return resolve_type_expression(ast_context, v.expr)
+	case ^Slice_Expr:
+		return resolve_type_expression(ast_context, v.expr)
+	case ^Tag_Expr:
+		return resolve_type_expression(ast_context, v.expr)
+	case ^Helper_Type:
+		return resolve_type_expression(ast_context, v.type)
+	case ^Ellipsis:
+		return resolve_type_expression(ast_context, v.expr)
+	case ^Implicit:
+		ident := index.new_type(Ident, v.node.pos, v.node.end, context.temp_allocator)
+		ident.name = v.tok.text
+		return resolve_type_identifier(ast_context, ident^)
+	case ^Type_Assertion:
+		if unary, ok := v.type.derived.(^ast.Unary_Expr); ok {
 			if unary.op.kind == .Question {
 				if symbol, ok := resolve_type_expression(ast_context, v.expr); ok {
 					if union_value, ok := symbol.value.(index.SymbolUnionValue); ok {
 						if len(union_value.types) != 1 {
-							return {}, false;
+							return {}, false
 						}
-						return resolve_type_expression(ast_context, union_value.types[0]);
+						return resolve_type_expression(ast_context, union_value.types[0])
 					}
 				}
 			}
 		} else {
-			return resolve_type_expression(ast_context, v.type);
+			return resolve_type_expression(ast_context, v.type)
 		}	
-	case Proc_Lit:
+	case ^Proc_Lit:
 		if v.type.results != nil {
 			if len(v.type.results.list) == 1 {
-				return resolve_type_expression(ast_context, v.type.results.list[0].type);
+				return resolve_type_expression(ast_context, v.type.results.list[0].type)
 			}
 		}
-	case Pointer_Type:
-		symbol, ok := resolve_type_expression(ast_context, v.elem);
-		symbol.pointers += 1;
-		return symbol, ok;
-	case Multi_Pointer_Type:
-		symbol, ok := resolve_type_expression(ast_context, v.elem);
-		symbol.pointers += 1;
-		return symbol, ok;
-	case Index_Expr:
-		indexed, ok := resolve_type_expression(ast_context, v.expr);
+	case ^Pointer_Type:
+		symbol, ok := resolve_type_expression(ast_context, v.elem)
+		symbol.pointers += 1
+		return symbol, ok
+	case ^Multi_Pointer_Type:
+		symbol, ok := resolve_type_expression(ast_context, v.elem)
+		symbol.pointers += 1
+		return symbol, ok
+	case ^Index_Expr:
+		indexed, ok := resolve_type_expression(ast_context, v.expr)
 
 		if !ok {
-			return {}, false;
+			return {}, false
 		}
 
-		symbol: index.Symbol;
+		symbol: index.Symbol
 
 		#partial switch v2 in indexed.value {
 		case index.SymbolDynamicArrayValue:
-			symbol, ok = resolve_type_expression(ast_context, v2.expr);
+			symbol, ok = resolve_type_expression(ast_context, v2.expr)
 		case index.SymbolSliceValue:
-			symbol, ok = resolve_type_expression(ast_context, v2.expr);
+			symbol, ok = resolve_type_expression(ast_context, v2.expr)
 		case index.SymbolFixedArrayValue:
-			symbol, ok = resolve_type_expression(ast_context, v2.expr);
+			symbol, ok = resolve_type_expression(ast_context, v2.expr)
 		case index.SymbolMapValue:
-			symbol, ok = resolve_type_expression(ast_context, v2.value);
+			symbol, ok = resolve_type_expression(ast_context, v2.value)
 		}
 
-		symbol.type = indexed.type;
+		symbol.type = indexed.type
 
-		return symbol, ok;
-	case Call_Expr:
-		ast_context.call = cast(^Call_Expr)node;
-		return resolve_type_expression(ast_context, v.expr);
-	case Implicit_Selector_Expr:
-		return index.Symbol {}, false;
-	case Selector_Call_Expr:
-		return resolve_type_expression(ast_context, v.expr);
-	case Selector_Expr:
+		return symbol, ok
+	case ^Call_Expr:
+		ast_context.call = cast(^Call_Expr)node
+		return resolve_type_expression(ast_context, v.expr)
+	case ^Implicit_Selector_Expr:
+		return index.Symbol {}, false
+	case ^Selector_Call_Expr:
+		return resolve_type_expression(ast_context, v.expr)
+	case ^Selector_Expr:
 		if selector, ok := resolve_type_expression(ast_context, v.expr); ok {
-			ast_context.use_locals = false;
+			ast_context.use_locals = false
 
 			#partial switch s in selector.value {
 			case index.SymbolFixedArrayValue:
-				components_count := 0;
+				components_count := 0
 				for c in v.field.name {
 					if c == 'x' || c == 'y' || c == 'z'  || c == 'w' ||
 					   c == 'r' || c == 'g' || c == 'b'  || c == 'a' {
-						components_count += 1;
+						components_count += 1
 					}
 				}
 
 				if components_count == 0 {
-					return {}, false;
+					return {}, false
 				}
 
 				if components_count == 1 {
 					if selector.pkg != "" {
-						ast_context.current_package = selector.pkg;
+						ast_context.current_package = selector.pkg
 					} else {
-						ast_context.current_package = ast_context.document_package;
+						ast_context.current_package = ast_context.document_package
 					}
-					symbol, ok := resolve_type_expression(ast_context, s.expr);
-					symbol.type = .Variable;
-					return symbol, ok;
+					symbol, ok := resolve_type_expression(ast_context, s.expr)
+					symbol.type = .Variable
+					return symbol, ok
 				} else {
 					value := index.SymbolFixedArrayValue {
 						expr = s.expr,
 						len = make_int_basic_value(ast_context, components_count),
-					};
-					selector.value = value;
-					selector.type = .Variable;
-					return selector, true;
+					}
+					selector.value = value
+					selector.type = .Variable
+					return selector, true
 				}
 			case index.SymbolProcedureValue:
 				if len(s.return_types) == 1 {
-					selector_expr := index.new_type(ast.Selector_Expr, s.return_types[0].node.pos, s.return_types[0].node.end, context.temp_allocator);
-					selector_expr.expr = s.return_types[0].type;
-					selector_expr.field = v.field;
-					return resolve_type_expression(ast_context, selector_expr);
+					selector_expr := index.new_type(ast.Selector_Expr, s.return_types[0].node.pos, s.return_types[0].node.end, context.temp_allocator)
+					selector_expr.expr = s.return_types[0].type
+					selector_expr.field = v.field
+					return resolve_type_expression(ast_context, selector_expr)
 				}
 			case index.SymbolStructValue:
 				if selector.pkg != "" {
-					ast_context.current_package = selector.pkg;
+					ast_context.current_package = selector.pkg
 				} else {
-					ast_context.current_package = ast_context.document_package;
+					ast_context.current_package = ast_context.document_package
 				}
 
 				for name, i in s.names {
 					if v.field != nil && name == v.field.name {
-						ast_context.field_name = v.field.name;
-						symbol, ok := resolve_type_expression(ast_context, s.types[i]);
-						symbol.type = .Variable;
-						return symbol, ok;
+						ast_context.field_name = v.field.name
+						symbol, ok := resolve_type_expression(ast_context, s.types[i])
+						symbol.type = .Variable
+						return symbol, ok
 					}
 				}
 			case index.SymbolPackageValue:
-				ast_context.current_package = selector.pkg;
+				ast_context.current_package = selector.pkg
 
 				if v.field != nil {
-					return resolve_symbol_return(ast_context, index.lookup(v.field.name, selector.pkg));
+					return resolve_symbol_return(ast_context, index.lookup(v.field.name, selector.pkg))
 				} else {
-					return index.Symbol {}, false;
+					return index.Symbol {}, false
 				}
 			}
 		} else {
-			return index.Symbol {}, false;
+			return index.Symbol {}, false
 		}
 	case:
-		log.warnf("default node kind, resolve_type_expression: %T", v);
+		log.warnf("default node kind, resolve_type_expression: %T", v)
 		if v == nil {
-			return {}, false;
+			return {}, false
 		}
 	}
 
-	return index.Symbol {}, false;
+	return index.Symbol {}, false
 }
 
 store_local :: proc(ast_context: ^AstContext, expr: ^ast.Expr, offset: int, name: string, id := 0) {
-	local_stack := &ast_context.locals[id][name];
+	local_stack := &ast_context.locals[id][name]
 
 	if local_stack == nil {
-		locals := &ast_context.locals[id];
-		locals[name] = make([dynamic]DocumentLocal, ast_context.allocator);
-		local_stack = &locals[name];
+		locals := &ast_context.locals[id]
+		locals[name] = make([dynamic]DocumentLocal, ast_context.allocator)
+		local_stack = &locals[name]
 	}
 
-	append(local_stack, DocumentLocal {expr = expr, offset = offset, id = id});
+	append(local_stack, DocumentLocal {expr = expr, offset = offset, id = id})
 }
 
 add_local_group :: proc(ast_context: ^AstContext, id: int) {
-	ast_context.locals[id] = make(map[string][dynamic]DocumentLocal, 100, ast_context.allocator);
+	ast_context.locals[id] = make(map[string][dynamic]DocumentLocal, 100, ast_context.allocator)
 }
 
 clear_local_group :: proc(ast_context: ^AstContext, id: int) {
-	ast_context.locals[id] = {};
+	ast_context.locals[id] = {}
 }
 
 get_local :: proc(ast_context: ^AstContext, offset: int, name: string) -> ^ast.Expr {
-	previous := 0;
+	previous := 0
 
 	//is the local we are getting being declared?
 	if ast_context.value_decl != nil {
 		for value_decl_name in ast_context.value_decl.names {
-			if ident, ok := value_decl_name.derived.(ast.Ident); ok {
+			if ident, ok := value_decl_name.derived.(^ast.Ident); ok {
 				if ident.name == name {
-					previous = 1;
-					break;
+					previous = 1
+					break
 				}
 			}
 		}
@@ -1085,16 +1083,16 @@ get_local :: proc(ast_context: ^AstContext, offset: int, name: string) -> ^ast.E
 			for i := len(local_stack) - 1; i >= 0; i -= 1 {
 				if local_stack[i].offset <= offset {
 					if i - previous < 0 {
-						return nil;
+						return nil
 					} else {
-						return local_stack[i - previous].expr;
+						return local_stack[i - previous].expr
 					}		
 				}
 			}
 		}
 	}
 
-	return nil;
+	return nil
 }
 
 get_local_offset :: proc(ast_context: ^AstContext, offset: int, name: string) -> int {
@@ -1103,40 +1101,40 @@ get_local_offset :: proc(ast_context: ^AstContext, offset: int, name: string) ->
 			for i := len(local_stack) - 1; i >= 0; i -= 1 {
 				if local_stack[i].offset <= offset {
 					if i < 0 {
-						return -1;
+						return -1
 					} else {
-						return local_stack[i].offset;
+						return local_stack[i].offset
 					}		
 				}
 			}
 		}
 	}
 
-	return -1;
+	return -1
 }
 
 resolve_type_identifier :: proc(ast_context: ^AstContext, node: ast.Ident) -> (index.Symbol, bool) {
-	using ast;
+	using ast
 
 	if ast_context.recursion_counter > 15 {
-		log.error("Recursion passed 15 attempts - giving up");
-		return {}, false;
+		log.error("Recursion passed 15 attempts - giving up")
+		return {}, false
 	}
 
-	saved_package := ast_context.current_package;
+	saved_package := ast_context.current_package
 
 	defer {
-		ast_context.current_package = saved_package;
+		ast_context.current_package = saved_package
 	}
 
-	ast_context.recursion_counter += 1;
+	ast_context.recursion_counter += 1
 
 	defer {
-		ast_context.recursion_counter -= 1;
+		ast_context.recursion_counter -= 1
 	}
 
 	if pkg, ok := ast_context.in_package[node.name]; ok {
-		ast_context.current_package = pkg;
+		ast_context.current_package = pkg
 	}
 
 	if _, ok := ast_context.parameters[node.name]; ok {
@@ -1146,152 +1144,152 @@ resolve_type_identifier :: proc(ast_context: ^AstContext, node: ast.Ident) -> (i
 					type = .Package,
 					pkg = imp.name,
 					value = index.SymbolPackageValue {},
-				};
+				}
 
-				return symbol, true;
+				return symbol, true
 			}
 		}
 	}
 
 	//note(Daniel, if global and local ends up being 100% same just make a function that takes the map)
 	if local := get_local(ast_context, node.pos.offset, node.name); local != nil && ast_context.use_locals {
-		is_distinct := false;
+		is_distinct := false
 
-		if dist, ok := local.derived.(ast.Distinct_Type); ok {
+		if dist, ok := local.derived.(^ast.Distinct_Type); ok {
 			if dist.type != nil {
-				local = dist.type; 
-				is_distinct = true;
-			}
-		}
-
-		return_symbol: index.Symbol;
-		ok: bool;
-
-		switch v in local.derived {
-		case Ident:
-			return_symbol, ok = resolve_type_identifier(ast_context, v);
-		case Union_Type:
-			return_symbol, ok = make_symbol_union_from_ast(ast_context, v, node.name), true;
-			return_symbol.name = node.name;
-		case Enum_Type:
-			return_symbol, ok = make_symbol_enum_from_ast(ast_context, v, node.name), true;
-			return_symbol.name = node.name;
-		case Struct_Type:
-			return_symbol, ok = make_symbol_struct_from_ast(ast_context, v, node.name), true;
-			return_symbol.name = node.name;
-		case Bit_Set_Type:
-			return_symbol, ok = make_symbol_bitset_from_ast(ast_context, v, node.name), true;
-			return_symbol.name = node.name;
-		case Proc_Lit:
+				local = dist.type 
+				is_distinct = true
+			}
+		}
+
+		return_symbol: index.Symbol
+		ok: bool
+
+		#partial switch v in local.derived {
+		case ^Ident:
+			return_symbol, ok = resolve_type_identifier(ast_context, v^)
+		case ^Union_Type:
+			return_symbol, ok = make_symbol_union_from_ast(ast_context, v^, node.name), true
+			return_symbol.name = node.name
+		case ^Enum_Type:
+			return_symbol, ok = make_symbol_enum_from_ast(ast_context, v^, node.name), true
+			return_symbol.name = node.name
+		case ^Struct_Type:
+			return_symbol, ok = make_symbol_struct_from_ast(ast_context, v^, node.name), true
+			return_symbol.name = node.name
+		case ^Bit_Set_Type:
+			return_symbol, ok = make_symbol_bitset_from_ast(ast_context, v^, node.name), true
+			return_symbol.name = node.name
+		case ^Proc_Lit:
 			if !v.type.generic {
-				return_symbol, ok = make_symbol_procedure_from_ast(ast_context, local, v.type^, node.name), true;
+				return_symbol, ok = make_symbol_procedure_from_ast(ast_context, local, v.type^, node.name), true
 			} else {
-				if return_symbol, ok = resolve_generic_function(ast_context, v); !ok {
-					return_symbol, ok = make_symbol_procedure_from_ast(ast_context, local, v.type^, node.name), true;
+				if return_symbol, ok = resolve_generic_function(ast_context, v^); !ok {
+					return_symbol, ok = make_symbol_procedure_from_ast(ast_context, local, v.type^, node.name), true
 				}
 			}
-		case Proc_Group:
-			return_symbol, ok = resolve_function_overload(ast_context, v);
-		case Array_Type:
-			return_symbol, ok = make_symbol_array_from_ast(ast_context, v), true;
-		case Dynamic_Array_Type:
-			return_symbol, ok = make_symbol_dynamic_array_from_ast(ast_context, v), true;
-		case Map_Type:
-			return_symbol, ok = make_symbol_map_from_ast(ast_context, v), true;
-		case Basic_Lit:
-			return_symbol, ok = resolve_basic_lit(ast_context, v);
-			return_symbol.name = node.name;
-			return_symbol.type = ast_context.variables[node.name] ? .Variable : .Constant;
+		case ^Proc_Group:
+			return_symbol, ok = resolve_function_overload(ast_context, v^)
+		case ^Array_Type:
+			return_symbol, ok = make_symbol_array_from_ast(ast_context, v^), true
+		case ^Dynamic_Array_Type:
+			return_symbol, ok = make_symbol_dynamic_array_from_ast(ast_context, v^), true
+		case ^Map_Type:
+			return_symbol, ok = make_symbol_map_from_ast(ast_context, v^), true
+		case ^Basic_Lit:
+			return_symbol, ok = resolve_basic_lit(ast_context, v^)
+			return_symbol.name = node.name
+			return_symbol.type = ast_context.variables[node.name] ? .Variable : .Constant
 		case:
-			return_symbol, ok = resolve_type_expression(ast_context, local);
+			return_symbol, ok = resolve_type_expression(ast_context, local)
 		}
 
 		if is_distinct {
-			return_symbol.name = node.name;
-			return_symbol.flags |= {.Distinct};
+			return_symbol.name = node.name
+			return_symbol.flags |= {.Distinct}
 		}
 
 		if is_variable, ok := ast_context.variables[node.name]; ok && is_variable {
-			return_symbol.type = .Variable;
+			return_symbol.type = .Variable
 		}
 
-		return return_symbol, ok;
+		return return_symbol, ok
 
 	} else if global, ok := ast_context.globals[node.name]; ast_context.use_globals && ok {
-		is_distinct := false;
+		is_distinct := false
 
-		if dist, ok := global.expr.derived.(ast.Distinct_Type); ok {
+		if dist, ok := global.expr.derived.(^ast.Distinct_Type); ok {
 			if dist.type != nil {
-				global.expr = dist.type;
-				is_distinct = true;
-			}
-		}
-
-		return_symbol: index.Symbol;
-		ok: bool;
-
-		switch v in global.expr.derived {
-		case Ident:
-			return_symbol, ok = resolve_type_identifier(ast_context, v);
-		case Struct_Type:
-			return_symbol, ok = make_symbol_struct_from_ast(ast_context, v, node.name), true;
-			return_symbol.name = node.name;
-		case Bit_Set_Type:
-			return_symbol, ok = make_symbol_bitset_from_ast(ast_context, v, node.name), true;
-			return_symbol.name = node.name;
-		case Union_Type:
-			return_symbol, ok = make_symbol_union_from_ast(ast_context, v, node.name), true;
-			return_symbol.name = node.name;
-		case Enum_Type:
-			return_symbol, ok = make_symbol_enum_from_ast(ast_context, v, node.name), true;
-			return_symbol.name = node.name;
-		case Proc_Lit:
+				global.expr = dist.type
+				is_distinct = true
+			}
+		}
+
+		return_symbol: index.Symbol
+		ok: bool
+
+		#partial switch v in global.expr.derived {
+		case ^Ident:
+			return_symbol, ok = resolve_type_identifier(ast_context, v^)
+		case ^Struct_Type:
+			return_symbol, ok = make_symbol_struct_from_ast(ast_context, v^, node.name), true
+			return_symbol.name = node.name
+		case ^Bit_Set_Type:
+			return_symbol, ok = make_symbol_bitset_from_ast(ast_context, v^, node.name), true
+			return_symbol.name = node.name
+		case ^Union_Type:
+			return_symbol, ok = make_symbol_union_from_ast(ast_context, v^, node.name), true
+			return_symbol.name = node.name
+		case ^Enum_Type:
+			return_symbol, ok = make_symbol_enum_from_ast(ast_context, v^, node.name), true
+			return_symbol.name = node.name
+		case ^Proc_Lit:
 			if !v.type.generic {
-				return_symbol, ok = make_symbol_procedure_from_ast(ast_context, global.expr, v.type^, node.name), true;
+				return_symbol, ok = make_symbol_procedure_from_ast(ast_context, global.expr, v.type^, node.name), true
 			} else {
-				if return_symbol, ok = resolve_generic_function(ast_context, v); !ok {
-					return_symbol, ok = make_symbol_procedure_from_ast(ast_context, global.expr, v.type^, node.name), true;
+				if return_symbol, ok = resolve_generic_function(ast_context, v^); !ok {
+					return_symbol, ok = make_symbol_procedure_from_ast(ast_context, global.expr, v.type^, node.name), true
 				}
 			}
-		case Proc_Group:
-			return_symbol, ok = resolve_function_overload(ast_context, v);
-		case Array_Type:
-			return_symbol, ok = make_symbol_array_from_ast(ast_context, v), true;
-		case Dynamic_Array_Type:
-			return_symbol, ok = make_symbol_dynamic_array_from_ast(ast_context, v), true;
-		case Basic_Lit:
-			return_symbol, ok = resolve_basic_lit(ast_context, v);
-			return_symbol.name = node.name;
-			return_symbol.type = global.mutable ? .Variable : .Constant;
+		case ^Proc_Group:
+			return_symbol, ok = resolve_function_overload(ast_context, v^)
+		case ^Array_Type:
+			return_symbol, ok = make_symbol_array_from_ast(ast_context, v^), true
+		case ^Dynamic_Array_Type:
+			return_symbol, ok = make_symbol_dynamic_array_from_ast(ast_context, v^), true
+		case ^Basic_Lit:
+			return_symbol, ok = resolve_basic_lit(ast_context, v^)
+			return_symbol.name = node.name
+			return_symbol.type = global.mutable ? .Variable : .Constant
 		case:
-			return_symbol, ok = resolve_type_expression(ast_context, global.expr);
+			return_symbol, ok = resolve_type_expression(ast_context, global.expr)
 		}
 
 		if is_distinct {
-			return_symbol.name = node.name;
-			return_symbol.flags |= {.Distinct};
+			return_symbol.name = node.name
+			return_symbol.flags |= {.Distinct}
 		}
 
 		if is_variable, ok := ast_context.variables[node.name]; ok && is_variable {
-			return_symbol.type = .Variable;
+			return_symbol.type = .Variable
 		}
 
-		return_symbol.doc = common.get_doc(global.docs, ast_context.allocator);
+		return_symbol.doc = common.get_doc(global.docs, ast_context.allocator)
 
-		return return_symbol, ok;
+		return return_symbol, ok
 	} else if node.name == "context" {
 		for built in index.indexer.builtin_packages {
 			if symbol, ok := index.lookup("Context", built); ok {
-				symbol.type = .Variable;
-				return symbol, ok;
+				symbol.type = .Variable
+				return symbol, ok
 			}
 		}
 	} else if v, ok := common.keyword_map[node.name]; ok {
 		//keywords
-		ident := index.new_type(Ident, node.pos, node.end, ast_context.allocator);
-		ident.name = node.name;
+		ident := index.new_type(Ident, node.pos, node.end, ast_context.allocator)
+		ident.name = node.name
 
-		symbol: index.Symbol;
+		symbol: index.Symbol
 
 		switch ident.name {
 		case "true", "false":
@@ -1302,7 +1300,7 @@ resolve_type_identifier :: proc(ast_context: ^AstContext, node: ast.Ident) -> (i
 				value = index.SymbolUntypedValue {
 					type = .Bool,	
 				},
-			};
+			}
 		case:
 			symbol = index.Symbol {
 				type = .Keyword,
@@ -1312,10 +1310,10 @@ resolve_type_identifier :: proc(ast_context: ^AstContext, node: ast.Ident) -> (i
 				value = index.SymbolBasicValue {
 					ident = ident,
 				},
-			};
+			}
 		}
 
-		return symbol, true;
+		return symbol, true
 	} else {
 		//right now we replace the package ident with the absolute directory name, so it should have '/' which is not a valid ident character
 		if strings.contains(node.name, "/") {
@@ -1323,9 +1321,9 @@ resolve_type_identifier :: proc(ast_context: ^AstContext, node: ast.Ident) -> (i
 				type = .Package,
 				pkg = node.name,
 				value = index.SymbolPackageValue {},
-			};
+			}
 
-			return symbol, true;
+			return symbol, true
 		} else {
 			//part of the ast so we check the imports of the document
 			for imp in ast_context.imports {
@@ -1334,23 +1332,23 @@ resolve_type_identifier :: proc(ast_context: ^AstContext, node: ast.Ident) -> (i
 						type = .Package,
 						pkg = imp.name,
 						value = index.SymbolPackageValue {},
-					};
+					}
 
-					return symbol, true;
+					return symbol, true
 				}
 			}
 		}
 
 		//last option is to check the index
 		if symbol, ok := index.lookup(node.name, ast_context.current_package); ok {
-			return resolve_symbol_return(ast_context, symbol);
+			return resolve_symbol_return(ast_context, symbol)
 		}
 
 		//If we are resolving a symbol that is in the document package, then we'll check the builtin packages.
 		if ast_context.current_package == ast_context.document_package {
 			for built in index.indexer.builtin_packages {
 				if symbol, ok := index.lookup(node.name, built); ok {
-					return resolve_symbol_return(ast_context, symbol);
+					return resolve_symbol_return(ast_context, symbol)
 				}
 			}
 		}
@@ -1360,59 +1358,59 @@ resolve_type_identifier :: proc(ast_context: ^AstContext, node: ast.Ident) -> (i
 			for imp in ast_context.imports {
 				if strings.compare(imp.base, u) == 0 {
 					if symbol, ok := index.lookup(node.name, imp.name); ok {
-						return resolve_symbol_return(ast_context, symbol);
+						return resolve_symbol_return(ast_context, symbol)
 					}
 				}
 			}
 		}
 	}
 
-	return index.Symbol {}, false;
+	return index.Symbol {}, false
 }
 
 resolve_ident_is_package :: proc(ast_context: ^AstContext, node: ast.Ident) -> bool {
 	if strings.contains(node.name, "/") {
-		return true;
+		return true
 	} else {
 		for imp in ast_context.imports {
 
 			if imp.base == node.name {
-				return true;
+				return true
 			}
 		}
 	}
 
-	return false;
+	return false
 }
 
 expand_struct_usings :: proc(ast_context: ^AstContext, symbol: index.Symbol, value: index.SymbolStructValue) -> index.SymbolStructValue {
-	names := slice.to_dynamic(value.names, ast_context.allocator);
-	types := slice.to_dynamic(value.types, ast_context.allocator);
+	names := slice.to_dynamic(value.names, ast_context.allocator)
+	types := slice.to_dynamic(value.types, ast_context.allocator)
 
 	for k, v in value.usings {
-		ast_context.current_package = symbol.pkg;
+		ast_context.current_package = symbol.pkg
 
-		field_expr: ^ast.Expr;
+		field_expr: ^ast.Expr
 
 		for name, i in value.names {
 
 			if name == k && v {
-				field_expr = value.types[i];
+				field_expr = value.types[i]
 			}
 		}
 
 		if field_expr == nil {
-			continue;
+			continue
 		}
 
 		if s, ok := resolve_type_expression(ast_context, field_expr); ok {
 			if struct_value, ok := s.value.(index.SymbolStructValue); ok {
 				for name in struct_value.names {
-					append(&names, name);
+					append(&names, name)
 				}
 
 				for type in struct_value.types {
-					append(&types, type);
+					append(&types, type)
 				}
 			}
 		}
@@ -1421,126 +1419,126 @@ expand_struct_usings :: proc(ast_context: ^AstContext, symbol: index.Symbol, val
 	return {
 		names = names[:],
 		types = types[:],
-	};
+	}
 }
 
 resolve_symbol_return :: proc(ast_context: ^AstContext, symbol: index.Symbol, ok := true) -> (index.Symbol, bool) {
 	if !ok {
-		return symbol, ok;
+		return symbol, ok
 	}
 
-	symbol := symbol;
+	symbol := symbol
 
 	if symbol.type == .Unresolved {
-		resolve_unresolved_symbol(ast_context, &symbol);
+		resolve_unresolved_symbol(ast_context, &symbol)
 	}
 	
 	#partial switch v in &symbol.value {
 	case index.SymbolProcedureGroupValue:
-		if symbol, ok := resolve_function_overload(ast_context, v.group.derived.(ast.Proc_Group)); ok {
-			return symbol, true;
+		if symbol, ok := resolve_function_overload(ast_context, v.group.derived.(^ast.Proc_Group)^); ok {
+			return symbol, true
 		} else {
-			return symbol, false;
+			return symbol, false
 		}
 	case index.SymbolProcedureValue:
 		if v.generic {
 			if resolved_symbol, ok := resolve_generic_function(ast_context, v.arg_types, v.return_types); ok {
-				return resolved_symbol, ok;
+				return resolved_symbol, ok
 			} else {
-				return symbol, true;
+				return symbol, true
 			}
 		} else {
-			return symbol, true;
+			return symbol, true
 		}
 	case index.SymbolUnionValue:
 		if v.poly != nil {
 			//Todo(daniel): Maybe change the function to return a new symbol instead of referencing it.
 			//resolving the poly union means changing the type, so we do a copy of it.
-			types := make([dynamic]^ast.Expr, ast_context.allocator);
-			append_elems(&types, ..v.types);
-			v.types = types[:];
-			resolve_poly_union(ast_context, v.poly, &symbol);
+			types := make([dynamic]^ast.Expr, ast_context.allocator)
+			append_elems(&types, ..v.types)
+			v.types = types[:]
+			resolve_poly_union(ast_context, v.poly, &symbol)
 		}
-		return symbol, ok;
+		return symbol, ok
 	case index.SymbolStructValue:
 		if v.poly != nil {
 			//Todo(daniel): Maybe change the function to return a new symbol instead of referencing it.
 			//resolving the struct union means changing the type, so we do a copy of it.
-			types := make([dynamic]^ast.Expr, ast_context.allocator);
-			append_elems(&types, ..v.types);
-			v.types = types[:];
-			resolve_poly_struct(ast_context, v.poly, &symbol);
+			types := make([dynamic]^ast.Expr, ast_context.allocator)
+			append_elems(&types, ..v.types)
+			v.types = types[:]
+			resolve_poly_struct(ast_context, v.poly, &symbol)
 		}
 
 		//expand the types and names from the using - can't be done while indexing without complicating everything(this also saves memory)
 		if len(v.usings) > 0 {
-			expanded := symbol;
-			expanded.value = expand_struct_usings(ast_context, symbol, v);
-			return expanded, true;
+			expanded := symbol
+			expanded.value = expand_struct_usings(ast_context, symbol, v)
+			return expanded, true
 		} else {
-			return symbol, true; 
+			return symbol, true 
 		}
 	case index.SymbolGenericValue:
-		ret, ok := resolve_type_expression(ast_context, v.expr);
-		return ret, ok;
+		ret, ok := resolve_type_expression(ast_context, v.expr)
+		return ret, ok
 	}
 
-	return symbol, true;
+	return symbol, true
 }
 
 resolve_unresolved_symbol :: proc(ast_context: ^AstContext, symbol: ^index.Symbol) {
-	using index;
+	using index
 
 	if symbol.type != .Unresolved {
-		return;
+		return
 	}
 
 	#partial switch v in symbol.value {
 	case SymbolStructValue:
-		symbol.type = .Struct;
+		symbol.type = .Struct
     case SymbolPackageValue:
-		symbol.type = .Package;
+		symbol.type = .Package
     case SymbolProcedureValue, SymbolProcedureGroupValue:
-		symbol.type = .Function;
+		symbol.type = .Function
     case SymbolUnionValue:
-		symbol.type = .Enum;
+		symbol.type = .Enum
     case SymbolEnumValue:
-		symbol.type = .Enum;
+		symbol.type = .Enum
     case SymbolBitSetValue:
-		symbol.type = .Enum;
+		symbol.type = .Enum
 	case index.SymbolGenericValue:
-		ast_context.current_package = symbol.pkg;
+		ast_context.current_package = symbol.pkg
 		if ret, ok := resolve_type_expression(ast_context, v.expr); ok {
-			symbol.type = ret.type;
-			symbol.signature = ret.signature;
+			symbol.type = ret.type
+			symbol.signature = ret.signature
 		}
 	}
 }
 
 resolve_location_identifier :: proc(ast_context: ^AstContext, node: ast.Ident) -> (index.Symbol, bool) {
-	symbol: index.Symbol;
+	symbol: index.Symbol
 
 	if local := get_local(ast_context, node.pos.offset, node.name); local != nil {
-		symbol.range = common.get_token_range(get_local(ast_context, node.pos.offset, node.name), ast_context.file.src);
-		return symbol, true;
+		symbol.range = common.get_token_range(get_local(ast_context, node.pos.offset, node.name), ast_context.file.src)
+		return symbol, true
 	} else if global, ok := ast_context.globals[node.name]; ok {
-		symbol.range = common.get_token_range(global.expr, ast_context.file.src);
-		return symbol, true;
+		symbol.range = common.get_token_range(global.expr, ast_context.file.src)
+		return symbol, true
 	}
 
 	if symbol, ok := index.lookup(node.name, ast_context.document_package); ok {
-		return symbol, ok;
+		return symbol, ok
 	}
 
-	usings := get_using_packages(ast_context);
+	usings := get_using_packages(ast_context)
 
 	for pkg in usings {
 		if symbol, ok := index.lookup(node.name, pkg); ok {
-			return symbol, ok;
+			return symbol, ok
 		}
 	}
 
-	return {}, false;
+	return {}, false
 }
 
 resolve_first_symbol_from_binary_expression :: proc(ast_context: ^AstContext, binary: ^ast.Binary_Expr) -> (index.Symbol, bool) {
@@ -1548,87 +1546,87 @@ resolve_first_symbol_from_binary_expression :: proc(ast_context: ^AstContext, bi
 
 	if binary.left != nil {
 
-		if ident, ok := binary.left.derived.(ast.Ident); ok {
-			if s, ok := resolve_type_identifier(ast_context, ident); ok {
-				return s, ok;
+		if ident, ok := binary.left.derived.(^ast.Ident); ok {
+			if s, ok := resolve_type_identifier(ast_context, ident^); ok {
+				return s, ok
 			}
-		} else if _, ok := binary.left.derived.(ast.Binary_Expr); ok {
+		} else if _, ok := binary.left.derived.(^ast.Binary_Expr); ok {
 			if s, ok := resolve_first_symbol_from_binary_expression(ast_context, cast(^ast.Binary_Expr)binary.left); ok {
-				return s, ok;
+				return s, ok
 			}
 		}
 	}
 
 	if binary.right != nil {
-		if ident, ok := binary.right.derived.(ast.Ident); ok {
-			if s, ok := resolve_type_identifier(ast_context, ident); ok {
-				return s, ok;
+		if ident, ok := binary.right.derived.(^ast.Ident); ok {
+			if s, ok := resolve_type_identifier(ast_context, ident^); ok {
+				return s, ok
 			}
-		} else if _, ok := binary.right.derived.(ast.Binary_Expr); ok {
+		} else if _, ok := binary.right.derived.(^ast.Binary_Expr); ok {
 			if s, ok := resolve_first_symbol_from_binary_expression(ast_context, cast(^ast.Binary_Expr)binary.right); ok {
-				return s, ok;
+				return s, ok
 			}
 		}
 	}
 
-	return {}, false;
+	return {}, false
 }
 
 find_position_in_call_param :: proc(ast_context: ^AstContext, call: ast.Call_Expr) -> (int, bool) {
 	if call.args == nil {
-		return 0, false;
+		return 0, false
 	}
 
 	for arg, i in call.args {
 		if position_in_node(arg, ast_context.position) {
-			return i, true;
+			return i, true
 		}
 	}
 
-	return len(call.args) - 1, true;
+	return len(call.args) - 1, true
 }
 
 make_pointer_ast :: proc(ast_context: ^AstContext, elem: ^ast.Expr) -> ^ast.Pointer_Type {
-	pointer := index.new_type(ast.Pointer_Type, elem.pos, elem.end, ast_context.allocator);
-	pointer.elem = elem;
-	return pointer;
+	pointer := index.new_type(ast.Pointer_Type, elem.pos, elem.end, ast_context.allocator)
+	pointer.elem = elem
+	return pointer
 }
 
 make_bool_ast :: proc(ast_context: ^AstContext) -> ^ast.Ident {
-	ident := index.new_type(ast.Ident, {}, {}, ast_context.allocator);
-	ident.name = "bool";
-	return ident;
+	ident := index.new_type(ast.Ident, {}, {}, ast_context.allocator)
+	ident.name = "bool"
+	return ident
 }
 
 make_int_ast :: proc(ast_context: ^AstContext) -> ^ast.Ident {
-	ident := index.new_type(ast.Ident, {}, {}, ast_context.allocator);
-	ident.name = "int";
-	return ident;
+	ident := index.new_type(ast.Ident, {}, {}, ast_context.allocator)
+	ident.name = "int"
+	return ident
 }
 
 make_int_basic_value :: proc(ast_context: ^AstContext, n: int) -> ^ast.Basic_Lit {
-	basic := index.new_type(ast.Basic_Lit, {}, {}, ast_context.allocator);
-	basic.tok.text = fmt.tprintf("%v", n);
-	return basic; 
+	basic := index.new_type(ast.Basic_Lit, {}, {}, ast_context.allocator)
+	basic.tok.text = fmt.tprintf("%v", n)
+	return basic 
 }
 
 get_package_from_node :: proc(node: ast.Node) -> string {
-	slashed, _ := filepath.to_slash(node.pos.file, context.temp_allocator);
+	slashed, _ := filepath.to_slash(node.pos.file, context.temp_allocator)
 
-	when ODIN_OS == "windows" {
-		ret := strings.to_lower(path.dir(slashed, context.temp_allocator), context.temp_allocator);
+	when ODIN_OS == .Windows {
+		ret := strings.to_lower(path.dir(slashed, context.temp_allocator), context.temp_allocator)
 	} else {
-		ret := path.dir(slashed, context.temp_allocator);
+		ret := path.dir(slashed, context.temp_allocator)
 	}
 
-	return ret;
+	return ret
 }
 
 get_using_packages :: proc(ast_context: ^AstContext) -> []string {
-	usings := make([]string, len(ast_context.usings), context.temp_allocator);
+	usings := make([]string, len(ast_context.usings), context.temp_allocator)
 
 	if len(ast_context.usings) == 0 {
-		return usings;
+		return usings
 	}
 
 	//probably map instead
@@ -1637,12 +1635,12 @@ get_using_packages :: proc(ast_context: ^AstContext) -> []string {
 		for imp in ast_context.imports {
 
 			if strings.compare(imp.base, u) == 0 {
-				usings[i] = imp.name;
+				usings[i] = imp.name
 			}
 		}
 	}
 
-	return usings;
+	return usings
 }
 
 make_symbol_procedure_from_ast :: proc(ast_context: ^AstContext, n: ^ast.Node, v: ast.Proc_Type, name: string) -> index.Symbol {
@@ -1651,35 +1649,35 @@ make_symbol_procedure_from_ast :: proc(ast_context: ^AstContext, n: ^ast.Node, v
 		type = .Function,
 		pkg = get_package_from_node(n^),
 		name = name,
-	};
+	}
 
-	return_types := make([dynamic]^ast.Field, ast_context.allocator);
-	arg_types    := make([dynamic]^ast.Field, ast_context.allocator);
+	return_types := make([dynamic]^ast.Field, ast_context.allocator)
+	arg_types    := make([dynamic]^ast.Field, ast_context.allocator)
 
 	if v.results != nil {
 		for ret in v.results.list {
-			append(&return_types, ret);
+			append(&return_types, ret)
 		}
 	}
 
 	if v.params != nil {
 		for param in v.params.list {
-			append(&arg_types, param);
+			append(&arg_types, param)
 		}
 	}
 
 	if expr, ok := ast_context.globals[name]; ok {
 		if expr.deprecated {
-			symbol.flags |= {.Distinct};
+			symbol.flags |= {.Distinct}
 		}
 	}
 
 	symbol.value = index.SymbolProcedureValue {
 		return_types = return_types[:],
 		arg_types = arg_types[:],
-	};
+	}
 
-	return symbol;
+	return symbol
 }
 
 make_symbol_array_from_ast :: proc(ast_context: ^AstContext, v: ast.Array_Type) -> index.Symbol {
@@ -1687,20 +1685,20 @@ make_symbol_array_from_ast :: proc(ast_context: ^AstContext, v: ast.Array_Type)
 		range = common.get_token_range(v.node, ast_context.file.src),
 		type = .Variable,
 		pkg = get_package_from_node(v.node),
-	};
+	}
 
 	if v.len != nil {
 		symbol.value = index.SymbolFixedArrayValue {
 			expr = v.elem,
 			len = v.len,
-		};
+		}
 	} else {
 		symbol.value = index.SymbolSliceValue {
 			expr = v.elem,
-		};
+		}
 	}
 
-	return symbol;
+	return symbol
 }
 
 make_symbol_dynamic_array_from_ast :: proc(ast_context: ^AstContext, v: ast.Dynamic_Array_Type) -> index.Symbol {
@@ -1708,13 +1706,13 @@ make_symbol_dynamic_array_from_ast :: proc(ast_context: ^AstContext, v: ast.Dyna
 		range = common.get_token_range(v.node, ast_context.file.src),
 		type = .Variable,
 		pkg = get_package_from_node(v.node),
-	};
+	}
 
 	symbol.value = index.SymbolDynamicArrayValue {
 		expr = v.elem,
-	};
+	}
 
-	return symbol;
+	return symbol
 }
 
 make_symbol_map_from_ast :: proc(ast_context: ^AstContext, v: ast.Map_Type) -> index.Symbol {
@@ -1722,14 +1720,14 @@ make_symbol_map_from_ast :: proc(ast_context: ^AstContext, v: ast.Map_Type) -> i
 		range = common.get_token_range(v.node, ast_context.file.src),
 		type = .Variable,
 		pkg = get_package_from_node(v.node),
-	};
+	}
 
 	symbol.value = index.SymbolMapValue {
 		key = v.key,
 		value = v.value,
-	};
+	}
 
-	return symbol;
+	return symbol
 }
 
 make_symbol_basic_type_from_ast :: proc(ast_context: ^AstContext, n: ^ast.Node, v: ^ast.Ident) -> index.Symbol {
@@ -1737,13 +1735,13 @@ make_symbol_basic_type_from_ast :: proc(ast_context: ^AstContext, n: ^ast.Node,
 		range = common.get_token_range(n^, ast_context.file.src),
 		type = .Variable,
 		pkg = get_package_from_node(n^),
-	};
+	}
 
 	symbol.value = index.SymbolBasicValue {
 		ident = v,
-	};
+	}
 
-	return symbol;
+	return symbol
 }
 
 make_symbol_union_from_ast :: proc(ast_context: ^AstContext, v: ast.Union_Type, ident: string, inlined := false) -> index.Symbol {
@@ -1752,22 +1750,22 @@ make_symbol_union_from_ast :: proc(ast_context: ^AstContext, v: ast.Union_Type,
 		type = .Union,
 		pkg = get_package_from_node(v.node),
 		name = ident,
-	};
+	}
 
 	if inlined {
-		symbol.flags |= {.Anonymous};
-		symbol.name = "union";
+		symbol.flags |= {.Anonymous}
+		symbol.name = "union"
 	}
 
 	symbol.value = index.SymbolUnionValue {
 		types = v.variants,
-	};
+	}
 
 	if v.poly_params != nil {
-		resolve_poly_union(ast_context, v.poly_params, &symbol);
+		resolve_poly_union(ast_context, v.poly_params, &symbol)
 	}
 
-	return symbol;
+	return symbol
 }
 
 make_symbol_enum_from_ast :: proc(ast_context: ^AstContext, v: ast.Enum_Type, ident: string, inlined := false) -> index.Symbol {
@@ -1776,33 +1774,33 @@ make_symbol_enum_from_ast :: proc(ast_context: ^AstContext, v: ast.Enum_Type, id
 		type = .Enum,
 		name = ident,
 		pkg = get_package_from_node(v.node),
-	};
+	}
 
 	if inlined {
-		symbol.flags |= {.Anonymous};
-		symbol.name = "enum";
+		symbol.flags |= {.Anonymous}
+		symbol.name = "enum"
 	}
 
 
-	names := make([dynamic]string, ast_context.allocator);
+	names := make([dynamic]string, ast_context.allocator)
 
 	for n in v.fields {
-		if ident, ok := n.derived.(ast.Ident); ok {
-			append(&names, ident.name);
-		} else if field, ok := n.derived.(ast.Field_Value); ok {
-			if ident, ok := field.field.derived.(ast.Ident); ok {
-				append(&names, ident.name);
-			} else if binary, ok := field.field.derived.(ast.Binary_Expr); ok {
-				append(&names, binary.left.derived.(ast.Ident).name);
+		if ident, ok := n.derived.(^ast.Ident); ok {
+			append(&names, ident.name)
+		} else if field, ok := n.derived.(^ast.Field_Value); ok {
+			if ident, ok := field.field.derived.(^ast.Ident); ok {
+				append(&names, ident.name)
+			} else if binary, ok := field.field.derived.(^ast.Binary_Expr); ok {
+				append(&names, binary.left.derived.(^ast.Ident).name)
 			}	
 		}
 	}
 
 	symbol.value = index.SymbolEnumValue {
 		names = names[:],
-	};
+	}
 
-	return symbol;
+	return symbol
 }
 
 make_symbol_bitset_from_ast :: proc(ast_context: ^AstContext, v: ast.Bit_Set_Type, ident: string, inlined := false) -> index.Symbol {
@@ -1811,18 +1809,18 @@ make_symbol_bitset_from_ast :: proc(ast_context: ^AstContext, v: ast.Bit_Set_Typ
 		type = .Enum,
 		name = ident,
 		pkg = get_package_from_node(v.node),
-	};
+	}
 
 	if inlined {
-		symbol.flags |= {.Anonymous};
-		symbol.name = "bitset";
+		symbol.flags |= {.Anonymous}
+		symbol.name = "bitset"
 	}
 
 	symbol.value = index.SymbolBitSetValue {
 		expr = v.elem,
-	};
+	}
 
-	return symbol;
+	return symbol
 }
 
 make_symbol_struct_from_ast :: proc(ast_context: ^AstContext, v: ast.Struct_Type, ident: string, inlined := false) -> index.Symbol {
@@ -1831,25 +1829,25 @@ make_symbol_struct_from_ast :: proc(ast_context: ^AstContext, v: ast.Struct_Type
 		type = .Struct,
 		pkg = get_package_from_node(v.node),
 		name = ident,
-	};
+	}
 
 	if inlined {
-		symbol.flags |= {.Anonymous};
-		symbol.name = "struct";
+		symbol.flags |= {.Anonymous}
+		symbol.name = "struct"
 	}
 
-	names  := make([dynamic]string, ast_context.allocator);
-	types  := make([dynamic]^ast.Expr, ast_context.allocator);
-	usings := make(map[string]bool, 0, ast_context.allocator);
+	names  := make([dynamic]string, ast_context.allocator)
+	types  := make([dynamic]^ast.Expr, ast_context.allocator)
+	usings := make(map[string]bool, 0, ast_context.allocator)
 
 	for field in v.fields.list {
 		for n in field.names {
-			if identifier, ok := n.derived.(ast.Ident); ok {
-				append(&names, identifier.name);
-				append(&types, index.clone_type(field.type, ast_context.allocator, nil));
+			if identifier, ok := n.derived.(^ast.Ident); ok {
+				append(&names, identifier.name)
+				append(&types, index.clone_type(field.type, ast_context.allocator, nil))
 
 				if .Using in field.flags {
-					usings[identifier.name] = true;
+					usings[identifier.name] = true
 				}
 			}
 		}
@@ -1859,73 +1857,73 @@ make_symbol_struct_from_ast :: proc(ast_context: ^AstContext, v: ast.Struct_Type
 		names = names[:],
 		types = types[:],
 		usings = usings,
-	};
+	}
 
 	if v.poly_params != nil {
-		resolve_poly_struct(ast_context, v.poly_params, &symbol);
+		resolve_poly_struct(ast_context, v.poly_params, &symbol)
 	}
 
 	//TODO change the expand to not double copy the array, but just pass the dynamic arrays
 	if len(usings) > 0 {
-		symbol.value = expand_struct_usings(ast_context, symbol, symbol.value.(index.SymbolStructValue));
+		symbol.value = expand_struct_usings(ast_context, symbol, symbol.value.(index.SymbolStructValue))
 	}
 
-	return symbol;
+	return symbol
 }
 
 resolve_poly_union :: proc(ast_context: ^AstContext, poly_params: ^ast.Field_List, symbol: ^index.Symbol) {
 	if ast_context.call == nil {
-		return;
+		return
 	}
 
-	symbol_value := &symbol.value.(index.SymbolUnionValue);
+	symbol_value := &symbol.value.(index.SymbolUnionValue)
 
 	if symbol_value == nil {
-		return;
+		return
 	}
 
-	i := 0;
+	i := 0
 
-	poly_map := make(map[string]^ast.Expr, 0, context.temp_allocator);
+	poly_map := make(map[string]^ast.Expr, 0, context.temp_allocator)
 
 	for param in poly_params.list {
 		for name in param.names {
 			if len(ast_context.call.args) <= i {
-				break;
+				break
 			}
 
 			if param.type == nil {
-				continue;
+				continue
 			}
 			
-			if poly, ok := param.type.derived.(ast.Typeid_Type); ok {
-				if ident, ok := name.derived.(ast.Ident); ok {
-					poly_map[ident.name] = ast_context.call.args[i];
-				} else if poly, ok := name.derived.(ast.Poly_Type); ok { 
+			if poly, ok := param.type.derived.(^ast.Typeid_Type); ok {
+				if ident, ok := name.derived.(^ast.Ident); ok {
+					poly_map[ident.name] = ast_context.call.args[i]
+				} else if poly, ok := name.derived.(^ast.Poly_Type); ok { 
 					if poly.type != nil {
-						poly_map[poly.type.name] = ast_context.call.args[i];
+						poly_map[poly.type.name] = ast_context.call.args[i]
 					}
 				}
 			}
 
-			i += 1;
+			i += 1
 		}
 	}
 	
 	for type, i in symbol_value.types {
-		if ident, ok := type.derived.(ast.Ident); ok {
+		if ident, ok := type.derived.(^ast.Ident); ok {
 			if expr, ok := poly_map[ident.name]; ok {
-				symbol_value.types[i] = expr;
+				symbol_value.types[i] = expr
 			}
-		} else if call_expr, ok := type.derived.(ast.Call_Expr); ok {
+		} else if call_expr, ok := type.derived.(^ast.Call_Expr); ok {
 			if call_expr.args == nil {
-				continue;
+				continue
 			}
 
 			for arg, i in call_expr.args {
-				if ident, ok := arg.derived.(ast.Ident); ok {
+				if ident, ok := arg.derived.(^ast.Ident); ok {
 					if expr, ok := poly_map[ident.name]; ok {
-						symbol_value.types[i] = expr;
+						symbol_value.types[i] = expr
 					}
 				}
 			}
@@ -1935,57 +1933,57 @@ resolve_poly_union :: proc(ast_context: ^AstContext, poly_params: ^ast.Field_Lis
 
 resolve_poly_struct :: proc(ast_context: ^AstContext, poly_params: ^ast.Field_List, symbol: ^index.Symbol) {
 	if ast_context.call == nil {
-		return;
+		return
 	}
 
-	symbol_value := &symbol.value.(index.SymbolStructValue);
+	symbol_value := &symbol.value.(index.SymbolStructValue)
 
 	if symbol_value == nil {
-		return;
+		return
 	}
 
-	i := 0;
+	i := 0
 
-	poly_map := make(map[string]^ast.Expr, 0, context.temp_allocator);
+	poly_map := make(map[string]^ast.Expr, 0, context.temp_allocator)
 
 	for param in poly_params.list {
 		for name in param.names {
 			if len(ast_context.call.args) <= i {
-				break;
+				break
 			}
 
 			if param.type == nil {
-				continue;
+				continue
 			}
 			
-			if poly, ok := param.type.derived.(ast.Typeid_Type); ok {
-				if ident, ok := name.derived.(ast.Ident); ok {
-					poly_map[ident.name] = ast_context.call.args[i];
-				} else if poly, ok := name.derived.(ast.Poly_Type); ok { 
+			if poly, ok := param.type.derived.(^ast.Typeid_Type); ok {
+				if ident, ok := name.derived.(^ast.Ident); ok {
+					poly_map[ident.name] = ast_context.call.args[i]
+				} else if poly, ok := name.derived.(^ast.Poly_Type); ok { 
 					if poly.type != nil {
-						poly_map[poly.type.name] = ast_context.call.args[i];
+						poly_map[poly.type.name] = ast_context.call.args[i]
 					}
 				}
 			}
 
-			i += 1;
+			i += 1
 		}
 	}
 	
 	for type, i in symbol_value.types {
-		if ident, ok := type.derived.(ast.Ident); ok {
+		if ident, ok := type.derived.(^ast.Ident); ok {
 			if expr, ok := poly_map[ident.name]; ok {
-				symbol_value.types[i] = expr;
+				symbol_value.types[i] = expr
 			}
-		} else if call_expr, ok := type.derived.(ast.Call_Expr); ok {
+		} else if call_expr, ok := type.derived.(^ast.Call_Expr); ok {
 			if call_expr.args == nil {
-				continue;
+				continue
 			}
 
 			for arg, i in call_expr.args {
-				if ident, ok := arg.derived.(ast.Ident); ok {
+				if ident, ok := arg.derived.(^ast.Ident); ok {
 					if expr, ok := poly_map[ident.name]; ok {
-						symbol_value.types[i] = expr;
+						symbol_value.types[i] = expr
 					}
 				}
 			}
@@ -1994,149 +1992,149 @@ resolve_poly_struct :: proc(ast_context: ^AstContext, poly_params: ^ast.Field_Li
 }
 
 get_globals :: proc(file: ast.File, ast_context: ^AstContext) {
-	ast_context.variables["context"] = true;
+	ast_context.variables["context"] = true
 
-	exprs := common.collect_globals(file);
+	exprs := common.collect_globals(file)
 
 	for expr in exprs {
-		ast_context.variables[expr.name] = expr.mutable;
-		ast_context.globals[expr.name] = expr;
+		ast_context.variables[expr.name] = expr.mutable
+		ast_context.globals[expr.name] = expr
 	}
 }
 
 get_generic_assignment :: proc(file: ast.File, value: ^ast.Expr, ast_context: ^AstContext, results: ^[dynamic]^ast.Expr) {
-	using ast;
+	using ast
 
-	ast_context.use_locals = true;
-	ast_context.use_globals = true;
+	ast_context.use_locals = true
+	ast_context.use_globals = true
 
-	switch v in &value.derived {
-	case Call_Expr:
-		ast_context.call = cast(^ast.Call_Expr)value;
+	#partial switch v in value.derived {
+	case ^Call_Expr:
+		ast_context.call = cast(^ast.Call_Expr)value
 	
 		if symbol, ok := resolve_type_expression(ast_context, v.expr); ok {
 			if procedure, ok := symbol.value.(index.SymbolProcedureValue); ok {
 				for ret in procedure.return_types {
-					append(results, ret.type);
+					append(results, ret.type)
 				}
 			}
 		}
-	case Comp_Lit:
+	case ^Comp_Lit:
 		if v.type != nil {
-			append(results, v.type);
+			append(results, v.type)
 		}
-	case Array_Type:
+	case ^Array_Type:
 		if v.elem != nil {
-			append(results, v.elem);
+			append(results, v.elem)
 		}
-	case Dynamic_Array_Type:
+	case ^Dynamic_Array_Type:
 		if v.elem != nil {
-			append(results, v.elem);
+			append(results, v.elem)
 		}
-	case Selector_Expr:
+	case ^Selector_Expr:
 		if v.expr != nil {
-			append(results, value);
+			append(results, value)
 		}
-	case Type_Assertion:
+	case ^Type_Assertion:
 		if v.type != nil {
 			//This is the unique .? that can only be used with maybe
-			if unary, ok := v.type.derived.(ast.Unary_Expr); ok && unary.op.kind == .Question {
-				append(results, cast(^ast.Expr)&v.node);
+			if unary, ok := v.type.derived.(^ast.Unary_Expr); ok && unary.op.kind == .Question {
+				append(results, cast(^ast.Expr)&v.node)
 			} else {
-				append(results, v.type);
+				append(results, v.type)
 			}
 
-			b := make_bool_ast(ast_context);
-			b.pos.file = v.type.pos.file;
-			append(results, b);
+			b := make_bool_ast(ast_context)
+			b.pos.file = v.type.pos.file
+			append(results, b)
 		}
 	case:
 		//log.debugf("default node get_generic_assignment %v", v);
-		append(results, value);
+		append(results, value)
 	}
 }
 
 get_locals_value_decl :: proc(file: ast.File, value_decl: ast.Value_Decl, ast_context: ^AstContext) {
-	using ast;
+	using ast
 
 	if len(value_decl.names) <= 0 {
-		return;
+		return
 	}
 
 	if value_decl.type != nil {
 		for name, i in value_decl.names {
-			str := common.get_ast_node_string(value_decl.names[i], file.src);
-			ast_context.variables[str] = value_decl.is_mutable;
-			store_local(ast_context, value_decl.type, value_decl.end.offset, str, ast_context.local_id);
+			str := common.get_ast_node_string(value_decl.names[i], file.src)
+			ast_context.variables[str] = value_decl.is_mutable
+			store_local(ast_context, value_decl.type, value_decl.end.offset, str, ast_context.local_id)
 		}
-		return;
+		return
 	}
 
-	results := make([dynamic]^Expr, context.temp_allocator);
+	results := make([dynamic]^Expr, context.temp_allocator)
 
 	for value in value_decl.values {
-		get_generic_assignment(file, value, ast_context, &results);
+		get_generic_assignment(file, value, ast_context, &results)
 	}
 
 	if len(results) == 0 {
-		return;
+		return
 	}
 
 	for name, i in value_decl.names {
-		result_i := min(len(results)-1, i);
-		str := common.get_ast_node_string(name, file.src);
-		ast_context.in_package[str] = get_package_from_node(results[result_i]);
-		store_local(ast_context, results[result_i], value_decl.end.offset, str, ast_context.local_id);
-		ast_context.variables[str] = value_decl.is_mutable;
+		result_i := min(len(results)-1, i)
+		str := common.get_ast_node_string(name, file.src)
+		ast_context.in_package[str] = get_package_from_node(results[result_i]^)
+		store_local(ast_context, results[result_i], value_decl.end.offset, str, ast_context.local_id)
+		ast_context.variables[str] = value_decl.is_mutable
 	}
 }
 
 get_locals_stmt :: proc(file: ast.File, stmt: ^ast.Stmt, ast_context: ^AstContext, document_position: ^DocumentPositionContext, save_assign := false) {
-	ast_context.use_locals = true;
-	ast_context.use_globals = true;
-	ast_context.current_package = ast_context.document_package;
+	ast_context.use_locals = true
+	ast_context.use_globals = true
+	ast_context.current_package = ast_context.document_package
 
-	using ast;
+	using ast
 
 	if stmt == nil {
-		return;
+		return
 	}
 
 	if stmt.pos.offset > document_position.position {
-		return;
-	}
-
-	switch v in stmt.derived {
-	case Value_Decl:
-		get_locals_value_decl(file, v, ast_context);
-	case Type_Switch_Stmt:
-		get_locals_type_switch_stmt(file, v, ast_context, document_position);
-	case Switch_Stmt:
-		get_locals_switch_stmt(file, v, ast_context, document_position);
-	case For_Stmt:
-		get_locals_for_stmt(file, v, ast_context, document_position);
-	case Inline_Range_Stmt:
-		get_locals_stmt(file, v.body, ast_context, document_position);
-	case Range_Stmt:
-		get_locals_for_range_stmt(file, v, ast_context, document_position);
-	case If_Stmt:
-		get_locals_if_stmt(file, v, ast_context, document_position);
-	case Block_Stmt:
-		get_locals_block_stmt(file, v, ast_context, document_position);
-	case Proc_Lit:
-		get_locals_stmt(file, v.body, ast_context, document_position);
-	case Assign_Stmt:
+		return
+	}
+
+	#partial switch v in stmt.derived {
+	case ^Value_Decl:
+		get_locals_value_decl(file, v^, ast_context)
+	case ^Type_Switch_Stmt:
+		get_locals_type_switch_stmt(file, v^, ast_context, document_position)
+	case ^Switch_Stmt:
+		get_locals_switch_stmt(file, v^, ast_context, document_position)
+	case ^For_Stmt:
+		get_locals_for_stmt(file, v^, ast_context, document_position)
+	case ^Inline_Range_Stmt:
+		get_locals_stmt(file, v.body, ast_context, document_position)
+	case ^Range_Stmt:
+		get_locals_for_range_stmt(file, v^, ast_context, document_position)
+	case ^If_Stmt:
+		get_locals_if_stmt(file, v^, ast_context, document_position)
+	case ^Block_Stmt:
+		get_locals_block_stmt(file, v^, ast_context, document_position)
+	case ^Proc_Lit:
+		get_locals_stmt(file, v.body, ast_context, document_position)
+	case ^Assign_Stmt:
 		if save_assign {
-			get_locals_assign_stmt(file, v, ast_context);
-		}
-	case Using_Stmt:
-		get_locals_using_stmt(v, ast_context);
-	case When_Stmt:
-		get_locals_stmt(file, v.else_stmt, ast_context, document_position);
-		get_locals_stmt(file, v.body, ast_context, document_position);
-	case Case_Clause:
+			get_locals_assign_stmt(file, v^, ast_context)
+		}
+	case ^Using_Stmt:
+		get_locals_using_stmt(v^, ast_context)
+	case ^When_Stmt:
+		get_locals_stmt(file, v.else_stmt, ast_context, document_position)
+		get_locals_stmt(file, v.body, ast_context, document_position)
+	case ^Case_Clause:
 		for stmt in v.body {
-			get_locals_stmt(file, stmt, ast_context, document_position);
+			get_locals_stmt(file, stmt, ast_context, document_position)
 		}
 	case:
 			//log.debugf("default node local stmt %v", v);
@@ -2145,11 +2143,11 @@ get_locals_stmt :: proc(file: ast.File, stmt: ^ast.Stmt, ast_context: ^AstContex
 
 get_locals_block_stmt :: proc(file: ast.File, block: ast.Block_Stmt, ast_context: ^AstContext, document_position: ^DocumentPositionContext) {
 	if !(block.pos.offset <= document_position.position && document_position.position <= block.end.offset) {
-		return;
+		return
 	}
 
 	for stmt in block.stmts {
-		get_locals_stmt(file, stmt, ast_context, document_position);
+		get_locals_stmt(file, stmt, ast_context, document_position)
 	}
 }
 
@@ -2158,17 +2156,17 @@ get_locals_using_stmt :: proc(stmt: ast.Using_Stmt, ast_context: ^AstContext) {
 		if symbol, ok := resolve_type_expression(ast_context, u); ok {
 			#partial switch v in symbol.value {
 			case index.SymbolPackageValue:
-				if ident, ok := u.derived.(ast.Ident); ok {
-					append(&ast_context.usings, ident.name);
+				if ident, ok := u.derived.(^ast.Ident); ok {
+					append(&ast_context.usings, ident.name)
 				}
 			case index.SymbolStructValue:
 				for name, i in v.names {
-					selector := index.new_type(ast.Selector_Expr, v.types[i].pos, v.types[i].end, context.temp_allocator);
-					selector.expr = u;
-					selector.field = index.new_type(ast.Ident, v.types[i].pos, v.types[i].end, context.temp_allocator);
-					selector.field.name = name;
-					store_local(ast_context, selector, 0, name, ast_context.local_id);
-					ast_context.variables[name] = true;
+					selector := index.new_type(ast.Selector_Expr, v.types[i].pos, v.types[i].end, context.temp_allocator)
+					selector.expr = u
+					selector.field = index.new_type(ast.Ident, v.types[i].pos, v.types[i].end, context.temp_allocator)
+					selector.field.name = name
+					store_local(ast_context, selector, 0, name, ast_context.local_id)
+					ast_context.variables[name] = true
 				}
 			}
 		}
@@ -2176,163 +2174,163 @@ get_locals_using_stmt :: proc(stmt: ast.Using_Stmt, ast_context: ^AstContext) {
 }
 
 get_locals_assign_stmt :: proc(file: ast.File, stmt: ast.Assign_Stmt, ast_context: ^AstContext) {
-	using ast;
+	using ast
 
 	if stmt.lhs == nil || stmt.rhs == nil {
-		return;
+		return
 	}
 
-	results := make([dynamic]^Expr, context.temp_allocator);
+	results := make([dynamic]^Expr, context.temp_allocator)
 
 	for rhs in stmt.rhs {
-		get_generic_assignment(file, rhs, ast_context, &results);
+		get_generic_assignment(file, rhs, ast_context, &results)
 	}
 
 	if len(stmt.lhs) != len(results) {
-		return;
+		return
 	}
 
 	for lhs, i in stmt.lhs {
-		if ident, ok := lhs.derived.(ast.Ident); ok {
-			store_local(ast_context, results[i], ident.pos.offset, ident.name, ast_context.local_id);
-			ast_context.variables[ident.name] = true;
+		if ident, ok := lhs.derived.(^ast.Ident); ok {
+			store_local(ast_context, results[i], ident.pos.offset, ident.name, ast_context.local_id)
+			ast_context.variables[ident.name] = true
 		}
 	}
 }
 
 get_locals_if_stmt :: proc(file: ast.File, stmt: ast.If_Stmt, ast_context: ^AstContext, document_position: ^DocumentPositionContext) {
 	if !(stmt.pos.offset <= document_position.position && document_position.position <= stmt.end.offset) {
-		return;
+		return
 	}
 
-	get_locals_stmt(file, stmt.init, ast_context, document_position, true);
-	get_locals_stmt(file, stmt.body, ast_context, document_position);
-	get_locals_stmt(file, stmt.else_stmt, ast_context, document_position);
+	get_locals_stmt(file, stmt.init, ast_context, document_position, true)
+	get_locals_stmt(file, stmt.body, ast_context, document_position)
+	get_locals_stmt(file, stmt.else_stmt, ast_context, document_position)
 }
 
 get_locals_for_range_stmt :: proc(file: ast.File, stmt: ast.Range_Stmt, ast_context: ^AstContext, document_position: ^DocumentPositionContext) {
-	using ast;
+	using ast
 
 	if !(stmt.body.pos.offset <= document_position.position && document_position.position <= stmt.body.end.offset) {
-		return;
+		return
 	}
 
-	results := make([dynamic]^Expr, context.temp_allocator);
+	results := make([dynamic]^Expr, context.temp_allocator)
 
 	if stmt.expr == nil {
-		return;
+		return
 	}
 	
 	if symbol, ok := resolve_type_expression(ast_context, stmt.expr); ok {
 		#partial switch v in symbol.value {
 		case index.SymbolMapValue:
 			if len(stmt.vals) >= 1 {
-				if ident, ok := stmt.vals[0].derived.(Ident); ok {
-					store_local(ast_context, v.key, ident.pos.offset, ident.name, ast_context.local_id);
-					ast_context.variables[ident.name] = true;
-					ast_context.in_package[ident.name] = symbol.pkg;
+				if ident, ok := stmt.vals[0].derived.(^Ident); ok {
+					store_local(ast_context, v.key, ident.pos.offset, ident.name, ast_context.local_id)
+					ast_context.variables[ident.name] = true
+					ast_context.in_package[ident.name] = symbol.pkg
 				}
 			}
 			if len(stmt.vals) >= 2 {
-				if ident, ok := stmt.vals[1].derived.(Ident); ok {
-					store_local(ast_context, v.value, ident.pos.offset, ident.name, ast_context.local_id);
-					ast_context.variables[ident.name] = true;
-					ast_context.in_package[ident.name] = symbol.pkg;
+				if ident, ok := stmt.vals[1].derived.(^Ident); ok {
+					store_local(ast_context, v.value, ident.pos.offset, ident.name, ast_context.local_id)
+					ast_context.variables[ident.name] = true
+					ast_context.in_package[ident.name] = symbol.pkg
 				}
 			}
 		case index.SymbolDynamicArrayValue:
 			if len(stmt.vals) >= 1 {
-				if ident, ok := stmt.vals[0].derived.(Ident); ok {
-					store_local(ast_context, v.expr, ident.pos.offset, ident.name, ast_context.local_id);
-					ast_context.variables[ident.name] = true;
-					ast_context.in_package[ident.name] = symbol.pkg;
+				if ident, ok := stmt.vals[0].derived.(^Ident); ok {
+					store_local(ast_context, v.expr, ident.pos.offset, ident.name, ast_context.local_id)
+					ast_context.variables[ident.name] = true
+					ast_context.in_package[ident.name] = symbol.pkg
 				}
 			}
 			if len(stmt.vals) >= 2 {
-				if ident, ok := stmt.vals[1].derived.(Ident); ok {
-					store_local(ast_context, make_int_ast(ast_context), ident.pos.offset, ident.name, ast_context.local_id);
-					ast_context.variables[ident.name] = true;
-					ast_context.in_package[ident.name] = symbol.pkg;
+				if ident, ok := stmt.vals[1].derived.(^Ident); ok {
+					store_local(ast_context, make_int_ast(ast_context), ident.pos.offset, ident.name, ast_context.local_id)
+					ast_context.variables[ident.name] = true
+					ast_context.in_package[ident.name] = symbol.pkg
 				}
 			}
 		case index.SymbolFixedArrayValue:
 			if len(stmt.vals) >= 1 {
-				if ident, ok := stmt.vals[0].derived.(Ident); ok {
-					store_local(ast_context, v.expr, ident.pos.offset, ident.name, ast_context.local_id);
-					ast_context.variables[ident.name] = true;
-					ast_context.in_package[ident.name] = symbol.pkg;
+				if ident, ok := stmt.vals[0].derived.(^Ident); ok {
+					store_local(ast_context, v.expr, ident.pos.offset, ident.name, ast_context.local_id)
+					ast_context.variables[ident.name] = true
+					ast_context.in_package[ident.name] = symbol.pkg
 				}
 			}
 
 			if len(stmt.vals) >= 2 {
-				if ident, ok := stmt.vals[1].derived.(Ident); ok {
-					store_local(ast_context, make_int_ast(ast_context), ident.pos.offset, ident.name, ast_context.local_id);
-					ast_context.variables[ident.name] = true;
-					ast_context.in_package[ident.name] = symbol.pkg;
+				if ident, ok := stmt.vals[1].derived.(^Ident); ok {
+					store_local(ast_context, make_int_ast(ast_context), ident.pos.offset, ident.name, ast_context.local_id)
+					ast_context.variables[ident.name] = true
+					ast_context.in_package[ident.name] = symbol.pkg
 				}
 			}
 		case index.SymbolSliceValue:
 			if len(stmt.vals) >= 1 {
-				if ident, ok := stmt.vals[0].derived.(Ident); ok {
-					store_local(ast_context, v.expr, ident.pos.offset, ident.name, ast_context.local_id);
-					ast_context.variables[ident.name] = true;
-					ast_context.in_package[ident.name] = symbol.pkg;
+				if ident, ok := stmt.vals[0].derived.(^Ident); ok {
+					store_local(ast_context, v.expr, ident.pos.offset, ident.name, ast_context.local_id)
+					ast_context.variables[ident.name] = true
+					ast_context.in_package[ident.name] = symbol.pkg
 				}
 			}
 			if len(stmt.vals) >= 2 {
-				if ident, ok := stmt.vals[1].derived.(Ident); ok {
-					store_local(ast_context, make_int_ast(ast_context), ident.pos.offset, ident.name, ast_context.local_id);
-					ast_context.variables[ident.name] = true;
-					ast_context.in_package[ident.name] = symbol.pkg;
+				if ident, ok := stmt.vals[1].derived.(^Ident); ok {
+					store_local(ast_context, make_int_ast(ast_context), ident.pos.offset, ident.name, ast_context.local_id)
+					ast_context.variables[ident.name] = true
+					ast_context.in_package[ident.name] = symbol.pkg
 				}
 			}
 		}
 	}
 	
-	get_locals_stmt(file, stmt.body, ast_context, document_position);
+	get_locals_stmt(file, stmt.body, ast_context, document_position)
 }
 
 get_locals_for_stmt :: proc(file: ast.File, stmt: ast.For_Stmt, ast_context: ^AstContext, document_position: ^DocumentPositionContext) {
 	if !(stmt.pos.offset <= document_position.position && document_position.position <= stmt.end.offset) {
-		return;
+		return
 	}
 
-	get_locals_stmt(file, stmt.init, ast_context, document_position, true);
-	get_locals_stmt(file, stmt.body, ast_context, document_position);
+	get_locals_stmt(file, stmt.init, ast_context, document_position, true)
+	get_locals_stmt(file, stmt.body, ast_context, document_position)
 }
 
 get_locals_switch_stmt :: proc(file: ast.File, stmt: ast.Switch_Stmt, ast_context: ^AstContext, document_position: ^DocumentPositionContext) {
 	if !(stmt.pos.offset <= document_position.position && document_position.position <= stmt.end.offset) {
-		return;
+		return
 	}
 
-	get_locals_stmt(file, stmt.body, ast_context, document_position);
+	get_locals_stmt(file, stmt.body, ast_context, document_position)
 }
 
 get_locals_type_switch_stmt :: proc(file: ast.File, stmt: ast.Type_Switch_Stmt, ast_context: ^AstContext, document_position: ^DocumentPositionContext) {
-	using ast;
+	using ast
 
 	if !(stmt.pos.offset <= document_position.position && document_position.position <= stmt.end.offset) {
-		return;
+		return
 	}
 
 	if stmt.body == nil {
-		return;
+		return
 	}
 
-	if block, ok := stmt.body.derived.(Block_Stmt); ok {
+	if block, ok := stmt.body.derived.(^Block_Stmt); ok {
 		for block_stmt in block.stmts {
-			if cause, ok := block_stmt.derived.(Case_Clause); ok && cause.pos.offset <= document_position.position && document_position.position <= cause.end.offset {
+			if cause, ok := block_stmt.derived.(^Case_Clause); ok && cause.pos.offset <= document_position.position && document_position.position <= cause.end.offset {
 				for b in cause.body {
-					get_locals_stmt(file, b, ast_context, document_position);
+					get_locals_stmt(file, b, ast_context, document_position)
 				}
 
-				tag := stmt.tag.derived.(Assign_Stmt);
+				tag := stmt.tag.derived.(^Assign_Stmt)
 
 				if len(tag.lhs) == 1 && len(cause.list) == 1 {
-					ident := tag.lhs[0].derived.(Ident);
-					store_local(ast_context, cause.list[0], ident.pos.offset, ident.name, ast_context.local_id);
-					ast_context.variables[ident.name] = true;
+					ident := tag.lhs[0].derived.(^Ident)
+					store_local(ast_context, cause.list[0], ident.pos.offset, ident.name, ast_context.local_id)
+					ast_context.variables[ident.name] = true
 				}
 			}
 		}
@@ -2340,32 +2338,32 @@ get_locals_type_switch_stmt :: proc(file: ast.File, stmt: ast.Type_Switch_Stmt,
 }
 
 get_locals_proc_param_and_results :: proc(file: ast.File, function: ast.Proc_Lit, ast_context: ^AstContext, document_position: ^DocumentPositionContext) {
-	proc_lit, ok := function.derived.(ast.Proc_Lit);
+	proc_lit, ok := function.derived.(^ast.Proc_Lit)
 
 	if !ok || proc_lit.body == nil {
-		return;
+		return
 	}
 
 	if proc_lit.type != nil && proc_lit.type.params != nil {
 		for arg in proc_lit.type.params.list {
 			for name in arg.names {
 				if arg.type != nil {
-					str := common.get_ast_node_string(name, file.src);
-					store_local(ast_context, arg.type, name.pos.offset, str, ast_context.local_id);
-					ast_context.variables[str] = true;
-					ast_context.parameters[str] = true;
+					str := common.get_ast_node_string(name, file.src)
+					store_local(ast_context, arg.type, name.pos.offset, str, ast_context.local_id)
+					ast_context.variables[str] = true
+					ast_context.parameters[str] = true
 
 					if .Using in arg.flags {
-						using_stmt: ast.Using_Stmt;
-						using_stmt.list = make([]^ast.Expr, 1, context.temp_allocator);
-						using_stmt.list[0] = arg.type;
-						get_locals_using_stmt(using_stmt, ast_context);
+						using_stmt: ast.Using_Stmt
+						using_stmt.list = make([]^ast.Expr, 1, context.temp_allocator)
+						using_stmt.list[0] = arg.type
+						get_locals_using_stmt(using_stmt, ast_context)
 					}
 				} else {
-					str := common.get_ast_node_string(name, file.src);
-					store_local(ast_context, arg.default_value, name.pos.offset, str, ast_context.local_id);
-					ast_context.variables[str] = true;
-					ast_context.parameters[str] = true;
+					str := common.get_ast_node_string(name, file.src)
+					store_local(ast_context, arg.default_value, name.pos.offset, str, ast_context.local_id)
+					ast_context.variables[str] = true
+					ast_context.parameters[str] = true
 				}
 			}
 		}
@@ -2375,10 +2373,10 @@ get_locals_proc_param_and_results :: proc(file: ast.File, function: ast.Proc_Lit
 		for result in proc_lit.type.results.list {
 			for name in result.names {
 				if result.type != nil {
-					str := common.get_ast_node_string(name, file.src);
-					store_local(ast_context, result.type, name.pos.offset, str, ast_context.local_id);
-					ast_context.variables[str] = true;
-					ast_context.parameters[str] = true;
+					str := common.get_ast_node_string(name, file.src)
+					store_local(ast_context, result.type, name.pos.offset, str, ast_context.local_id)
+					ast_context.variables[str] = true
+					ast_context.parameters[str] = true
 				}
 			}
 		}
@@ -2386,50 +2384,50 @@ get_locals_proc_param_and_results :: proc(file: ast.File, function: ast.Proc_Lit
 }
 
 get_locals :: proc(file: ast.File, function: ^ast.Node, ast_context: ^AstContext, document_position: ^DocumentPositionContext) {
-	proc_lit, ok := function.derived.(ast.Proc_Lit);
+	proc_lit, ok := function.derived.(^ast.Proc_Lit)
 
 	if !ok || proc_lit.body == nil {
-		return;
+		return
 	}
 
-	get_locals_proc_param_and_results(file, proc_lit, ast_context, document_position);
+	get_locals_proc_param_and_results(file, proc_lit^, ast_context, document_position)
 
-	block: ast.Block_Stmt;
-	block, ok = proc_lit.body.derived.(ast.Block_Stmt);
+	block: ^ast.Block_Stmt
+	block, ok = proc_lit.body.derived.(^ast.Block_Stmt)
 
 	if !ok {
-		log.error("Proc_List body not block");
-		return;
+		log.error("Proc_List body not block")
+		return
 	}
 
 	for stmt in block.stmts {
-		get_locals_stmt(file, stmt, ast_context, document_position);
+		get_locals_stmt(file, stmt, ast_context, document_position)
 	}
 }
 
 clear_locals :: proc(ast_context: ^AstContext) {
-	clear(&ast_context.locals);
-	clear(&ast_context.parameters);
-	clear(&ast_context.variables);
-	clear(&ast_context.usings);
+	clear(&ast_context.locals)
+	clear(&ast_context.parameters)
+	clear(&ast_context.variables)
+	clear(&ast_context.usings)
 }
 
 resolve_entire_file :: proc(document: ^common.Document, allocator := context.allocator) -> map[uintptr]index.Symbol {
-	ast_context := make_ast_context(document.ast, document.imports, document.package_name, document.uri.uri, allocator);
+	ast_context := make_ast_context(document.ast, document.imports, document.package_name, document.uri.uri, allocator)
 
-	get_globals(document.ast, &ast_context);
+	get_globals(document.ast, &ast_context)
 
-	ast_context.current_package = ast_context.document_package;
+	ast_context.current_package = ast_context.document_package
 
-	symbols := make(map[uintptr]index.Symbol, 100, allocator);
+	symbols := make(map[uintptr]index.Symbol, 100, allocator)
 
 	for k, v in ast_context.globals {
-		resolve_entire_decl(&ast_context, v.expr, &symbols, allocator);
-		clear_local_group(&ast_context, 0);
-		add_local_group(&ast_context, 0);
+		resolve_entire_decl(&ast_context, v.expr, &symbols, allocator)
+		clear_local_group(&ast_context, 0)
+		add_local_group(&ast_context, 0)
 	}
 
-	return symbols;
+	return symbols
 }
 
 resolve_entire_decl :: proc(ast_context: ^AstContext, decl: ^ast.Expr, symbols: ^map[uintptr]index.Symbol, allocator := context.allocator) {
@@ -2449,75 +2447,75 @@ resolve_entire_decl :: proc(ast_context: ^AstContext, decl: ^ast.Expr, symbols:
 		ast_context = ast_context,
 		symbols = symbols,
 		scopes = make([dynamic]Scope, allocator),
-	};
+	}
 
 	visit :: proc(visitor: ^ast.Visitor, node: ^ast.Node) -> ^ast.Visitor {
 		if node == nil || visitor == nil {
-			return nil;
+			return nil
 		}
-		data := cast(^Visit_Data)visitor.data;
-		ast_context := data.ast_context;
-		ast_context.use_locals = true;
-		ast_context.use_globals = true;
+		data := cast(^Visit_Data)visitor.data
+		ast_context := data.ast_context
+		ast_context.use_locals = true
+		ast_context.use_globals = true
 
 		//It's somewhat silly to check the scope everytime, but the alternative is to implement my own walker function.
 		if len(data.scopes) > 0 {
-			current_scope := data.scopes[len(data.scopes)-1];
+			current_scope := data.scopes[len(data.scopes)-1]
 
 			if current_scope.offset < node.end.offset {
-				clear_local_group(ast_context, current_scope.id);
+				clear_local_group(ast_context, current_scope.id)
 
-				pop(&data.scopes);
+				pop(&data.scopes)
 
 				if len(data.scopes) > 0 {
-					current_scope = data.scopes[len(data.scopes)-1];
-					ast_context.local_id = current_scope.id;
+					current_scope = data.scopes[len(data.scopes)-1]
+					ast_context.local_id = current_scope.id
 				} else {
-					ast_context.local_id = 0;
+					ast_context.local_id = 0
 				}
 			}	
 		}
 
-		switch v in &node.derived {
-		case ast.If_Stmt, ast.For_Stmt, ast.Range_Stmt, ast.Inline_Range_Stmt, ast.Proc_Lit:
-			scope: Scope;
-			scope.id = data.id_counter;
-			scope.offset = node.end.offset;
-			data.id_counter += 1;
-			ast_context.local_id = scope.id;
+		#partial switch v in node.derived {
+		case ^ast.If_Stmt, ^ast.For_Stmt, ^ast.Range_Stmt, ^ast.Inline_Range_Stmt, ^ast.Proc_Lit:
+			scope: Scope
+			scope.id = data.id_counter
+			scope.offset = node.end.offset
+			data.id_counter += 1
+			ast_context.local_id = scope.id
 
-			append(&data.scopes, scope);
-			add_local_group(ast_context, scope.id);
+			append(&data.scopes, scope)
+			add_local_group(ast_context, scope.id)
 
-			position_context: DocumentPositionContext;
-			position_context.position = node.end.offset;
-			get_locals_stmt(ast_context.file, cast(^ast.Stmt)node, ast_context, &position_context);
-		case ast.Ident:
-			if symbol, ok := resolve_type_identifier(ast_context, v); ok {
-				data.symbols[cast(uintptr)node] = symbol;
+			position_context: DocumentPositionContext
+			position_context.position = node.end.offset
+			get_locals_stmt(ast_context.file, cast(^ast.Stmt)node, ast_context, &position_context)
+		case ^ast.Ident:
+			if symbol, ok := resolve_type_identifier(ast_context, v^); ok {
+				data.symbols[cast(uintptr)node] = symbol
 			}
-		case ast.Selector_Expr:
+		case ^ast.Selector_Expr:
 			if symbol, ok := resolve_type_expression(ast_context, &v.node); ok {
-				data.symbols[cast(uintptr)node] = symbol;
+				data.symbols[cast(uintptr)node] = symbol
 			}
-		case ast.Call_Expr:
+		case ^ast.Call_Expr:
 			if symbol, ok := resolve_type_expression(ast_context, &v.node); ok {
-				data.symbols[cast(uintptr)node] = symbol;
+				data.symbols[cast(uintptr)node] = symbol
 			}
 		}
 
-		switch v in &node.derived {
-		case ast.Proc_Lit:
+		#partial switch v in node.derived {
+		case ^ast.Proc_Lit:
 			if v.body == nil {
-				break;
+				break
 			}
 		
-			type_position_context: DocumentPositionContext;
-			type_position_context.position = v.end.offset;
-			get_locals_proc_param_and_results(ast_context.file, v, ast_context, &type_position_context);
+			type_position_context: DocumentPositionContext
+			type_position_context.position = v.end.offset
+			get_locals_proc_param_and_results(ast_context.file, v^, ast_context, &type_position_context)
 		}
 
-		return visitor;
+		return visitor
 	}
 
 	visitor := ast.Visitor {
@@ -2525,7 +2523,7 @@ resolve_entire_decl :: proc(ast_context: ^AstContext, decl: ^ast.Expr, symbols:
 		visit = visit,
 	}
 
-	ast.walk(&visitor, decl);
+	ast.walk(&visitor, decl)
 }
 
 concatenate_symbol_information :: proc {
@@ -2534,113 +2532,113 @@ concatenate_symbol_information :: proc {
 }
 
 concatenate_raw_symbol_information :: proc(ast_context: ^AstContext, symbol: index.Symbol, is_completion: bool) -> string {
-	return concatenate_raw_string_information(ast_context, symbol.pkg, symbol.name, symbol.signature, symbol.type, is_completion);
+	return concatenate_raw_string_information(ast_context, symbol.pkg, symbol.name, symbol.signature, symbol.type, is_completion)
 }
 
 concatenate_raw_string_information :: proc(ast_context: ^AstContext, pkg: string, name: string, signature: string, type: index.SymbolType, is_completion: bool) -> string {
-	pkg := path.base(pkg, false, context.temp_allocator);
+	pkg := path.base(pkg, false, context.temp_allocator)
 
 	if type == .Package {
-		return fmt.tprintf("%v: package", name);
+		return fmt.tprintf("%v: package", name)
 	} else if type == .Keyword && is_completion {
-		return name;
+		return name
 	} else {
 		if signature != "" {
-			return fmt.tprintf("%v.%v: %v", pkg, name, signature);
+			return fmt.tprintf("%v.%v: %v", pkg, name, signature)
 		} else {
-			return fmt.tprintf("%v.%v", pkg, name);
+			return fmt.tprintf("%v.%v", pkg, name)
 		}
 	}
 }
 
 unwrap_enum :: proc(ast_context: ^AstContext, node: ^ast.Expr) -> (index.SymbolEnumValue, bool) {
 	if node == nil {
-		return {}, false;
+		return {}, false
 	}
 
 	if enum_symbol, ok := resolve_type_expression(ast_context, node); ok {
 
 		if enum_value, ok := enum_symbol.value.(index.SymbolEnumValue); ok {
-			return enum_value, true;
+			return enum_value, true
 		}
 	}
 
-	return {}, false;
+	return {}, false
 }
 
 unwrap_union :: proc(ast_context: ^AstContext, node: ^ast.Expr) -> (index.SymbolUnionValue, bool) {
 	if union_symbol, ok := resolve_type_expression(ast_context, node); ok {
 		if union_value, ok := union_symbol.value.(index.SymbolUnionValue); ok {
-			return union_value, true;
+			return union_value, true
 		}
 	}
 
-	return {}, false;
+	return {}, false
 }
 
 unwrap_bitset :: proc(ast_context: ^AstContext, bitset_symbol: index.Symbol) -> (index.SymbolEnumValue, bool) {
 	if bitset_value, ok := bitset_symbol.value.(index.SymbolBitSetValue); ok {
 		if enum_symbol, ok := resolve_type_expression(ast_context, bitset_value.expr); ok {
 			if enum_value, ok := enum_symbol.value.(index.SymbolEnumValue); ok {
-				return enum_value, true;
+				return enum_value, true
 			}
 		}
 	}
 
-	return {}, false;
+	return {}, false
 }
 
 get_signature :: proc(ast_context: ^AstContext, ident: ast.Ident, symbol: index.Symbol, was_variable := false) -> string {
-	using index;
+	using index
 
 	if symbol.type == .Function {
-		return symbol.signature;
+		return symbol.signature
 	}
 
 	if .Distinct in symbol.flags {
-		return symbol.name;
+		return symbol.name
 	}
 
-	is_variable := symbol.type == .Variable;
+	is_variable := symbol.type == .Variable
 
 	#partial switch v in symbol.value {
 	case SymbolBasicValue:
-		return common.node_to_string(v.ident);
+		return common.node_to_string(v.ident)
 	case SymbolBitSetValue:
-		return common.node_to_string(v.expr);
+		return common.node_to_string(v.expr)
 	case SymbolEnumValue:
 		if is_variable {
-			return symbol.name;
+			return symbol.name
 		}
 		else {
-			return "enum";
+			return "enum"
 		}
 	case SymbolMapValue:
-		return strings.concatenate(a = {"map[", common.node_to_string(v.key), "]", common.node_to_string(v.value)}, allocator = ast_context.allocator);
+		return strings.concatenate(a = {"map[", common.node_to_string(v.key), "]", common.node_to_string(v.value)}, allocator = ast_context.allocator)
 	case SymbolProcedureValue:
-		return "proc";
+		return "proc"
 	case SymbolStructValue:
 		if is_variable {
-			return symbol.name;
+			return symbol.name
 		}
 		else {
-			return "struct";
+			return "struct"
 		}
 	case SymbolUnionValue:
 		if is_variable {
-			return symbol.name;
+			return symbol.name
 		}
 		else {
-			return "union";
+			return "union"
 		}
 	case SymbolDynamicArrayValue:
-		return strings.concatenate(a = {"[dynamic]", common.node_to_string(v.expr)}, allocator = ast_context.allocator);
+		return strings.concatenate(a = {"[dynamic]", common.node_to_string(v.expr)}, allocator = ast_context.allocator)
 	case SymbolSliceValue:
-		return strings.concatenate(a = {"[]", common.node_to_string(v.expr)}, allocator = ast_context.allocator);
+		return strings.concatenate(a = {"[]", common.node_to_string(v.expr)}, allocator = ast_context.allocator)
 	case SymbolFixedArrayValue:
-		return strings.concatenate(a = {"[", common.node_to_string(v.len), "]", common.node_to_string(v.expr)}, allocator = ast_context.allocator);
+		return strings.concatenate(a = {"[", common.node_to_string(v.len), "]", common.node_to_string(v.expr)}, allocator = ast_context.allocator)
 	case SymbolPackageValue:
-		return "package";
+		return "package"
 	case SymbolUntypedValue:
 		switch v.type {
 		case .Float:   return "float"
@@ -2650,74 +2648,71 @@ get_signature :: proc(ast_context: ^AstContext, ident: ast.Ident, symbol: index.
 		}
 	}
 	
-	return "";
+	return ""
 }
 
 position_in_proc_decl :: proc(position_context: ^DocumentPositionContext) -> bool {
 	if position_context.value_decl == nil {
-		return false;
+		return false
 	}
 
 	if len(position_context.value_decl.values) != 1 {
-		return false;
+		return false
 	}
 
-	if _, ok := position_context.value_decl.values[0].derived.(ast.Proc_Type); ok {
-		return true;
+	if _, ok := position_context.value_decl.values[0].derived.(^ast.Proc_Type); ok {
+		return true
 	}
 
-	if proc_lit, ok := position_context.value_decl.values[0].derived.(ast.Proc_Lit); ok {
+	if proc_lit, ok := position_context.value_decl.values[0].derived.(^ast.Proc_Lit); ok {
 		if proc_lit.type != nil && position_in_node(proc_lit.type, position_context.position) {
-			return true;
+			return true
 		}
 	}
 
-	return false;
+	return false
 }
 
 
 is_lhs_comp_lit :: proc(position_context: ^DocumentPositionContext) -> bool {
-
 	if position_context.position <= position_context.comp_lit.open.offset {
-		return false;
+		return false
 	}
 
 	if len(position_context.comp_lit.elems) == 0 {
-		return true;
+		return true
 	}
 
 	for elem in position_context.comp_lit.elems {
-
 		if position_in_node(elem, position_context.position) {
-
-			if ident, ok := elem.derived.(ast.Ident); ok {
-				return true;
-			} else if field, ok := elem.derived.(ast.Field_Value); ok {
+			if ident, ok := elem.derived.(^ast.Ident); ok {
+				return true
+			} else if field, ok := elem.derived.(^ast.Field_Value); ok {
 
 				if position_in_node(field.value, position_context.position) {
-					return false;
+					return false
 				}
 			}
 		}
 	}
 
-	return true;
+	return true
 }
 
 field_exists_in_comp_lit :: proc(comp_lit: ^ast.Comp_Lit, name: string) -> bool {
 	for elem in comp_lit.elems {
-		if field, ok := elem.derived.(ast.Field_Value); ok {
+		if field, ok := elem.derived.(^ast.Field_Value); ok {
 			if field.field != nil {
-				if ident, ok := field.field.derived.(ast.Ident); ok {
+				if ident, ok := field.field.derived.(^ast.Ident); ok {
 					if ident.name == name {
-						return true;
+						return true
 					}
 				}
 			}
 		}
 	}
 
-	return false;
+	return false
 }
 
 /*
@@ -2725,183 +2720,183 @@ field_exists_in_comp_lit :: proc(comp_lit: ^ast.Comp_Lit, name: string) -> bool
 */
 get_call_commas :: proc(position_context: ^DocumentPositionContext, document: ^common.Document) {
 	if position_context.call == nil {
-		return;
+		return
 	}
 
-	commas := make([dynamic]int, 0, 10, context.temp_allocator);
+	commas := make([dynamic]int, 0, 10, context.temp_allocator)
 
-	paren_count := 0;
-	bracket_count := 0;
-	brace_count := 0;
+	paren_count := 0
+	bracket_count := 0
+	brace_count := 0
 
-	if call, ok := position_context.call.derived.(ast.Call_Expr); ok {
+	if call, ok := position_context.call.derived.(^ast.Call_Expr); ok {
 		if document.text[call.open.offset] == '(' {
-			paren_count -= 1;
+			paren_count -= 1
 		}
 		for i := call.open.offset; i < call.close.offset; i += 1 {
 			switch document.text[i] {
-			case '[': paren_count += 1;
-			case ']': paren_count -= 1;
-			case '{': brace_count += 1;
-			case '}': brace_count -= 1;
-			case '(': paren_count += 1;
-			case ')': paren_count -= 1;
+			case '[': paren_count += 1
+			case ']': paren_count -= 1
+			case '{': brace_count += 1
+			case '}': brace_count -= 1
+			case '(': paren_count += 1
+			case ')': paren_count -= 1
 			case ',':
 				if paren_count == 0 && brace_count == 0 && bracket_count == 0 {
-					append(&commas, i);
+					append(&commas, i)
 				}
 			}
 		}
 	}
 
-	position_context.call_commas = commas[:];
+	position_context.call_commas = commas[:]
 }
 
 type_to_string :: proc(ast_context: ^AstContext, expr: ^ast.Expr) -> string {
 	if symbol, ok := resolve_type_expression(ast_context, expr); ok {
 		if .Anonymous in symbol.flags {
-			return symbol.name;
+			return symbol.name
 		}
 	}
 
-	return  common.node_to_string(expr);
+	return  common.node_to_string(expr)
 }
 
 /*
 	Figure out what exactly is at the given position and whether it is in a function, struct, etc.
 */
 get_document_position_context :: proc(document: ^common.Document, position: common.Position, hint: DocumentPositionContextHint) -> (DocumentPositionContext, bool) {
-	position_context: DocumentPositionContext;
+	position_context: DocumentPositionContext
 
-	position_context.hint = hint;
-	position_context.file = document.ast;
-	position_context.line = position.line;
+	position_context.hint = hint
+	position_context.file = document.ast
+	position_context.line = position.line
 
-	absolute_position, ok := common.get_absolute_position(position, document.text);
+	absolute_position, ok := common.get_absolute_position(position, document.text)
 
 	if !ok {
-		log.error("failed to get absolute position");
-		return position_context, false;
+		log.error("failed to get absolute position")
+		return position_context, false
 	}
 
-	position_context.position = absolute_position;
+	position_context.position = absolute_position
 
-	exists_in_decl := false;
+	exists_in_decl := false
 
 	for decl in document.ast.decls {
 		if position_in_node(decl, position_context.position) {
-			get_document_position(decl, &position_context);
-			exists_in_decl = true;
-			switch v in decl.derived {
-			case ast.Expr_Stmt:
-				position_context.global_lhs_stmt = true;
+			get_document_position(decl, &position_context)
+			exists_in_decl = true
+			#partial switch v in decl.derived {
+			case ^ast.Expr_Stmt:
+				position_context.global_lhs_stmt = true
 			}
-			break;
+			break
 		}
 	}
 
 	for import_stmt in document.ast.imports {
 		if position_in_node(import_stmt, position_context.position) {
-			position_context.import_stmt = import_stmt;
-			break;
+			position_context.import_stmt = import_stmt
+			break
 		}
 	}
 
 	if !exists_in_decl && position_context.import_stmt == nil {
-		position_context.abort_completion = true;
+		position_context.abort_completion = true
 	}
 
 	if !position_in_node(position_context.comp_lit, position_context.position) {
-		position_context.comp_lit = nil;
+		position_context.comp_lit = nil
 	}
 
 	if !position_in_node(position_context.parent_comp_lit, position_context.position) {
-		position_context.parent_comp_lit = nil;
+		position_context.parent_comp_lit = nil
 	}
 
 	if !position_in_node(position_context.assign, position_context.position) {
-		position_context.assign = nil;
+		position_context.assign = nil
 	}
 
 	if !position_in_node(position_context.binary, position_context.position) {
-		position_context.binary = nil;
+		position_context.binary = nil
 	}
 
 	if !position_in_node(position_context.parent_binary, position_context.position) {
-		position_context.parent_binary = nil;
+		position_context.parent_binary = nil
 	}
 
 	if hint == .Completion && position_context.selector == nil && position_context.field == nil {
-		fallback_position_context_completion(document, position, &position_context);
+		fallback_position_context_completion(document, position, &position_context)
 	}
 
 	if (hint == .SignatureHelp || hint == .Completion) && position_context.call == nil {
-		fallback_position_context_signature(document, position, &position_context);
+		fallback_position_context_signature(document, position, &position_context)
 	}
 
 	if hint == .SignatureHelp {
-		get_call_commas(&position_context, document);
+		get_call_commas(&position_context, document)
 	}
 
-	return position_context, true;
+	return position_context, true
 }
 
 //terrible fallback code
 fallback_position_context_completion :: proc(document: ^common.Document, position: common.Position, position_context: ^DocumentPositionContext) {
-	paren_count:   int;
-	bracket_count: int;
-	end:           int;
-	start:         int;
-	empty_dot:     bool;
-	empty_arrow:   bool;
-	last_dot:      bool;
-	last_arrow:    bool;
-	dots_seen:     int;
-	partial_arrow: bool;
+	paren_count:   int
+	bracket_count: int
+	end:           int
+	start:         int
+	empty_dot:     bool
+	empty_arrow:   bool
+	last_dot:      bool
+	last_arrow:    bool
+	dots_seen:     int
+	partial_arrow: bool
 
-	i := position_context.position - 1;
+	i := position_context.position - 1
 
-	end = i;
+	end = i
 
 	for i > 0 {
 
-		c := position_context.file.src[i];
+		c := position_context.file.src[i]
 
 		if c == '(' && paren_count == 0 {
-			start = i + 1;
-			break;
+			start = i + 1
+			break
 		} else if c == '[' && bracket_count == 0 {
-			start = i + 1;
-			break;
+			start = i + 1
+			break
 		} else if c == ']' && !last_dot {
-			start = i + 1;
-			break;
+			start = i + 1
+			break
 		} else if c == ')' && !last_dot {
-			start = i + 1;
-			break;
+			start = i + 1
+			break
 		} else if c == ')' {
-			paren_count -= 1;
+			paren_count -= 1
 		} else if c == '(' {
-			paren_count += 1;
+			paren_count += 1
 		} else if c == '[' {
-			bracket_count += 1;
+			bracket_count += 1
 		} else if c == ']' {
-			bracket_count -= 1;
+			bracket_count -= 1
 		} else if c == '.' {
-			dots_seen += 1;
-			last_dot = true;
-			i -= 1;
-			continue;
+			dots_seen += 1
+			last_dot = true
+			i -= 1
+			continue
 		} else if position_context.file.src[max(0, i - 1)] == '-' && c == '>' {
-			last_arrow = true;
-			i -= 2;
-			continue;
+			last_arrow = true
+			i -= 2
+			continue
 		}
 
 		//ignore everything in the bracket
 		if bracket_count != 0 || paren_count != 0 {
-			i -= 1;
-			continue;
+			i -= 1
+			continue
 		}
 
 		//yeah..
@@ -2910,51 +2905,51 @@ fallback_position_context_completion :: proc(document: ^common.Document, positio
 		c == '\n' || c == '\r' || c == '=' ||
 		c == '<' || c == '-' || c == '!' ||
 		c == '+' || c == '&'|| c == '|' {
-			start = i + 1;
-			break;
+			start = i + 1
+			break
 		} else if c == '>' {
-			partial_arrow = true;
+			partial_arrow = true
 		}
 
-		last_dot = false;
-		last_arrow = false;
+		last_dot = false
+		last_arrow = false
 
-		i -= 1;
+		i -= 1
 	}
 
 	if i >= 0 && position_context.file.src[end] == '.' {
-		empty_dot = true;
-		end -= 1;
+		empty_dot = true
+		end -= 1
 	} else if i >= 0 && position_context.file.src[max(0, end - 1)] == '-' && position_context.file.src[end] == '>' {
-		empty_arrow = true;
-		end -= 2;
-		position_context.arrow = true;
+		empty_arrow = true
+		end -= 2
+		position_context.arrow = true
 	}
 
-	begin_offset := max(0, start);
-	end_offset   := max(start, end + 1);
+	begin_offset := max(0, start)
+	end_offset   := max(start, end + 1)
 
-	str := position_context.file.src[0:end_offset];
+	str := position_context.file.src[0:end_offset]
 
 	if empty_dot && end_offset - begin_offset == 0 {
-		position_context.implicit = true;
-		return;
+		position_context.implicit = true
+		return
 	}
 
-	s := string(position_context.file.src[begin_offset:end_offset]);
+	s := string(position_context.file.src[begin_offset:end_offset])
 
 	if !partial_arrow {
 
-		only_whitespaces := true;
+		only_whitespaces := true
 
 		for r in s {
 			if !strings.is_space(r) {
-				only_whitespaces = false;
+				only_whitespaces = false
 			}
 		}
 
 		if only_whitespaces {
-			return;
+			return
 		}
 	}
 
@@ -2962,149 +2957,149 @@ fallback_position_context_completion :: proc(document: ^common.Document, positio
 		err = common.parser_warning_handler,  //empty
 		warn = common.parser_warning_handler, //empty
 		file = &position_context.file,
-	};
+	}
 
-	tokenizer.init(&p.tok, str, position_context.file.fullpath, common.parser_warning_handler);
+	tokenizer.init(&p.tok, str, position_context.file.fullpath, common.parser_warning_handler)
 
-	p.tok.ch = ' ';
-	p.tok.line_count = position.line;
-	p.tok.offset = begin_offset;
-	p.tok.read_offset = begin_offset;
+	p.tok.ch = ' '
+	p.tok.line_count = position.line
+	p.tok.offset = begin_offset
+	p.tok.read_offset = begin_offset
 
-	tokenizer.advance_rune(&p.tok);
+	tokenizer.advance_rune(&p.tok)
 
 	if p.tok.ch == utf8.RUNE_BOM {
-		tokenizer.advance_rune(&p.tok);
+		tokenizer.advance_rune(&p.tok)
 	}
 
-	parser.advance_token(&p);
+	parser.advance_token(&p)
 
-	context.allocator = context.temp_allocator;
+	context.allocator = context.temp_allocator
 
-	e := parser.parse_expr(&p, true);
+	e := parser.parse_expr(&p, true)
 
 	if empty_dot || empty_arrow {
-		position_context.selector = e;
-	} else if s, ok := e.derived.(ast.Selector_Expr); ok {
-		position_context.selector = s.expr;
-		position_context.field = s.field;
-	} else if s, ok := e.derived.(ast.Implicit_Selector_Expr); ok {
-		position_context.implicit = true;
-	} else if s, ok := e.derived.(ast.Tag_Expr); ok {
-		position_context.tag = s.expr;
-	} else if bad_expr, ok := e.derived.(ast.Bad_Expr); ok {
+		position_context.selector = e
+	} else if s, ok := e.derived.(^ast.Selector_Expr); ok {
+		position_context.selector = s.expr
+		position_context.field = s.field
+	} else if s, ok := e.derived.(^ast.Implicit_Selector_Expr); ok {
+		position_context.implicit = true
+	} else if s, ok := e.derived.(^ast.Tag_Expr); ok {
+		position_context.tag = s.expr
+	} else if bad_expr, ok := e.derived.(^ast.Bad_Expr); ok {
 		//this is most likely because of use of 'in', 'context', etc.
 		//try to go back one dot.
 
-		src_with_dot := string(position_context.file.src[0:min(len(position_context.file.src), end_offset + 1)]);
-		last_dot     := strings.last_index(src_with_dot, ".");
+		src_with_dot := string(position_context.file.src[0:min(len(position_context.file.src), end_offset + 1)])
+		last_dot     := strings.last_index(src_with_dot, ".")
 
 		if last_dot == -1 {
-			return;
+			return
 		}
 
-		tokenizer.init(&p.tok, position_context.file.src[0:last_dot], position_context.file.fullpath, common.parser_warning_handler);
+		tokenizer.init(&p.tok, position_context.file.src[0:last_dot], position_context.file.fullpath, common.parser_warning_handler)
 
-		p.tok.ch = ' ';
-		p.tok.line_count = position.line;
-		p.tok.offset = begin_offset;
-		p.tok.read_offset = begin_offset;
+		p.tok.ch = ' '
+		p.tok.line_count = position.line
+		p.tok.offset = begin_offset
+		p.tok.read_offset = begin_offset
 
-		tokenizer.advance_rune(&p.tok);
+		tokenizer.advance_rune(&p.tok)
 
 		if p.tok.ch == utf8.RUNE_BOM {
-			tokenizer.advance_rune(&p.tok);
+			tokenizer.advance_rune(&p.tok)
 		}
 
-		parser.advance_token(&p);
+		parser.advance_token(&p)
 
-		e := parser.parse_expr(&p, true);
+		e := parser.parse_expr(&p, true)
 
 		if e == nil {
-			position_context.abort_completion = true;
-			return;
-		} else if e, ok := e.derived.(ast.Bad_Expr); ok {
-			position_context.abort_completion = true;
-			return;
+			position_context.abort_completion = true
+			return
+		} else if e, ok := e.derived.(^ast.Bad_Expr); ok {
+			position_context.abort_completion = true
+			return
 		}
 
-		position_context.selector = e;
+		position_context.selector = e
 
-		ident := index.new_type(ast.Ident, e.pos, e.end, context.temp_allocator);
-		ident.name = string(position_context.file.src[last_dot + 1:end_offset]);
+		ident := index.new_type(ast.Ident, e.pos, e.end, context.temp_allocator)
+		ident.name = string(position_context.file.src[last_dot + 1:end_offset])
 
 		if ident.name != "" {
-			position_context.field = ident;
+			position_context.field = ident
 		}
 	} else {
-		position_context.identifier = e;
+		position_context.identifier = e
 	}
 }
 
 fallback_position_context_signature :: proc(document: ^common.Document, position: common.Position, position_context: ^DocumentPositionContext) {
-	end:   int;
-	start: int;
-	i := position_context.position - 1;
-	end = i;
+	end:   int
+	start: int
+	i := position_context.position - 1
+	end = i
 
 	for i > 0 {
 
-		c := position_context.file.src[i];
+		c := position_context.file.src[i]
 
 		if c == ' ' || c == '\n' || c == '\r' {
-			start = i + 1;
-			break;
+			start = i + 1
+			break
 		}
 
-		i -= 1;
+		i -= 1
 	}
 
 	if end < 0 {
-		return;
+		return
 	}
 
 	if position_context.file.src[end] != '(' {
-		return;
+		return
 	}
 
-	end -= 1;
+	end -= 1
 
-	begin_offset := max(0, start);
-	end_offset   := max(start, end + 1);
+	begin_offset := max(0, start)
+	end_offset   := max(start, end + 1)
 
 	if end_offset - begin_offset <= 1 {
-		return;
+		return
 	}
 
-	str := position_context.file.src[0:end_offset];
+	str := position_context.file.src[0:end_offset]
 
 	p := parser.Parser {
 		err = common.parser_warning_handler,  //empty
 		warn = common.parser_warning_handler, //empty
 		file = &position_context.file,
-	};
+	}
 
-	tokenizer.init(&p.tok, str, position_context.file.fullpath, common.parser_warning_handler);
+	tokenizer.init(&p.tok, str, position_context.file.fullpath, common.parser_warning_handler)
 
-	p.tok.ch = ' ';
-	p.tok.line_count = position.line;
-	p.tok.offset = begin_offset;
-	p.tok.read_offset = begin_offset;
+	p.tok.ch = ' '
+	p.tok.line_count = position.line
+	p.tok.offset = begin_offset
+	p.tok.read_offset = begin_offset
 
-	tokenizer.advance_rune(&p.tok);
+	tokenizer.advance_rune(&p.tok)
 
 	if p.tok.ch == utf8.RUNE_BOM {
-		tokenizer.advance_rune(&p.tok);
+		tokenizer.advance_rune(&p.tok)
 	}
 
-	parser.advance_token(&p);
+	parser.advance_token(&p)
 
-	context.allocator = context.temp_allocator;
+	context.allocator = context.temp_allocator
 
-	position_context.call = parser.parse_expr(&p, true);
+	position_context.call = parser.parse_expr(&p, true)
 
-	if _, ok := position_context.call.derived.(ast.Proc_Type); ok {
-		position_context.call = nil;
+	if _, ok := position_context.call.derived.(^ast.Proc_Type); ok {
+		position_context.call = nil
 	}
 	
 	//log.error(string(position_context.file.src[begin_offset:end_offset]));
@@ -3118,81 +3113,81 @@ get_document_position ::proc {
 	get_document_position_array,
 	get_document_position_dynamic_array,
 	get_document_position_node,
-};
+}
 
 get_document_position_array :: proc(array: $A/[]^$T, position_context: ^DocumentPositionContext) {
 	for elem, i in array {
-		get_document_position(elem, position_context);
+		get_document_position(elem, position_context)
 	}
 }
 
 get_document_position_dynamic_array :: proc(array: $A/[dynamic]^$T, position_context: ^DocumentPositionContext) {
 	for elem, i in array {
-		get_document_position(elem, position_context);
+		get_document_position(elem, position_context)
 	}
 }
 
 position_in_node :: proc(node: ^ast.Node, position: common.AbsolutePosition) -> bool {
-	return node != nil && node.pos.offset <= position && position <= node.end.offset;
+	return node != nil && node.pos.offset <= position && position <= node.end.offset
 }
 
 get_document_position_node :: proc(node: ^ast.Node, position_context: ^DocumentPositionContext) {
-	using ast;
+	using ast
 
 	if node == nil {
-		return;
+		return
 	}
 
 	if !position_in_node(node, position_context.position) {
-		return;
+		return
 	}
 
-	switch n in node.derived {
-	case Bad_Expr:
-	case Ident:
-		position_context.identifier = node;
-	case Implicit:
-	case Undef:
-	case Basic_Lit:
-	case Ellipsis:
-		get_document_position(n.expr, position_context);
-	case Proc_Lit:
-		get_document_position(n.type, position_context);
+	#partial switch n in node.derived {
+	case ^Bad_Expr:
+	case ^Ident:
+		position_context.identifier = node
+	case ^Implicit:
+	case ^Undef:
+	case ^Basic_Lit:
+	case ^Ellipsis:
+		get_document_position(n.expr, position_context)
+	case ^Proc_Lit:
+		get_document_position(n.type, position_context)
 
 		if position_in_node(n.body, position_context.position) {
-			position_context.function = cast(^Proc_Lit)node;
-			get_document_position(n.body, position_context);
+			position_context.function = cast(^Proc_Lit)node
+			get_document_position(n.body, position_context)
 		}  
-	case Comp_Lit:
+	case ^Comp_Lit:
 		//only set this for the parent comp literal, since we will need to walk through it to infer types.
 		if position_context.parent_comp_lit == nil {
-			position_context.parent_comp_lit = cast(^Comp_Lit)node;
+			position_context.parent_comp_lit = cast(^Comp_Lit)node
 		}
 
-		position_context.comp_lit = cast(^Comp_Lit)node;
+		position_context.comp_lit = cast(^Comp_Lit)node
 
-		get_document_position(n.type, position_context);
-		get_document_position(n.elems, position_context);
-	case Tag_Expr:
-		get_document_position(n.expr, position_context);
-	case Unary_Expr:
-		get_document_position(n.expr, position_context);
-	case Binary_Expr:
+		get_document_position(n.type, position_context)
+		get_document_position(n.elems, position_context)
+	case ^Tag_Expr:
+		get_document_position(n.expr, position_context)
+	case ^Unary_Expr:
+		get_document_position(n.expr, position_context)
+	case ^Binary_Expr:
 		if position_context.parent_binary == nil {
-			position_context.parent_binary = cast(^Binary_Expr)node;
-		}
-		position_context.binary = cast(^Binary_Expr)node;
-		get_document_position(n.left, position_context);
-		get_document_position(n.right, position_context);
-	case Paren_Expr:
-		get_document_position(n.expr, position_context);
-	case Call_Expr:
+			position_context.parent_binary = cast(^Binary_Expr)node
+		}
+		position_context.binary = cast(^Binary_Expr)node
+		get_document_position(n.left, position_context)
+		get_document_position(n.right, position_context)
+	case ^Paren_Expr:
+		get_document_position(n.expr, position_context)
+	case ^Call_Expr:
 		if position_context.hint == .SignatureHelp || position_context.hint == .Completion {
-			position_context.call = cast(^Expr)node;
+			position_context.call = cast(^Expr)node
 		}
-		get_document_position(n.expr, position_context);
-		get_document_position(n.args, position_context);
-	case Selector_Expr:
+		get_document_position(n.expr, position_context)
+		get_document_position(n.args, position_context)
+	case ^Selector_Expr:
 		if position_context.hint == .Completion {
 			if n.field != nil && n.field.pos.line - 1 == position_context.line {
 				//The parser is not fault tolerant enough, relying on the fallback as the main completion parsing for now
@@ -3200,182 +3195,181 @@ get_document_position_node :: proc(node: ^ast.Node, position_context: ^DocumentP
 				//position_context.field = n.field;
 			}
 		} else if (position_context.hint == .Definition || position_context.hint == .Hover) && n.field != nil {
-			position_context.selector = n.expr;
-			position_context.field = n.field;
-			get_document_position(n.expr, position_context);
-			get_document_position(n.field, position_context);
+			position_context.selector = n.expr
+			position_context.field = n.field
+			get_document_position(n.expr, position_context)
+			get_document_position(n.field, position_context)
 		} else {
-			get_document_position(n.expr, position_context);
-			get_document_position(n.field, position_context);
-		}
-	case Index_Expr:
-		get_document_position(n.expr, position_context);
-		get_document_position(n.index, position_context);
-	case Deref_Expr:
-		get_document_position(n.expr, position_context);
-	case Slice_Expr:
-		get_document_position(n.expr, position_context);
-		get_document_position(n.low, position_context);
-		get_document_position(n.high, position_context);
-	case Field_Value:
-		position_context.field_value = cast(^Field_Value)node;
-		get_document_position(n.field, position_context);
-		get_document_position(n.value, position_context);
-	case Ternary_If_Expr:
-		get_document_position(n.x, position_context);
-		get_document_position(n.cond, position_context);
-		get_document_position(n.y, position_context);
-	case Ternary_When_Expr:
-		get_document_position(n.x, position_context);
-		get_document_position(n.cond, position_context);
-		get_document_position(n.y, position_context);
-	case Type_Assertion:
-		get_document_position(n.expr, position_context);
-		get_document_position(n.type, position_context);
-	case Type_Cast:
-		get_document_position(n.type, position_context);
-		get_document_position(n.expr, position_context);
-	case Auto_Cast:
-		get_document_position(n.expr, position_context);
-	case Bad_Stmt:
-	case Empty_Stmt:
-	case Expr_Stmt:
-		get_document_position(n.expr, position_context);
-	case Tag_Stmt:
-		r := cast(^Tag_Stmt)node;
-		get_document_position(r.stmt, position_context);
-	case Assign_Stmt:
-		position_context.assign = cast(^Assign_Stmt)node;
-		get_document_position(n.lhs, position_context);
-		get_document_position(n.rhs, position_context);
-	case Block_Stmt:
-		get_document_position(n.label, position_context);
-		get_document_position(n.stmts, position_context);
-	case If_Stmt:
-		get_document_position(n.label, position_context);
-		get_document_position(n.init, position_context);
-		get_document_position(n.cond, position_context);
-		get_document_position(n.body, position_context);
-		get_document_position(n.else_stmt, position_context);
-	case When_Stmt:
-		get_document_position(n.cond, position_context);
-		get_document_position(n.body, position_context);
-		get_document_position(n.else_stmt, position_context);
-	case Return_Stmt:
-		position_context.returns = cast(^Return_Stmt)node;
-		get_document_position(n.results, position_context);
-	case Defer_Stmt:
-		get_document_position(n.stmt, position_context);
-	case For_Stmt:
-		get_document_position(n.label, position_context);
-		get_document_position(n.init, position_context);
-		get_document_position(n.cond, position_context);
-		get_document_position(n.post, position_context);
-		get_document_position(n.body, position_context);
-	case Range_Stmt:
-		get_document_position(n.label, position_context);
-		get_document_position(n.vals, position_context);
-		get_document_position(n.expr, position_context);
-		get_document_position(n.body, position_context);
-	case Case_Clause:
-
+			get_document_position(n.expr, position_context)
+			get_document_position(n.field, position_context)
+		}
+	case ^Index_Expr:
+		get_document_position(n.expr, position_context)
+		get_document_position(n.index, position_context)
+	case ^Deref_Expr:
+		get_document_position(n.expr, position_context)
+	case ^Slice_Expr:
+		get_document_position(n.expr, position_context)
+		get_document_position(n.low, position_context)
+		get_document_position(n.high, position_context)
+	case ^Field_Value:
+		position_context.field_value = cast(^Field_Value)node
+		get_document_position(n.field, position_context)
+		get_document_position(n.value, position_context)
+	case ^Ternary_If_Expr:
+		get_document_position(n.x, position_context)
+		get_document_position(n.cond, position_context)
+		get_document_position(n.y, position_context)
+	case ^Ternary_When_Expr:
+		get_document_position(n.x, position_context)
+		get_document_position(n.cond, position_context)
+		get_document_position(n.y, position_context)
+	case ^Type_Assertion:
+		get_document_position(n.expr, position_context)
+		get_document_position(n.type, position_context)
+	case ^Type_Cast:
+		get_document_position(n.type, position_context)
+		get_document_position(n.expr, position_context)
+	case ^Auto_Cast:
+		get_document_position(n.expr, position_context)
+	case ^Bad_Stmt:
+	case ^Empty_Stmt:
+	case ^Expr_Stmt:
+		get_document_position(n.expr, position_context)
+	case ^Tag_Stmt:
+		r := cast(^Tag_Stmt)node
+		get_document_position(r.stmt, position_context)
+	case ^Assign_Stmt:
+		position_context.assign = cast(^Assign_Stmt)node
+		get_document_position(n.lhs, position_context)
+		get_document_position(n.rhs, position_context)
+	case ^Block_Stmt:
+		get_document_position(n.label, position_context)
+		get_document_position(n.stmts, position_context)
+	case ^If_Stmt:
+		get_document_position(n.label, position_context)
+		get_document_position(n.init, position_context)
+		get_document_position(n.cond, position_context)
+		get_document_position(n.body, position_context)
+		get_document_position(n.else_stmt, position_context)
+	case ^When_Stmt:
+		get_document_position(n.cond, position_context)
+		get_document_position(n.body, position_context)
+		get_document_position(n.else_stmt, position_context)
+	case ^Return_Stmt:
+		position_context.returns = cast(^Return_Stmt)node
+		get_document_position(n.results, position_context)
+	case ^Defer_Stmt:
+		get_document_position(n.stmt, position_context)
+	case ^For_Stmt:
+		get_document_position(n.label, position_context)
+		get_document_position(n.init, position_context)
+		get_document_position(n.cond, position_context)
+		get_document_position(n.post, position_context)
+		get_document_position(n.body, position_context)
+	case ^Range_Stmt:
+		get_document_position(n.label, position_context)
+		get_document_position(n.vals, position_context)
+		get_document_position(n.expr, position_context)
+		get_document_position(n.body, position_context)
+	case ^Case_Clause:
 		for elem in n.list {
 			if position_in_node(elem, position_context.position) {
-				position_context.case_clause = cast(^Case_Clause)node;
-				break;
-			}
-		}
-
-		get_document_position(n.list, position_context);
-		get_document_position(n.body, position_context);
-	case Switch_Stmt:
-		position_context.switch_stmt = cast(^Switch_Stmt)node;
-		get_document_position(n.label, position_context);
-		get_document_position(n.init, position_context);
-		get_document_position(n.cond, position_context);
-		get_document_position(n.body, position_context);
-	case Type_Switch_Stmt:
-		position_context.switch_type_stmt = cast(^Type_Switch_Stmt)node;
-		get_document_position(n.label, position_context);
-		get_document_position(n.tag, position_context);
-		get_document_position(n.expr, position_context);
-		get_document_position(n.body, position_context);
-	case Branch_Stmt:
-		get_document_position(n.label, position_context);
-	case Using_Stmt:
-		get_document_position(n.list, position_context);
-	case Bad_Decl:
-	case Value_Decl:
-		position_context.value_decl = cast(^Value_Decl)node;
-		get_document_position(n.attributes, position_context);
+				position_context.case_clause = cast(^Case_Clause)node
+				break
+			}
+		}
+
+		get_document_position(n.list, position_context)
+		get_document_position(n.body, position_context)
+	case ^Switch_Stmt:
+		position_context.switch_stmt = cast(^Switch_Stmt)node
+		get_document_position(n.label, position_context)
+		get_document_position(n.init, position_context)
+		get_document_position(n.cond, position_context)
+		get_document_position(n.body, position_context)
+	case ^Type_Switch_Stmt:
+		position_context.switch_type_stmt = cast(^Type_Switch_Stmt)node
+		get_document_position(n.label, position_context)
+		get_document_position(n.tag, position_context)
+		get_document_position(n.expr, position_context)
+		get_document_position(n.body, position_context)
+	case ^Branch_Stmt:
+		get_document_position(n.label, position_context)
+	case ^Using_Stmt:
+		get_document_position(n.list, position_context)
+	case ^Bad_Decl:
+	case ^Value_Decl:
+		position_context.value_decl = cast(^Value_Decl)node
+		get_document_position(n.attributes, position_context)
 
 		for name in n.names {
 			if position_in_node(name, position_context.position) && n.end.line - 1 == position_context.line {
-				position_context.abort_completion = true;
-				break;
-			}
-		}
-		get_document_position(n.names, position_context);
-		get_document_position(n.type, position_context);
-		get_document_position(n.values, position_context);
-	case Package_Decl:
-	case Import_Decl:
-	case Foreign_Block_Decl:
-		get_document_position(n.attributes, position_context);
-		get_document_position(n.foreign_library, position_context);
-		get_document_position(n.body, position_context);
-	case Foreign_Import_Decl:
-		get_document_position(n.name, position_context);
-	case Proc_Group:
-		get_document_position(n.args, position_context);
-	case Attribute:
-		get_document_position(n.elems, position_context);
-	case Field:
-		get_document_position(n.names, position_context);
-		get_document_position(n.type, position_context);
-		get_document_position(n.default_value, position_context);
-	case Field_List:
-		get_document_position(n.list, position_context);
-	case Typeid_Type:
-		get_document_position(n.specialization, position_context);
-	case Helper_Type:
-		get_document_position(n.type, position_context);
-	case Distinct_Type:
-		get_document_position(n.type, position_context);
-	case Poly_Type:
-		get_document_position(n.type, position_context);
-		get_document_position(n.specialization, position_context);
-	case Proc_Type:
-		get_document_position(n.params, position_context);
-		get_document_position(n.results, position_context);
-	case Pointer_Type:
-		get_document_position(n.elem, position_context);
-	case Array_Type:
-		get_document_position(n.len, position_context);
-		get_document_position(n.elem, position_context);
-	case Dynamic_Array_Type:
-		get_document_position(n.elem, position_context);
-	case Struct_Type:
-		get_document_position(n.poly_params, position_context);
-		get_document_position(n.align, position_context);
-		get_document_position(n.fields, position_context);
-	case Union_Type:
-		get_document_position(n.poly_params, position_context);
-		get_document_position(n.align, position_context);
-		get_document_position(n.variants, position_context);
-	case Enum_Type:
-		get_document_position(n.base_type, position_context);
-		get_document_position(n.fields, position_context);
-	case Bit_Set_Type:
-		get_document_position(n.elem, position_context);
-		get_document_position(n.underlying, position_context);
-	case Map_Type:
-		get_document_position(n.key, position_context);
-		get_document_position(n.value, position_context);
-	case Implicit_Selector_Expr:
-		position_context.implicit = true;
-		get_document_position(n.field, position_context);
+				position_context.abort_completion = true
+				break
+			}
+		}
+		get_document_position(n.names, position_context)
+		get_document_position(n.type, position_context)
+		get_document_position(n.values, position_context)
+	case ^Package_Decl:
+	case ^Import_Decl:
+	case ^Foreign_Block_Decl:
+		get_document_position(n.attributes, position_context)
+		get_document_position(n.foreign_library, position_context)
+		get_document_position(n.body, position_context)
+	case ^Foreign_Import_Decl:
+		get_document_position(n.name, position_context)
+	case ^Proc_Group:
+		get_document_position(n.args, position_context)
+	case ^Attribute:
+		get_document_position(n.elems, position_context)
+	case ^Field:
+		get_document_position(n.names, position_context)
+		get_document_position(n.type, position_context)
+		get_document_position(n.default_value, position_context)
+	case ^Field_List:
+		get_document_position(n.list, position_context)
+	case ^Typeid_Type:
+		get_document_position(n.specialization, position_context)
+	case ^Helper_Type:
+		get_document_position(n.type, position_context)
+	case ^Distinct_Type:
+		get_document_position(n.type, position_context)
+	case ^Poly_Type:
+		get_document_position(n.type, position_context)
+		get_document_position(n.specialization, position_context)
+	case ^Proc_Type:
+		get_document_position(n.params, position_context)
+		get_document_position(n.results, position_context)
+	case ^Pointer_Type:
+		get_document_position(n.elem, position_context)
+	case ^Array_Type:
+		get_document_position(n.len, position_context)
+		get_document_position(n.elem, position_context)
+	case ^Dynamic_Array_Type:
+		get_document_position(n.elem, position_context)
+	case ^Struct_Type:
+		get_document_position(n.poly_params, position_context)
+		get_document_position(n.align, position_context)
+		get_document_position(n.fields, position_context)
+	case ^Union_Type:
+		get_document_position(n.poly_params, position_context)
+		get_document_position(n.align, position_context)
+		get_document_position(n.variants, position_context)
+	case ^Enum_Type:
+		get_document_position(n.base_type, position_context)
+		get_document_position(n.fields, position_context)
+	case ^Bit_Set_Type:
+		get_document_position(n.elem, position_context)
+		get_document_position(n.underlying, position_context)
+	case ^Map_Type:
+		get_document_position(n.key, position_context)
+		get_document_position(n.value, position_context)
+	case ^Implicit_Selector_Expr:
+		position_context.implicit = true
+		get_document_position(n.field, position_context)
 	case:
-		log.errorf("Unhandled node kind: %T", n);
+		log.errorf("Unhandled node kind: %T", n)
 	}
 }