From d85f388792b14c4a29d228852cd5eaac748bf714 Mon Sep 17 00:00:00 2001 From: Nathan Braswell Date: Tue, 22 May 2018 20:14:15 -0400 Subject: [PATCH] Shorter AST names --- kraken.krak | 2 +- stdlib/address_of_ensure_variable_lower.krak | 4 +- stdlib/adt_lower.krak | 68 ++++++------ stdlib/ast_nodes.krak | 70 ++++++------ stdlib/ast_transformation.krak | 110 +++++++++---------- stdlib/bytecode_generator.krak | 6 +- stdlib/c_line_control.krak | 2 +- stdlib/defer_lower.krak | 2 +- stdlib/function_value_lower.krak | 66 +++++------ stdlib/interpreter.krak | 10 +- stdlib/obj_lower.krak | 70 ++++++------ stdlib/pass_common.krak | 24 ++-- 12 files changed, 217 insertions(+), 217 deletions(-) diff --git a/kraken.krak b/kraken.krak index fbc486f..7c8c14d 100644 --- a/kraken.krak +++ b/kraken.krak @@ -124,7 +124,7 @@ fun main(argc: int, argv: **char):int { /*var parsers = vec(parse1,parse2,parse3,parse4,parse5,parse6,parse7,parse8)*/ // This is our REPL loop - var scope = ast_translation_unit_ptr(str("stdin")) + var scope = _translation_unit(str("stdin")) if (doing_repl) { /*var globals = setup_globals(importer.name_ast_map)*/ while (doing_repl) { diff --git a/stdlib/address_of_ensure_variable_lower.krak b/stdlib/address_of_ensure_variable_lower.krak index 63e514c..014ffa5 100644 --- a/stdlib/address_of_ensure_variable_lower.krak +++ b/stdlib/address_of_ensure_variable_lower.krak @@ -34,10 +34,10 @@ fun address_of_ensure_variable_lower(name_ast_map: *map, var enclosing_block_idx = parent_chain->index_from_top_satisfying(is_code_block) var enclosing_block = parent_chain->from_top(enclosing_block_idx) var before_block_parent = parent_chain->from_top(enclosing_block_idx-1) - var ident = ast_identifier_ptr("for_address_of_temp", + var ident = _ident("for_address_of_temp", backing.func->function.type->parameter_types[0], enclosing_block) - var decl = ast_declaration_statement_ptr(ident, addresse) + var decl = _declaration(ident, addresse) add_before_in(decl, before_block_parent, enclosing_block) replace_with_in(addresse, ident, node) } diff --git a/stdlib/adt_lower.krak b/stdlib/adt_lower.krak index a8a5dfc..b7de80c 100644 --- a/stdlib/adt_lower.krak +++ b/stdlib/adt_lower.krak @@ -23,85 +23,85 @@ fun adt_lower(name_ast_map: *map,*ast_node>>, ast_to_syn ast_node::adt_def(backing) { /*println(backing.name + ": transforming!")*/ type_def_option_map[node] = vec<*ast_node>() - var replacement = ast_type_def_ptr(backing.name, false); + var replacement = _type_def(backing.name, false); // we're going to be replacing adt_def in the same ptr, so this works replacement->type_def.self_type = node->adt_def.self_type - var option_union = ast_type_def_ptr(backing.name + "_union", true); + var option_union = _type_def(backing.name + "_union", true); node->adt_def.options.for_each(fun(opt: *ast_node) { if (!opt->identifier.type->is_empty_adt_option()) - option_union->type_def.variables.add(ast_declaration_statement_ptr(opt, null())) + option_union->type_def.variables.add(_declaration(opt, null())) type_def_option_map[node].add(opt) }) var option_union_type = type_ptr(option_union) option_union->type_def.self_type = option_union_type - var option_union_ident = ast_identifier_ptr(str("data"), option_union_type, replacement) - replacement->type_def.variables.add(ast_declaration_statement_ptr(option_union_ident, null())) + var option_union_ident = _ident(str("data"), option_union_type, replacement) + replacement->type_def.variables.add(_declaration(option_union_ident, null())) add_to_scope("data", option_union_ident, replacement) - var flag = ast_identifier_ptr(str("flag"), type_ptr(base_type::integer()), replacement) - replacement->type_def.variables.add(ast_declaration_statement_ptr(flag, null())) + var flag = _ident(str("flag"), type_ptr(base_type::integer()), replacement) + replacement->type_def.variables.add(_declaration(flag, null())) add_to_scope("flag", flag, replacement) add_before_in(option_union, node, parent_chain) var enclosing_scope = node->adt_def.scope[str("~enclosing_scope")][0] var idx = 0 node->adt_def.option_funcs.for_each(fun(func: *ast_node) { var adt_type = replacement->type_def.self_type - var block = ast_code_block_ptr() + var block = _code_block() add_to_scope("~enclosing_scope", func, block) func->function.body_statement = block - var to_ret = ast_identifier_ptr(str("to_ret"), adt_type, block) - block->code_block.children.add(ast_declaration_statement_ptr(to_ret, null())) + var to_ret = _ident(str("to_ret"), adt_type, block) + block->code_block.children.add(_declaration(to_ret, null())) - var value = ast_value_ptr(to_string(idx), type_ptr(base_type::integer())) - block->code_block.children.add(ast_assignment_statement_ptr(make_operator_call(".", vec(to_ret, flag)), value)) + var value = _value(to_string(idx), type_ptr(base_type::integer())) + block->code_block.children.add(_assign(make_operator_call(".", vec(to_ret, flag)), value)) var opt = type_def_option_map[node][idx] var lvalue = make_operator_call(".", vec(make_operator_call(".", vec(to_ret, option_union_ident)), opt)) if (func->function.parameters.size) { // do copy_construct if it should block->code_block.children.add(assign_or_copy_construct_statement(lvalue, func->function.parameters[0])) } - block->code_block.children.add(ast_return_statement_ptr(to_ret)) + block->code_block.children.add(_return(to_ret)) add_before_in(func, node, parent_chain) add_to_scope(func->function.name, func, enclosing_scope) add_to_scope("~enclosing_scope", enclosing_scope, func) idx++ }) node->adt_def.regular_funcs.for_each(fun(func: *ast_node) { - var block = ast_code_block_ptr() + var block = _code_block() add_to_scope("~enclosing_scope", func, block) func->function.body_statement = block var func_this = func->function.this_param if (func->function.name == "operator==") { var other = func->function.parameters[0] - var if_stmt = ast_if_statement_ptr(make_operator_call("!=", vec(make_operator_call("->", vec(func_this, flag)), make_operator_call(".", vec(other, flag))))) - if_stmt->if_statement.then_part = ast_return_statement_ptr(ast_value_ptr(str("false"), type_ptr(base_type::boolean()))) + var if_stmt = _if(make_operator_call("!=", vec(make_operator_call("->", vec(func_this, flag)), make_operator_call(".", vec(other, flag))))) + if_stmt->if_statement.then_part = _return(_value(str("false"), type_ptr(base_type::boolean()))) block->code_block.children.add(if_stmt) for (var i = 0; i < type_def_option_map[node].size; i++;) { if (get_ast_type(type_def_option_map[node][i])->is_empty_adt_option()) continue - var if_stmt_inner = ast_if_statement_ptr(make_operator_call("==", vec(make_operator_call("->", vec(func_this, flag)), ast_value_ptr(to_string(i), type_ptr(base_type::integer()))))) + var if_stmt_inner = _if(make_operator_call("==", vec(make_operator_call("->", vec(func_this, flag)), _value(to_string(i), type_ptr(base_type::integer()))))) var option = type_def_option_map[node][i] var our_option = make_operator_call(".", vec(make_operator_call("->", vec(func_this, option_union_ident)), option)) var their_option = make_operator_call(".", vec(make_operator_call(".", vec(other, option_union_ident)), option)) - if_stmt_inner->if_statement.then_part = ast_return_statement_ptr(possible_object_equality(our_option, their_option)) + if_stmt_inner->if_statement.then_part = _return(possible_object_equality(our_option, their_option)) block->code_block.children.add(if_stmt_inner) } - block->code_block.children.add(ast_return_statement_ptr(ast_value_ptr(str("true"), type_ptr(base_type::boolean())))) + block->code_block.children.add(_return(_value(str("true"), type_ptr(base_type::boolean())))) } else if (func->function.name == "operator!=") { var other = func->function.parameters[0] - block->code_block.children.add(ast_return_statement_ptr(make_operator_call("!", vec(make_method_call(func_this, "operator==", vec(other)))))) + block->code_block.children.add(_return(make_operator_call("!", vec(make_method_call(func_this, "operator==", vec(other)))))) } else if (func->function.name == "construct") { - var value = ast_value_ptr(str("-1"), type_ptr(base_type::integer())) - block->code_block.children.add(ast_assignment_statement_ptr(make_operator_call("->", vec(func_this, flag)), value)) - block->code_block.children.add(ast_return_statement_ptr(func_this)) + var value = _value(str("-1"), type_ptr(base_type::integer())) + block->code_block.children.add(_assign(make_operator_call("->", vec(func_this, flag)), value)) + block->code_block.children.add(_return(func_this)) } else if (func->function.name == "copy_construct") { var other = func->function.parameters[0] - block->code_block.children.add(ast_assignment_statement_ptr(make_operator_call("->", vec(func_this, flag)), make_operator_call("->", vec(other, flag)))) + block->code_block.children.add(_assign(make_operator_call("->", vec(func_this, flag)), make_operator_call("->", vec(other, flag)))) for (var i = 0; i < type_def_option_map[node].size; i++;) { if (get_ast_type(type_def_option_map[node][i])->is_empty_adt_option()) continue - var if_stmt_inner = ast_if_statement_ptr(make_operator_call("==", vec(make_operator_call("->", vec(func_this, flag)), ast_value_ptr(to_string(i), type_ptr(base_type::integer()))))) + var if_stmt_inner = _if(make_operator_call("==", vec(make_operator_call("->", vec(func_this, flag)), _value(to_string(i), type_ptr(base_type::integer()))))) var option = type_def_option_map[node][i] var our_option = make_operator_call(".", vec(make_operator_call("->", vec(func_this, option_union_ident)), option)) var their_option = make_operator_call(".", vec(make_operator_call("->", vec(other, option_union_ident)), option)) @@ -119,7 +119,7 @@ fun adt_lower(name_ast_map: *map,*ast_node>>, ast_to_syn if (option_type->is_empty_adt_option()) continue if (option_type->indirection == 0 && option_type->is_object() && has_method(option_type->type_def, "destruct", vec<*type>())) { - var if_stmt_inner = ast_if_statement_ptr(make_operator_call("==", vec(make_operator_call("->", vec(func_this, flag)), ast_value_ptr(to_string(i), type_ptr(base_type::integer()))))) + var if_stmt_inner = _if(make_operator_call("==", vec(make_operator_call("->", vec(func_this, flag)), _value(to_string(i), type_ptr(base_type::integer()))))) var our_option = make_operator_call(".", vec(make_operator_call("->", vec(func_this, option_union_ident)), option)) if_stmt_inner->if_statement.then_part = make_method_call(our_option, "destruct", vec<*ast_node>()) block->code_block.children.add(if_stmt_inner) @@ -142,12 +142,12 @@ fun adt_lower(name_ast_map: *map,*ast_node>>, ast_to_syn var second_helper = fun(node: *ast_node, parent_chain: *stack<*ast_node>) { match(*node) { ast_node::match_statement(backing) { - var block = ast_code_block_ptr() + var block = _code_block() add_to_scope("~enclosing_scope", parent_chain->item_from_top_satisfying(fun(i: *ast_node): bool return is_code_block(i) || is_function(i);), block) var value = backing.value - var holder = ast_identifier_ptr(str("holder"), get_ast_type(value)->clone_with_increased_indirection(), block) - block->code_block.children.add(ast_declaration_statement_ptr(holder, null())) - block->code_block.children.add(ast_assignment_statement_ptr(holder, make_operator_call("&", vec(value)))) + var holder = _ident(str("holder"), get_ast_type(value)->clone_with_increased_indirection(), block) + block->code_block.children.add(_declaration(holder, null())) + block->code_block.children.add(_assign(holder, make_operator_call("&", vec(value)))) backing.cases.for_each(fun(case_stmt: *ast_node) { var option = case_stmt->case_statement.option var flag = get_from_scope(get_ast_type(value)->type_def, "flag") @@ -158,16 +158,16 @@ fun adt_lower(name_ast_map: *map,*ast_node>>, ast_to_syn for (var i = 0; i < type_def_option_map[get_ast_type(value)->type_def].size; i++;) if (type_def_option_map[get_ast_type(value)->type_def][i] == option) option_num = i; - var condition = make_operator_call("==", vec(make_operator_call("->", vec(holder, flag)), ast_value_ptr(to_string(option_num), type_ptr(base_type::integer())))) - var if_stmt = ast_if_statement_ptr(condition) - var inner_block = ast_code_block_ptr() + var condition = make_operator_call("==", vec(make_operator_call("->", vec(holder, flag)), _value(to_string(option_num), type_ptr(base_type::integer())))) + var if_stmt = _if(condition) + var inner_block = _code_block() add_to_scope("~enclosing_scope", block, inner_block) var unpack_ident = case_stmt->case_statement.unpack_ident if (unpack_ident) { var get_option = make_operator_call(".", vec(make_operator_call("->", vec(holder, data)), option)) get_option = make_operator_call("&", vec(get_option)) unpack_ident->identifier.type = unpack_ident->identifier.type->clone_with_ref() - inner_block->code_block.children.add(ast_declaration_statement_ptr(unpack_ident, get_option)) + inner_block->code_block.children.add(_declaration(unpack_ident, get_option)) } inner_block->code_block.children.add(case_stmt->case_statement.statement) if_stmt->if_statement.then_part = inner_block diff --git a/stdlib/ast_nodes.krak b/stdlib/ast_nodes.krak index c29a669..af40333 100644 --- a/stdlib/ast_nodes.krak +++ b/stdlib/ast_nodes.krak @@ -42,7 +42,7 @@ fun ast_node_ptr(node: ast_node): *ast_node { to_ret->copy_construct(&node) return to_ret } -fun ast_translation_unit_ptr(name: str): *ast_node { +fun _translation_unit(name: str): *ast_node { var obj_var.construct(name): translation_unit var ptr = new() ptr->copy_construct(&ast_node::translation_unit(obj_var)) @@ -86,7 +86,7 @@ obj translation_unit (Object) { return children == other.children && name == other.name && lambdas == other.lambdas } } -fun ast_import_ptr(name: str, containing_tu: *ast_node): *ast_node { +fun _import(name: str, containing_tu: *ast_node): *ast_node { var to_ret.construct(name, containing_tu): import var ptr = new() ptr->copy_construct(&ast_node::import(to_ret)) @@ -135,13 +135,13 @@ obj import (Object) { return imported == other.imported && name == other.name && containing_translation_unit == other.containing_translation_unit && translation_unit == other.translation_unit && starred == other.starred } } -fun ast_identifier_ptr(name: *char, type: *type, enclosing_scope: *ast_node): *ast_node { - return ast_identifier_ptr(str(name), type, enclosing_scope) +fun _ident(name: *char, type: *type, enclosing_scope: *ast_node): *ast_node { + return _ident(str(name), type, enclosing_scope) } -fun ast_identifier_ptr(name: str, type: *type, enclosing_scope: *ast_node): *ast_node { - return ast_identifier_ptr(name, type, enclosing_scope, false) +fun _ident(name: str, type: *type, enclosing_scope: *ast_node): *ast_node { + return _ident(name, type, enclosing_scope, false) } -fun ast_identifier_ptr(name: str, type: *type, enclosing_scope: *ast_node, is_extern: bool): *ast_node { +fun _ident(name: str, type: *type, enclosing_scope: *ast_node, is_extern: bool): *ast_node { var to_ret.construct(name, type, enclosing_scope, is_extern): identifier var ptr = new() ptr->copy_construct(&ast_node::identifier(to_ret)) @@ -186,11 +186,11 @@ obj identifier (Object) { return name == other.name && type == other.type && enclosing_scope == other.enclosing_scope && is_extern == other.is_extern } } -/*fun ast_type_def_ptr(name: str): *ast_node {*/ -fun ast_type_def_ptr(name: ref str): *ast_node { - return ast_type_def_ptr(name, false) +/*fun _type_def(name: str): *ast_node {*/ +fun _type_def(name: ref str): *ast_node { + return _type_def(name, false) } -fun ast_type_def_ptr(name: ref str, is_union: bool): *ast_node { +fun _type_def(name: ref str, is_union: bool): *ast_node { var to_ret.construct(name, is_union): type_def /*var to_ret.construct(name): type_def*/ var ptr = new() @@ -244,7 +244,7 @@ obj type_def (Object) { /*return name == other.name && self_type == other.self_type && variables == other.variables && methods == other.methods*/ } } -fun ast_adt_def_ptr(name: str): *ast_node { +fun _adt_def(name: str): *ast_node { var to_ret.construct(name): adt_def var ptr = new() ptr->copy_construct(&ast_node::adt_def(to_ret)) @@ -295,9 +295,9 @@ obj adt_def (Object) { return name == other.name && self_type == other.self_type && options == other.options && option_funcs == other.option_funcs && regular_funcs == other.regular_funcs } } -fun ast_function_ptr(name: str, type: *type, parameters: vec<*ast_node>, is_extern: bool): *ast_node - return ast_function_ptr(name, type, parameters, null(), is_extern, false) -fun ast_function_ptr(name: str, type: *type, parameters: vec<*ast_node>, this_param: *ast_node, is_extern: bool, is_variadic: bool): *ast_node { +fun _function(name: str, type: *type, parameters: vec<*ast_node>, is_extern: bool): *ast_node + return _function(name, type, parameters, null(), is_extern, false) +fun _function(name: str, type: *type, parameters: vec<*ast_node>, this_param: *ast_node, is_extern: bool, is_variadic: bool): *ast_node { var to_ret.construct(name, type, parameters, this_param, is_extern, is_variadic): function var ptr = new() ptr->copy_construct(&ast_node::function(to_ret)) @@ -356,7 +356,7 @@ obj function (Object) { return name == name && type == other.type && parameters == other.parameters && this_param == other.this_param && body_statement == other.body_statement && closed_variables == other.closed_variables && is_extern == other.is_extern && is_variadic == other.is_variadic } } -fun ast_template_ptr(name: str, syntax_node: *tree, template_types: vec, template_type_replacements: map, is_function: bool): *ast_node { +fun _template(name: str, syntax_node: *tree, template_types: vec, template_type_replacements: map, is_function: bool): *ast_node { var to_ret.construct(name, syntax_node, template_types, template_type_replacements, is_function): template var ptr = new() ptr->copy_construct(&ast_node::template(to_ret)) @@ -416,12 +416,12 @@ obj template (Object) { instantiated_map == other.instantiated_map && is_function == other.is_function } } -fun ast_code_block_ptr(stmt: *ast_node): *ast_node { - var to_ret = ast_code_block_ptr() +fun _code_block(stmt: *ast_node): *ast_node { + var to_ret = _code_block() to_ret->code_block.children.add(stmt) return to_ret } -fun ast_code_block_ptr(): *ast_node { +fun _code_block(): *ast_node { var to_ret.construct(): code_block var ptr = new() ptr->copy_construct(&ast_node::code_block(to_ret)) @@ -457,7 +457,7 @@ obj code_block (Object) { return children == other.children && scope == other.scope } } -fun ast_if_statement_ptr(condition: *ast_node): *ast_node { +fun _if(condition: *ast_node): *ast_node { var to_ret.construct(condition): if_statement var ptr = new() ptr->copy_construct(&ast_node::if_statement(to_ret)) @@ -499,7 +499,7 @@ obj if_statement (Object) { return condition == other.condition && then_part == other.then_part && else_part == other.else_part } } -fun ast_match_statement_ptr(value: *ast_node): *ast_node { +fun _match(value: *ast_node): *ast_node { var to_ret.construct(value): match_statement var ptr = new() ptr->copy_construct(&ast_node::match_statement(to_ret)) @@ -538,7 +538,7 @@ obj match_statement (Object) { return value == other.value && cases == other.cases && scope == other.scope } } -fun ast_case_statement_ptr(): *ast_node { +fun _case(): *ast_node { var to_ret.construct(): case_statement var ptr = new() ptr->copy_construct(&ast_node::case_statement(to_ret)) @@ -579,7 +579,7 @@ obj case_statement (Object) { return option == other.option && unpack_ident == other.unpack_ident && statement == other.statement } } -fun ast_while_loop_ptr(condition: *ast_node): *ast_node { +fun _while(condition: *ast_node): *ast_node { var to_ret.construct(condition): while_loop var ptr = new() ptr->copy_construct(&ast_node::while_loop(to_ret)) @@ -617,7 +617,7 @@ obj while_loop (Object) { return condition == other.condition && statement == other.statement } } -fun ast_for_loop_ptr(): *ast_node { +fun _for(): *ast_node { var to_ret.construct(): for_loop var ptr = new() ptr->copy_construct(&ast_node::for_loop(to_ret)) @@ -661,7 +661,7 @@ obj for_loop (Object) { return init == other.init && condition == other.condition && update == other.update && body == other.body } } -fun ast_return_statement_ptr(return_value: *ast_node): *ast_node { +fun _return(return_value: *ast_node): *ast_node { var to_ret.construct(return_value): return_statement var ptr = new() ptr->copy_construct(&ast_node::return_statement(to_ret)) @@ -700,7 +700,7 @@ adt branching_type { break_stmt, continue_stmt } -fun ast_branching_statement_ptr(b_type: branching_type): *ast_node { +fun _branch(b_type: branching_type): *ast_node { var to_ret.construct(b_type): branching_statement var ptr = new() ptr->copy_construct(&ast_node::branching_statement(to_ret)) @@ -732,7 +732,7 @@ obj branching_statement (Object) { return true } } -fun ast_defer_statement_ptr(statement_in: *ast_node): *ast_node { +fun _defer(statement_in: *ast_node): *ast_node { var to_ret.construct(statement_in): defer_statement var ptr = new() ptr->copy_construct(&ast_node::defer_statement(to_ret)) @@ -763,7 +763,7 @@ obj defer_statement (Object) { return true } } -fun ast_assignment_statement_ptr(to: *ast_node, from: *ast_node): *ast_node { +fun _assign(to: *ast_node, from: *ast_node): *ast_node { var to_ret.construct(to, from): assignment_statement var ptr = new() ptr->copy_construct(&ast_node::assignment_statement(to_ret)) @@ -797,7 +797,7 @@ obj assignment_statement (Object) { return to == other.to && from == other.from } } -fun ast_declaration_statement_ptr(ident: *ast_node, expression: *ast_node): *ast_node { +fun _declaration(ident: *ast_node, expression: *ast_node): *ast_node { var to_ret.construct(ident, expression): declaration_statement var ptr = new() ptr->copy_construct(&ast_node::declaration_statement(to_ret)) @@ -834,7 +834,7 @@ obj declaration_statement (Object) { return identifier == other.identifier && expression == other.expression && init_method_call == other.init_method_call } } -fun ast_if_comp_ptr(): *ast_node { +fun _if_comp(): *ast_node { var to_ret.construct(): if_comp var ptr = new() ptr->copy_construct(&ast_node::if_comp(to_ret)) @@ -868,7 +868,7 @@ obj if_comp (Object) { return wanted_generator == other.wanted_generator && statement == other.statement } } -fun ast_simple_passthrough_ptr(): *ast_node { +fun _passthrough(): *ast_node { var to_ret.construct(): simple_passthrough var ptr = new() ptr->copy_construct(&ast_node::simple_passthrough(to_ret)) @@ -917,7 +917,7 @@ obj simple_passthrough (Object) { out_params == other.out_params && linker_str == other.linker_str } } -fun ast_function_call_ptr(func: *ast_node, parameters: vec<*ast_node>): *ast_node { +fun _func_call(func: *ast_node, parameters: vec<*ast_node>): *ast_node { var to_ret.construct(func, parameters): function_call var ptr = new() ptr->copy_construct(&ast_node::function_call(to_ret)) @@ -952,7 +952,7 @@ obj function_call (Object) { return func == func && parameters == other.parameters } } -fun ast_compiler_intrinsic_ptr(intrinsic: str, parameters: vec<*ast_node>, type_parameters: vec<*type>, return_type: *type): *ast_node { +fun _compiler_intrinsic(intrinsic: str, parameters: vec<*ast_node>, type_parameters: vec<*type>, return_type: *type): *ast_node { var to_ret.construct(intrinsic, parameters, type_parameters, return_type): compiler_intrinsic var ptr = new() ptr->copy_construct(&ast_node::compiler_intrinsic(to_ret)) @@ -996,7 +996,7 @@ obj compiler_intrinsic (Object) { return intrinsic == intrinsic && parameters == other.parameters && type_parameters == other.type_parameters && return_type == other.return_type } } -fun ast_cast_ptr(value: *ast_node, to_type: *type): *ast_node { +fun _cast(value: *ast_node, to_type: *type): *ast_node { var to_ret.construct(value, to_type): cast var ptr = new() ptr->copy_construct(&ast_node::cast(to_ret)) @@ -1030,7 +1030,7 @@ obj cast (Object) { return value == other.value && to_type == other.to_type } } -fun ast_value_ptr(string_value: str, value_type: *type): *ast_node { +fun _value(string_value: str, value_type: *type): *ast_node { var to_ret.construct(string_value, value_type): value var ptr = new() ptr->copy_construct(&ast_node::value(to_ret)) diff --git a/stdlib/ast_transformation.krak b/stdlib/ast_transformation.krak index c859de5..ab9bd32 100644 --- a/stdlib/ast_transformation.krak +++ b/stdlib/ast_transformation.krak @@ -45,13 +45,13 @@ obj ast_transformation (Object) { } // first pass defines all type_defs (objects and aliases), ADTs, and top-level if-comps/passthroughs fun first_pass(file_name: str, parse_tree: *tree): pair<*ast_node, vec<*ast_node>> { - var translation_unit = ast_translation_unit_ptr(file_name) + var translation_unit = _translation_unit(file_name) parse_tree->children.for_each(fun(child: *tree) { if (child->data.name == "type_def") { translation_unit->translation_unit.children.add(first_pass_type_def(child, translation_unit, false)) } else if (child->data.name == "adt_def") { var name = concat_symbol_tree(get_node("identifier", child)) - var adt_def_node = ast_adt_def_ptr(name) + var adt_def_node = _adt_def(name) adt_def_node->adt_def.self_type = type_ptr(adt_def_node, set(str("Object"))) translation_unit->translation_unit.children.add(adt_def_node) ast_to_syntax.set(adt_def_node, child) @@ -72,7 +72,7 @@ obj ast_transformation (Object) { if (child->data.name == "import") { var import_identifier_children = get_nodes("identifier", child) var name = concat_symbol_tree(import_identifier_children[0]) - var import_node = ast_import_ptr(name, translation_unit) + var import_node = _import(name, translation_unit) imports.add(import_node) translation_unit->translation_unit.children.add(import_node) ast_to_syntax.set(import_node, child) @@ -100,15 +100,15 @@ obj ast_transformation (Object) { template_types.add(concat_symbol_tree(get_node("identifier", template_param))) template_type_replacements.set(template_types.last(), type_ptr(transform_traits(get_node("traits", template_param)))) }) - var template = ast_template_ptr(name, child, template_types, template_type_replacements, false) + var template = _template(name, child, template_types, template_type_replacements, false) add_to_scope("~enclosing_scope", scope, template) add_to_scope(name, template, scope) return template } else { // pass in whether or not this is a union - var type_def_node = ast_type_def_ptr(name, concat_symbol_tree(get_node("obj_nonterm", child)) == "uni") - /*var type_def_node = ast_type_def_ptr(name, false)*/ - /*var type_def_node = ast_type_def_ptr(name)*/ + var type_def_node = _type_def(name, concat_symbol_tree(get_node("obj_nonterm", child)) == "uni") + /*var type_def_node = _type_def(name, false)*/ + /*var type_def_node = _type_def(name)*/ type_def_node->type_def.self_type = type_ptr(type_def_node, transform_traits(get_node("traits", child))) ast_to_syntax.set(type_def_node, child) add_to_scope("~enclosing_scope", scope, type_def_node) @@ -161,7 +161,7 @@ obj ast_transformation (Object) { else ident_type = type_ptr(base_type::no_type_adt_option()) var option_name = concat_symbol_tree(get_node("identifier", adt_option)) - var identifier = ast_identifier_ptr(option_name, ident_type, node) + var identifier = _ident(option_name, ident_type, node) node->adt_def.options.add(identifier) // we add the identifier first so that it's found before the function when doing option.thingy add_to_scope(option_name, identifier, node) @@ -170,10 +170,10 @@ obj ast_transformation (Object) { var function_node = null() if (type_syntax) { - var identifier_param = ast_identifier_ptr(option_name, ident_type, node) - function_node = ast_function_ptr(option_name, type_ptr(vec(get_ast_type(identifier_param)), node->adt_def.self_type, 0, false, false, true), vec(identifier_param), false) + var identifier_param = _ident(option_name, ident_type, node) + function_node = _function(option_name, type_ptr(vec(get_ast_type(identifier_param)), node->adt_def.self_type, 0, false, false, true), vec(identifier_param), false) } else { - function_node = ast_function_ptr(option_name, type_ptr(vec<*type>(), node->adt_def.self_type, 0, false, false, true), vec<*ast_node>(), false) + function_node = _function(option_name, type_ptr(vec<*type>(), node->adt_def.self_type, 0, false, false, true), vec<*ast_node>(), false) } add_to_scope(option_name, function_node, node) add_to_scope("~enclosing_scope", node, function_node) @@ -183,29 +183,29 @@ obj ast_transformation (Object) { // note they don't even have real parameters (but the type has them correctly) or bodies // I'm not sure this is the correct enclosing scope, but I'm not sure how to do it with the function either - var equals_param = ast_identifier_ptr(str("in"), node->adt_def.self_type->clone_with_indirection(0,true), node) - var nequals_param = ast_identifier_ptr(str("in"), node->adt_def.self_type->clone_with_indirection(0,true), node) - var copy_construct_param = ast_identifier_ptr(str("in"), node->adt_def.self_type->clone_with_indirection(1,false), node) - var assign_param = ast_identifier_ptr(str("in"), node->adt_def.self_type->clone_with_indirection(0,true), node) + var equals_param = _ident(str("in"), node->adt_def.self_type->clone_with_indirection(0,true), node) + var nequals_param = _ident(str("in"), node->adt_def.self_type->clone_with_indirection(0,true), node) + var copy_construct_param = _ident(str("in"), node->adt_def.self_type->clone_with_indirection(1,false), node) + var assign_param = _ident(str("in"), node->adt_def.self_type->clone_with_indirection(0,true), node) vec( - make_pair("operator==", ast_function_ptr(str("operator=="), + make_pair("operator==", _function(str("operator=="), type_ptr(vec(equals_param->identifier.type), type_ptr(base_type::boolean()), 0, false, false, true), - vec(equals_param), ast_identifier_ptr("this", node->adt_def.self_type->clone_with_indirection(1), node), false, false)), - make_pair("operator!=", ast_function_ptr(str("operator!="), + vec(equals_param), _ident("this", node->adt_def.self_type->clone_with_indirection(1), node), false, false)), + make_pair("operator!=", _function(str("operator!="), type_ptr(vec(nequals_param->identifier.type), type_ptr(base_type::boolean()), 0, false, false, true), - vec(nequals_param), ast_identifier_ptr("this", node->adt_def.self_type->clone_with_indirection(1), node), false, false)), - make_pair("construct", ast_function_ptr(str("construct"), + vec(nequals_param), _ident("this", node->adt_def.self_type->clone_with_indirection(1), node), false, false)), + make_pair("construct", _function(str("construct"), type_ptr(vec<*type>(), node->adt_def.self_type->clone_with_increased_indirection(), 0, false, false, true), - vec<*ast_node>(), ast_identifier_ptr("this", node->adt_def.self_type->clone_with_indirection(1), node), false, false)), - make_pair("copy_construct", ast_function_ptr(str("copy_construct"), + vec<*ast_node>(), _ident("this", node->adt_def.self_type->clone_with_indirection(1), node), false, false)), + make_pair("copy_construct", _function(str("copy_construct"), type_ptr(vec(copy_construct_param->identifier.type), type_ptr(base_type::void_return()), 0, false, false, true), - vec(copy_construct_param), ast_identifier_ptr("this", node->adt_def.self_type->clone_with_indirection(1), node), false, false)), - make_pair("operator=", ast_function_ptr(str("operator="), + vec(copy_construct_param), _ident("this", node->adt_def.self_type->clone_with_indirection(1), node), false, false)), + make_pair("operator=", _function(str("operator="), type_ptr(vec(assign_param->identifier.type), type_ptr(base_type::void_return()), 0, false, false, true), - vec(assign_param), ast_identifier_ptr("this", node->adt_def.self_type->clone_with_indirection(1), node), false, false)), - make_pair("destruct", ast_function_ptr(str("destruct"), + vec(assign_param), _ident("this", node->adt_def.self_type->clone_with_indirection(1), node), false, false)), + make_pair("destruct", _function(str("destruct"), type_ptr(vec<*type>(), type_ptr(base_type::void_return()), 0, false, false, true), - vec<*ast_node>(), ast_identifier_ptr("this", node->adt_def.self_type->clone_with_indirection(1), node), false, false)) + vec<*ast_node>(), _ident("this", node->adt_def.self_type->clone_with_indirection(1), node), false, false)) ).for_each(fun(func_pair: pair<*char, *ast_node>) { node->adt_def.regular_funcs.add(func_pair.second) add_to_scope(str(func_pair.first), func_pair.second, node) @@ -225,7 +225,7 @@ obj ast_transformation (Object) { template_types.add(concat_symbol_tree(get_node("identifier", template_param))) template_type_replacements.set(template_types.last(), type_ptr(transform_traits(get_node("traits", template_param)))) }) - var template = ast_template_ptr(function_name, node, template_types, template_type_replacements, true) + var template = _template(function_name, node, template_types, template_type_replacements, true) add_to_scope(function_name, template, scope) add_to_scope("~enclosing_scope", scope, template) return template @@ -246,21 +246,21 @@ obj ast_transformation (Object) { var param_type = transform_type(get_node("type", child), scope, template_replacements) if (param_type->is_none()) error(child, "parameter type none") - parameters.add(ast_identifier_ptr(concat_symbol_tree(get_node("identifier", child)), param_type, null())) + parameters.add(_ident(concat_symbol_tree(get_node("identifier", child)), param_type, null())) }) var is_variadic = get_node("\"...\"", node) != null>() var is_raw = function_name != "__compiler_lambda__" var this_param = null() if (is_type_def(scope)) { - this_param = ast_identifier_ptr("this", scope->type_def.self_type->clone_with_indirection(1), scope) + this_param = _ident("this", scope->type_def.self_type->clone_with_indirection(1), scope) } else if (is_template(scope)) { var parent_scope = get_ast_scope(scope)->get(str("~enclosing_scope"))[0] if (is_type_def(parent_scope)) { - this_param = ast_identifier_ptr("this", parent_scope->type_def.self_type->clone_with_indirection(1), parent_scope) + this_param = _ident("this", parent_scope->type_def.self_type->clone_with_indirection(1), parent_scope) } } // figure out function type and make function_node - var function_node = ast_function_ptr(function_name, + var function_node = _function(function_name, type_ptr(parameters.map(fun(parameter: *ast_node): *type return parameter->identifier.type;), return_type, 0, false, is_variadic, is_raw), parameters, this_param, get_node("\"ext\"", node) != null>(), is_variadic) // fix up the enclosing_scope's @@ -586,22 +586,22 @@ obj ast_transformation (Object) { value_str = value_str.slice(0, -1-chop) } } - return ast_value_ptr(value_str, value_type) + return _value(value_str, value_type) } fun transform_code_block(node: *tree, scope: *ast_node, template_replacements: map): *ast_node { - var new_block = ast_code_block_ptr() + var new_block = _code_block() add_to_scope("~enclosing_scope", scope, new_block) new_block->code_block.children = transform_all(node->children, new_block, template_replacements) return new_block } fun transform_if_comp(node: *tree, scope: *ast_node): *ast_node { - var new_if_comp = ast_if_comp_ptr() + var new_if_comp = _if_comp() new_if_comp->if_comp.wanted_generator = concat_symbol_tree(get_node("identifier", node)) new_if_comp->if_comp.statement = transform_statement(get_node("statement", node), scope, map()) return new_if_comp } fun transform_simple_passthrough(node: *tree, scope: *ast_node): *ast_node { - var new_passthrough = ast_simple_passthrough_ptr() + var new_passthrough = _passthrough() new_passthrough->simple_passthrough.passthrough_str = concat_symbol_tree(get_node("triple_quoted_string", node)).slice(3,-4) // setup passthrough params and str var passthrough_params = get_node("passthrough_params", node) @@ -642,7 +642,7 @@ obj ast_transformation (Object) { var expression_syntax_node = get_node("boolean_expression", node) var expression = null() // we do it early so that if there is a type_syntax_node we can add to scope so that the expression can find this for things like rec closures - var identifier = ast_identifier_ptr(name, null(), scope, get_node("\"ext\"", node) != null>()) + var identifier = _ident(name, null(), scope, get_node("\"ext\"", node) != null>()) add_to_scope(name, identifier, scope) if (type_syntax_node) identifier->identifier.type = transform_type(type_syntax_node, scope, template_replacements) if (expression_syntax_node) { @@ -652,7 +652,7 @@ obj ast_transformation (Object) { } if (!identifier->identifier.type) error(node, "declaration statement with no type or expression from which to inference type") if (identifier->identifier.type->is_none() || (identifier->identifier.type->indirection == 0 && identifier->identifier.type->is_void())) error(node, "declaration statement with bad type") - var declaration = ast_declaration_statement_ptr(identifier, expression) + var declaration = _declaration(identifier, expression) // ok, deal with the possible init position method call if (identifiers.size == 2) { var parameters = get_nodes("parameter", node).map(fun(child: *tree): *ast_node return transform(get_node("boolean_expression", child), scope, template_replacements);) @@ -717,13 +717,13 @@ obj ast_transformation (Object) { } to_assign = make_operator_call("^", vec(assign_to, to_assign)) } - var assignment = ast_assignment_statement_ptr(assign_to, to_assign) + var assignment = _assign(assign_to, to_assign) return assignment } fun transform_if_statement(node: *tree, scope: *ast_node, template_replacements: map): *ast_node { if (get_node("AmbiguityInner", node)) error(node, "Ambigious two ifs with one else!") - var if_statement = ast_if_statement_ptr(transform_expression(get_node("boolean_expression", node), scope, template_replacements)) + var if_statement = _if(transform_expression(get_node("boolean_expression", node), scope, template_replacements)) // one variable declarations might be in a code_block-less if statement add_to_scope("~enclosing_scope", scope, if_statement) var statements = transform_all(get_nodes("statement", node), if_statement, template_replacements) @@ -734,13 +734,13 @@ obj ast_transformation (Object) { return if_statement } fun transform_while_loop(node: *tree, scope: *ast_node, template_replacements: map): *ast_node { - var while_loop = ast_while_loop_ptr(transform_expression(get_node("boolean_expression", node), scope, template_replacements)) + var while_loop = _while(transform_expression(get_node("boolean_expression", node), scope, template_replacements)) add_to_scope("~enclosing_scope", scope, while_loop) while_loop->while_loop.statement = transform(get_node("statement", node), while_loop, template_replacements) return while_loop } fun transform_for_loop(node: *tree, scope: *ast_node, template_replacements: map): *ast_node { - var for_loop = ast_for_loop_ptr() + var for_loop = _for() add_to_scope("~enclosing_scope", scope, for_loop) var statements = get_nodes("statement", node) for_loop->for_loop.init = transform(statements[0], for_loop, template_replacements) @@ -753,27 +753,27 @@ obj ast_transformation (Object) { var return_value = get_node("boolean_expression", node) var to_ret: *ast_node if (return_value) - to_ret = ast_return_statement_ptr(transform(return_value, scope, template_replacements)) + to_ret = _return(transform(return_value, scope, template_replacements)) else - to_ret = ast_return_statement_ptr(null()) + to_ret = _return(null()) ast_to_syntax.set(to_ret, node) return to_ret } fun transform_branching_statement(node: *tree, scope: *ast_node): *ast_node { if (node->data.name == "break_statement") - return ast_branching_statement_ptr(branching_type::break_stmt()) - return ast_branching_statement_ptr(branching_type::continue_stmt()) + return _branch(branching_type::break_stmt()) + return _branch(branching_type::continue_stmt()) } fun transform_defer_statement(node: *tree, scope: *ast_node, template_replacements: map): *ast_node { - return ast_defer_statement_ptr(transform(node->children[0], scope, template_replacements)) + return _defer(transform(node->children[0], scope, template_replacements)) } fun transform_match_statement(node: *tree, scope: *ast_node, template_replacements: map): *ast_node { - var to_ret = ast_match_statement_ptr(transform(get_node("boolean_expression", node), scope, template_replacements)) + var to_ret = _match(transform(get_node("boolean_expression", node), scope, template_replacements)) get_nodes("case_statement", node).for_each(fun(syntax: *tree) to_ret->match_statement.cases.add(transform_case_statement(syntax, scope, template_replacements));) return to_ret } fun transform_case_statement(node: *tree, scope: *ast_node, template_replacements: map): *ast_node { - var to_ret = ast_case_statement_ptr() + var to_ret = _case() var the_adts = scope_lookup(concat_symbol_tree(get_node("scoped_identifier", get_node("scoped_identifier", node))), scope).filter(fun(i: *ast_node): bool return is_adt_def(i);) if (the_adts.size != 1) error(node, str("the number of adts found was not 1, it was ") + the_adts.size + " for " + concat_symbol_tree(get_node("scoped_identifier", node))) @@ -784,7 +784,7 @@ obj ast_transformation (Object) { to_ret->case_statement.option = the_option var possible_ident = get_node("identifier", node) if (possible_ident) { - var ident = ast_identifier_ptr(concat_symbol_tree(possible_ident), the_option->identifier.type, scope) + var ident = _ident(concat_symbol_tree(possible_ident), the_option->identifier.type, scope) to_ret->case_statement.unpack_ident = ident add_to_scope(ident->identifier.name, ident, to_ret) } @@ -807,7 +807,7 @@ obj ast_transformation (Object) { } if (!(func_type->is_function() && func_type->indirection == 0)) error(node, "trying to call not a function") - var f = ast_function_call_ptr(func, parameters) + var f = _func_call(func, parameters) return f } fun transform_compiler_intrinsic(node: *tree, scope: *ast_node, template_replacements: map): *ast_node { @@ -819,7 +819,7 @@ obj ast_transformation (Object) { intrinsic_return_type = get_ast_type(parameters[0]) else intrinsic_return_type = type_ptr(base_type::ulong_int()) - return ast_compiler_intrinsic_ptr(intrinsic_name, parameters, type_parameters, intrinsic_return_type) + return _compiler_intrinsic(intrinsic_name, parameters, type_parameters, intrinsic_return_type) } fun transform_lambda(node: *tree, scope: *ast_node, template_replacements: map): *ast_node { var function_node = second_pass_function(node, scope, template_replacements, false) @@ -875,7 +875,7 @@ obj ast_transformation (Object) { if (func_name == "[") func_name += "]" if (func_name == "cast") - return ast_cast_ptr(transform(get_node("boolean_expression", node), scope, template_replacements), transform_type(get_node("type", node), scope, template_replacements)) + return _cast(transform(get_node("boolean_expression", node), scope, template_replacements), transform_type(get_node("type", node), scope, template_replacements)) var first_param = transform(node->children[0], scope, template_replacements) var second_param = null() if (func_name == "." || func_name == "->") { @@ -920,7 +920,7 @@ obj ast_transformation (Object) { var possible_overload_call = find_and_make_any_operator_overload_call(func_name, parameters, scope, template_replacements) if (possible_overload_call) return possible_overload_call - return ast_function_call_ptr(get_builtin_function(func_name, parameter_types, node), parameters) + return _func_call(get_builtin_function(func_name, parameter_types, node), parameters) } fun find_and_make_any_operator_overload_call(func_name: str, parameters: vec<*ast_node>, scope: *ast_node, template_replacements: map): *ast_node { var parameter_types = parameters.map(fun(param: *ast_node): *type return get_ast_type(param);) @@ -943,7 +943,7 @@ obj ast_transformation (Object) { if (!possible_overload) possible_overload = find_or_instantiate_template_function(str("operator")+func_name, null>(), scope, parameter_types, template_replacements, map()) if (possible_overload) - return ast_function_call_ptr(possible_overload, parameters) + return _func_call(possible_overload, parameters) return null() } fun find_or_instantiate_template_function(name: str, template_inst: *tree, scope: *ast_node, param_types: vec<*type>, template_replacements: map, replacements_base: map): *ast_node { diff --git a/stdlib/bytecode_generator.krak b/stdlib/bytecode_generator.krak index 69d0f26..c470bef 100644 --- a/stdlib/bytecode_generator.krak +++ b/stdlib/bytecode_generator.krak @@ -428,7 +428,7 @@ obj bytecode_generator (Object) { // we should save our return value as as the first parameter if (return_type->is_object() && return_type->indirection == 0) { var ptr_type = return_type->clone_with_increased_indirection() - functions.last().var_to_frame_offset[ast_identifier_ptr("bytecode_struct_return_temp_address", ptr_type, null())] = parameter_offset + functions.last().var_to_frame_offset[_ident("bytecode_struct_return_temp_address", ptr_type, null())] = parameter_offset parameter_offset += type_size(ptr_type) } node->function.parameters.for_each(fun(p: *ast_node) { @@ -445,7 +445,7 @@ obj bytecode_generator (Object) { generate(node->function.body_statement) // generate a return just in case the function itself doesn't have one - generate_return_statement(ast_return_statement_ptr(null())) + generate_return_statement(_return(null())) instructions[push_frame_idx].addi.bi = -functions.last().frame_size @@ -763,7 +763,7 @@ obj bytecode_generator (Object) { var return_type = get_ast_type(func)->return_type var struct_return_temp_ident = null() if (return_type->is_object() && return_type->indirection == 0) { - struct_return_temp_ident = ast_identifier_ptr("bytecode_struct_return_temp", return_type, null()) + struct_return_temp_ident = _ident("bytecode_struct_return_temp", return_type, null()) functions.last().frame_size += type_size(return_type) functions.last().var_to_frame_offset[struct_return_temp_ident] = -functions.last().frame_size } diff --git a/stdlib/c_line_control.krak b/stdlib/c_line_control.krak index 847a63a..bbccdde 100644 --- a/stdlib/c_line_control.krak +++ b/stdlib/c_line_control.krak @@ -12,7 +12,7 @@ import ast_transformation:* import pass_common:* fun get_line(node: *tree, name: str): *ast_node { - var to_ret = ast_simple_passthrough_ptr() + var to_ret = _passthrough() to_ret->simple_passthrough.passthrough_str = str("\n#line ") + get_first_terminal(node)->data.position + " \"" + name + "\"\n" return to_ret } diff --git a/stdlib/defer_lower.krak b/stdlib/defer_lower.krak index 095fd99..382772e 100644 --- a/stdlib/defer_lower.krak +++ b/stdlib/defer_lower.krak @@ -44,7 +44,7 @@ fun defer_lower(name_ast_map: *map,*ast_node>>, ast_to_s var helper_after = fun(node: *ast_node, parent_chain: *stack<*ast_node>) { match(*node) { ast_node::branching_statement(backing) { - var block = ast_code_block_ptr() + var block = _code_block() add_to_scope("~enclosing_scope", parent_chain->item_from_top_satisfying(fun(i: *ast_node): bool return is_code_block(i) || is_function(i);), block) replace_with_in(node, block, parent_chain) for (var i = 0; i < defer_triple_stack.top().size() - loop_stack.top(); i++;) diff --git a/stdlib/function_value_lower.krak b/stdlib/function_value_lower.krak index 03d18eb..efe50c1 100644 --- a/stdlib/function_value_lower.krak +++ b/stdlib/function_value_lower.krak @@ -154,22 +154,22 @@ fun function_value_lower(name_ast_map: *map,*ast_node>>, cleaned->is_raw = true var new_type_def_name = t.to_string() + "_function_value_struct" - var new_type_def = ast_type_def_ptr(new_type_def_name) + var new_type_def = _type_def(new_type_def_name) - var func_ident = ast_identifier_ptr("func", cleaned, new_type_def) + var func_ident = _ident("func", cleaned, new_type_def) add_to_scope("func", func_ident, new_type_def) var func_closure_type = cleaned->clone() func_closure_type->parameter_types.add(0, type_ptr(base_type::void_return(), 1)) - var func_closure_ident = ast_identifier_ptr("func_closure", func_closure_type, new_type_def) + var func_closure_ident = _ident("func_closure", func_closure_type, new_type_def) add_to_scope("func_closure", func_closure_ident, new_type_def) - var data_ident = ast_identifier_ptr("data", void_ptr, new_type_def) + var data_ident = _ident("data", void_ptr, new_type_def) add_to_scope("data", data_ident, new_type_def) - new_type_def->type_def.variables.add(ast_declaration_statement_ptr(func_ident, null())) - new_type_def->type_def.variables.add(ast_declaration_statement_ptr(func_closure_ident, null())) - new_type_def->type_def.variables.add(ast_declaration_statement_ptr(data_ident, null())) + new_type_def->type_def.variables.add(_declaration(func_ident, null())) + new_type_def->type_def.variables.add(_declaration(func_closure_ident, null())) + new_type_def->type_def.variables.add(_declaration(data_ident, null())) add_to_scope("~enclosing_scope", name_ast_map->values.first().second, new_type_def) add_to_scope(new_type_def_name, new_type_def, name_ast_map->values.first().second) @@ -179,17 +179,17 @@ fun function_value_lower(name_ast_map: *map,*ast_node>>, var lambda_call_type = type_ptr(vec(lambda_struct_type) + t.parameter_types, t.return_type, 0, false, false, true) // create parameters - var lambda_call_func_param = ast_identifier_ptr("func_struct", lambda_struct_type, null()) + var lambda_call_func_param = _ident("func_struct", lambda_struct_type, null()) var lambda_call_parameters = vec(lambda_call_func_param) + cleaned->parameter_types.map(fun(t:*type): *ast_node { - return ast_identifier_ptr("pass_through_param", t, null()) + return _ident("pass_through_param", t, null()) }) - var lambda_call_function = ast_function_ptr(str("lambda_call"), lambda_call_type, lambda_call_parameters, false) + var lambda_call_function = _function(str("lambda_call"), lambda_call_type, lambda_call_parameters, false) // create call body with if, etc - var if_statement = ast_if_statement_ptr(access_expression(lambda_call_func_param, "data")) - lambda_call_function->function.body_statement = ast_code_block_ptr(if_statement) - if_statement->if_statement.then_part = ast_code_block_ptr(ast_return_statement_ptr(ast_function_call_ptr(access_expression(lambda_call_func_param, "func_closure"), + var if_statement = _if(access_expression(lambda_call_func_param, "data")) + lambda_call_function->function.body_statement = _code_block(if_statement) + if_statement->if_statement.then_part = _code_block(_return(_func_call(access_expression(lambda_call_func_param, "func_closure"), vec(access_expression(lambda_call_func_param, "data")) + lambda_call_parameters.slice(1,-1)))) - if_statement->if_statement.else_part = ast_code_block_ptr(ast_return_statement_ptr(ast_function_call_ptr(access_expression(lambda_call_func_param, "func"), + if_statement->if_statement.else_part = _code_block(_return(_func_call(access_expression(lambda_call_func_param, "func"), lambda_call_parameters.slice(1,-1)))) lambda_type_to_struct_type_and_call_func[t] = make_pair(lambda_struct_type, lambda_call_function) @@ -210,13 +210,13 @@ fun function_value_lower(name_ast_map: *map,*ast_node>>, var closure_struct_type: *type if (l->function.closed_variables.size()) { var new_type_def_name = str("closure_struct_") + closure_id++ - var new_type_def = ast_type_def_ptr(new_type_def_name) + var new_type_def = _type_def(new_type_def_name) l->function.closed_variables.for_each(fun(v: *ast_node) { var closed_var_type = v->identifier.type if (lambda_type_to_struct_type_and_call_func.contains_key(*closed_var_type)) closed_var_type = lambda_type_to_struct_type_and_call_func[*closed_var_type].first - var closed_ident = ast_identifier_ptr(v->identifier.name, closed_var_type->clone_with_increased_indirection(), new_type_def) - new_type_def->type_def.variables.add(ast_declaration_statement_ptr(closed_ident, null())) + var closed_ident = _ident(v->identifier.name, closed_var_type->clone_with_increased_indirection(), new_type_def) + new_type_def->type_def.variables.add(_declaration(closed_ident, null())) add_to_scope(v->identifier.name, closed_ident, new_type_def) }) add_to_scope("~enclosing_scope", name_ast_map->values.first().second, new_type_def) @@ -227,31 +227,31 @@ fun function_value_lower(name_ast_map: *map,*ast_node>>, var return_type = lambda_type_to_struct_type_and_call_func[*l->function.type].first var creation_type = type_ptr(vec<*type>(), return_type, 0, false, false, true) - lambda_creation_funcs[l] = ast_function_ptr(l->function.name + "_creation", creation_type, vec<*ast_node>(), false); - var body = ast_code_block_ptr() - var ident = ast_identifier_ptr("to_ret", return_type, body) - body->code_block.children.add(ast_declaration_statement_ptr(ident, null())) - body->code_block.children.add(ast_assignment_statement_ptr(access_expression(ident, "func"), l)) - body->code_block.children.add(ast_assignment_statement_ptr(access_expression(ident, "func_closure"), l)) + lambda_creation_funcs[l] = _function(l->function.name + "_creation", creation_type, vec<*ast_node>(), false); + var body = _code_block() + var ident = _ident("to_ret", return_type, body) + body->code_block.children.add(_declaration(ident, null())) + body->code_block.children.add(_assign(access_expression(ident, "func"), l)) + body->code_block.children.add(_assign(access_expression(ident, "func_closure"), l)) if (l->function.closed_variables.size()) { - var closure_lambda_param = ast_identifier_ptr("closure_data_pass", closure_struct_type, l) + var closure_lambda_param = _ident("closure_data_pass", closure_struct_type, l) l->function.parameters.add(0, closure_lambda_param) - var closure_param = ast_identifier_ptr("closure", closure_struct_type, body) + var closure_param = _ident("closure", closure_struct_type, body) lambda_creation_funcs[l]->function.parameters.add(closure_param) - body->code_block.children.add(ast_assignment_statement_ptr(access_expression(ident, "data"), closure_param)) + body->code_block.children.add(_assign(access_expression(ident, "data"), closure_param)) l->function.closed_variables.for_each(fun(v: *ast_node) { // have to make sure to clean here as well var closed_param_type = v->identifier.type if (lambda_type_to_struct_type_and_call_func.contains_key(*closed_param_type)) closed_param_type = lambda_type_to_struct_type_and_call_func[*closed_param_type].first - var closed_param = ast_identifier_ptr("closed_param", closed_param_type->clone_with_increased_indirection(), l) + var closed_param = _ident("closed_param", closed_param_type->clone_with_increased_indirection(), l) lambda_creation_funcs[l]->function.parameters.add(closed_param) - body->code_block.children.add(ast_assignment_statement_ptr(access_expression(closure_param, v->identifier.name), closed_param)) + body->code_block.children.add(_assign(access_expression(closure_param, v->identifier.name), closed_param)) }) } else { - body->code_block.children.add(ast_assignment_statement_ptr(access_expression(ident, "data"), ast_value_ptr(str("0"), type_ptr(base_type::void_return(), 1)))) + body->code_block.children.add(_assign(access_expression(ident, "data"), _value(str("0"), type_ptr(base_type::void_return(), 1)))) } - body->code_block.children.add(ast_return_statement_ptr(ident)) + body->code_block.children.add(_return(ident)) lambda_creation_funcs[l]->function.body_statement = body name_ast_map->values.first().second->translation_unit.children.add(lambda_creation_funcs[l]) }) @@ -269,8 +269,8 @@ fun function_value_lower(name_ast_map: *map,*ast_node>>, if (p.function->function.closed_variables.size()) { // pull closure type off lambda creation func parameter var closure_type = get_ast_type(lambda_creation_funcs[p.function]->function.parameters[0])->clone_with_decreased_indirection() - var closure_struct_ident = ast_identifier_ptr("closure_struct", closure_type, p.parent_block) - p.parent_block->code_block.children.add(0,ast_declaration_statement_ptr(closure_struct_ident, null())) + var closure_struct_ident = _ident("closure_struct", closure_type, p.parent_block) + p.parent_block->code_block.children.add(0,_declaration(closure_struct_ident, null())) lambda_creation_params.add(make_operator_call("&", vec(closure_struct_ident))) p.function->function.closed_variables.for_each(fun(v: *ast_node) { var addr_of = make_operator_call("&", vec(v)) @@ -280,7 +280,7 @@ fun function_value_lower(name_ast_map: *map,*ast_node>>, lambda_creation_params.add(addr_of) }) } - var func_call = ast_function_call_ptr(lambda_creation_funcs[p.function], lambda_creation_params) + var func_call = _func_call(lambda_creation_funcs[p.function], lambda_creation_params) replace_with_in(p.function, func_call, p.parent) }) curr_time = split(curr_time, "\tfunction_value_creation_points.forEach") diff --git a/stdlib/interpreter.krak b/stdlib/interpreter.krak index 70de6d7..d0772fe 100644 --- a/stdlib/interpreter.krak +++ b/stdlib/interpreter.krak @@ -145,17 +145,17 @@ fun unwrap_value(val: value): *ast_node { value::ulong_int(data) value_string = to_string(data) value::floating(data) value_string = to_string(data) value::double_precision(data) value_string = to_string(data) - value::void_nothing() error("trying to unwrap a void into an ast_value_ptr") + value::void_nothing() error("trying to unwrap a void into an _value") value::pointer(point) { if (point.second->base == base_type::character() && point.second->indirection == 1) value_string = str("\"") + str((point.first) cast *char) + "\"" else - error("trying to unwrap a pointer into an ast_value_ptr") + error("trying to unwrap a pointer into an _value") } - value::object_like(ob) error("trying to unwrap an object_like into an ast_value_ptr") - value::function(fn) error("trying to unwrap a function into an ast_value_ptr") + value::object_like(ob) error("trying to unwrap an object_like into an _value") + value::function(fn) error("trying to unwrap a function into an _value") } - return ast_value_ptr(value_string, get_type_from_primitive_value(get_real_value(val))) + return _value(value_string, get_type_from_primitive_value(get_real_value(val))) } fun is_boolean(it: value): bool { match(it) { value::boolean(var) return true; } return false; } diff --git a/stdlib/obj_lower.krak b/stdlib/obj_lower.krak index 7a34da3..e7be82d 100644 --- a/stdlib/obj_lower.krak +++ b/stdlib/obj_lower.krak @@ -42,7 +42,7 @@ fun obj_lower(name_ast_map: *map,*ast_node>>, ast_to_syn match(*node) { ast_node::type_def(backing) all_type_defs.add(node) ast_node::function(backing) if (backing.body_statement && !is_code_block(backing.body_statement)) { - backing.body_statement = ast_code_block_ptr(backing.body_statement) + backing.body_statement = _code_block(backing.body_statement) add_to_scope("~enclosing_scope", node, backing.body_statement) if (!is_code_block(backing.body_statement)) error("BUT EXTRA WHY") @@ -51,55 +51,55 @@ fun obj_lower(name_ast_map: *map,*ast_node>>, ast_to_syn } ast_node::if_statement(backing) { if (!is_code_block(backing.then_part)) { - backing.then_part = ast_code_block_ptr(backing.then_part) + backing.then_part = _code_block(backing.then_part) add_to_scope("~enclosing_scope", node, backing.then_part) } if (backing.else_part && !is_code_block(backing.else_part)) { - backing.else_part = ast_code_block_ptr(backing.else_part) + backing.else_part = _code_block(backing.else_part) add_to_scope("~enclosing_scope", node, backing.else_part) } } // no need for case because it's already been lowered ast_node::while_loop(backing) { if (!is_code_block(backing.statement)) { - backing.statement = ast_code_block_ptr(backing.statement) + backing.statement = _code_block(backing.statement) add_to_scope("~enclosing_scope", node, backing.statement) } var condition = backing.condition - backing.condition = ast_value_ptr(str("true"), type_ptr(base_type::boolean())) + backing.condition = _value(str("true"), type_ptr(base_type::boolean())) // objects do not coerce to booleans, so it should be ok for this not to be a ref - var condition_ident = ast_identifier_ptr("condition_temp", get_ast_type(condition), backing.statement) - backing.statement->code_block.children.add(0, ast_declaration_statement_ptr(condition_ident, condition)) - var condition_if = ast_if_statement_ptr(make_operator_call("!", vec(condition_ident))) - condition_if->if_statement.then_part = ast_branching_statement_ptr(branching_type::break_stmt()) + var condition_ident = _ident("condition_temp", get_ast_type(condition), backing.statement) + backing.statement->code_block.children.add(0, _declaration(condition_ident, condition)) + var condition_if = _if(make_operator_call("!", vec(condition_ident))) + condition_if->if_statement.then_part = _branch(branching_type::break_stmt()) backing.statement->code_block.children.add(1, condition_if) } ast_node::for_loop(backing) { if (!is_code_block(backing.body)) { - backing.body = ast_code_block_ptr(backing.body) + backing.body = _code_block(backing.body) add_to_scope("~enclosing_scope", node, backing.body) } add_before_in(backing.init, node, parent_chain->top()) backing.init = null() // the do_update goes in the block above the for - var update_ident = ast_identifier_ptr("do_update", type_ptr(base_type::boolean()), parent_chain->top()) - add_before_in(ast_declaration_statement_ptr(update_ident, ast_value_ptr(str("false"), type_ptr(base_type::boolean()))), + var update_ident = _ident("do_update", type_ptr(base_type::boolean()), parent_chain->top()) + add_before_in(_declaration(update_ident, _value(str("false"), type_ptr(base_type::boolean()))), node, parent_chain->top()) - var update_if = ast_if_statement_ptr(update_ident) + var update_if = _if(update_ident) add_to_scope("~enclosing_scope", backing.body, update_if) - update_if->if_statement.then_part = ast_code_block_ptr(backing.update) + update_if->if_statement.then_part = _code_block(backing.update) add_to_scope("~enclosing_scope", update_if, update_if->if_statement.then_part) backing.update = null() backing.body->code_block.children.add(0, update_if) - backing.body->code_block.children.add(1, ast_assignment_statement_ptr(update_ident, ast_value_ptr(str("true"), type_ptr(base_type::boolean())))) + backing.body->code_block.children.add(1, _assign(update_ident, _value(str("true"), type_ptr(base_type::boolean())))) var condition = backing.condition - backing.condition = ast_value_ptr(str("true"), type_ptr(base_type::boolean())) + backing.condition = _value(str("true"), type_ptr(base_type::boolean())) // objects do not coerce to booleans, so it should be ok for this not to be a ref - var condition_ident = ast_identifier_ptr("condition_temp", get_ast_type(condition), backing.body) - backing.body->code_block.children.add(2, ast_declaration_statement_ptr(condition_ident, condition)) - var condition_if = ast_if_statement_ptr(make_operator_call("!", vec(condition_ident))) - condition_if->if_statement.then_part = ast_branching_statement_ptr(branching_type::break_stmt()) + var condition_ident = _ident("condition_temp", get_ast_type(condition), backing.body) + backing.body->code_block.children.add(2, _declaration(condition_ident, condition)) + var condition_if = _if(make_operator_call("!", vec(condition_ident))) + condition_if->if_statement.then_part = _branch(branching_type::break_stmt()) backing.body->code_block.children.add(3, condition_if) } } @@ -144,15 +144,15 @@ fun obj_lower(name_ast_map: *map,*ast_node>>, ast_to_syn } if (func_name == "||" || func_name == "&&") { var enclosing_block_idx = parent_chain->index_from_top_satisfying(fun(i: *ast_node): bool return is_code_block(i);) - var short_circuit_result = ast_identifier_ptr("short_circut_result", type_ptr(base_type::boolean()), parent_chain->from_top(enclosing_block_idx)) - var short_circuit_declaration = ast_declaration_statement_ptr(short_circuit_result, backing.parameters[0]) + var short_circuit_result = _ident("short_circut_result", type_ptr(base_type::boolean()), parent_chain->from_top(enclosing_block_idx)) + var short_circuit_declaration = _declaration(short_circuit_result, backing.parameters[0]) var condition = short_circuit_result if (func_name == "||") condition = make_operator_call("!", vec(condition)) - var short_circuit_if = ast_if_statement_ptr(condition) + var short_circuit_if = _if(condition) add_to_scope("~enclosing_scope", parent_chain->from_top(enclosing_block_idx), short_circuit_if) // how to get proper parent scoping working for this part - short_circuit_if->if_statement.then_part = ast_code_block_ptr(ast_assignment_statement_ptr(short_circuit_result, backing.parameters[1])) + short_circuit_if->if_statement.then_part = _code_block(_assign(short_circuit_result, backing.parameters[1])) add_to_scope("~enclosing_scope", short_circuit_if, short_circuit_if->if_statement.then_part) add_before_in(short_circuit_declaration, parent_chain->from_top(enclosing_block_idx-1), parent_chain->from_top(enclosing_block_idx)) add_before_in(short_circuit_if, parent_chain->from_top(enclosing_block_idx-1), parent_chain->from_top(enclosing_block_idx)) @@ -203,10 +203,10 @@ fun obj_lower(name_ast_map: *map,*ast_node>>, ast_to_syn in_function_param_type = get_ast_type(param)->clone_without_ref() var param_type = get_ast_type(param) if (!in_function_param_type->is_ref && param_type->indirection == 0 && (param_type->is_object() && has_method(param_type->type_def, "copy_construct", vec(param_type->clone_with_indirection(1))))) { - var temp_ident = ast_identifier_ptr("temporary_param_boom", param_type->clone_without_ref(), replace_in) + var temp_ident = _ident("temporary_param_boom", param_type->clone_without_ref(), replace_in) add_to_scope("temporary_param_boom", temp_ident, replace_in) add_to_scope("~enclosing_scope", replace_in, temp_ident) - var declaration = ast_declaration_statement_ptr(temp_ident, null()) + var declaration = _declaration(temp_ident, null()) var copy_in = make_method_call(temp_ident, "copy_construct", vec(make_operator_call("&", vec(param)))) add_before_in(declaration, replace_before, replace_in) add_before_in(copy_in, replace_before, replace_in) @@ -215,13 +215,13 @@ fun obj_lower(name_ast_map: *map,*ast_node>>, ast_to_syn } var func_return_type = func_type->return_type if (!func_return_type->is_ref && func_return_type->indirection == 0 && func_return_type->is_object()) { - var temp_return = ast_identifier_ptr("temporary_return_boomchaka", func_return_type, replace_in) + var temp_return = _ident("temporary_return_boomchaka", func_return_type, replace_in) add_to_scope("temporary_return_boomchaka", temp_return, replace_in) add_to_scope("~enclosing_scope", replace_in, temp_return) - var declaration = ast_declaration_statement_ptr(temp_return, node) + var declaration = _declaration(temp_return, node) add_before_in(declaration, replace_before, replace_in) if (has_method(func_return_type->type_def, "destruct", vec<*type>())) { - add_before_in(ast_defer_statement_ptr(make_method_call(temp_return, "destruct", vec<*ast_node>())), + add_before_in(_defer(make_method_call(temp_return, "destruct", vec<*ast_node>())), replace_before, replace_in) } replace_with_in(node, temp_return, parent_chain) @@ -242,7 +242,7 @@ fun obj_lower(name_ast_map: *map,*ast_node>>, ast_to_syn if (!is_code_block(backing.body_statement)) error("BUT WHY") backing.body_statement->code_block.children.add(order++, - ast_defer_statement_ptr(make_method_call(param, "destruct", vec<*ast_node>()))) + _defer(make_method_call(param, "destruct", vec<*ast_node>()))) } }) } @@ -252,10 +252,10 @@ fun obj_lower(name_ast_map: *map,*ast_node>>, ast_to_syn return; if (!ident_type->is_ref && ident_type->indirection == 0 && ident_type->is_object()) { if (backing.expression && has_method(ident_type->type_def, "copy_construct", vec(get_ast_type(backing.expression)->clone_with_increased_indirection()))) { - var temp_cpy_ctst = ast_identifier_ptr("temp_declaration_copy_construct", get_ast_type(backing.expression)->clone_without_ref(), parent_chain->top()) + var temp_cpy_ctst = _ident("temp_declaration_copy_construct", get_ast_type(backing.expression)->clone_without_ref(), parent_chain->top()) add_to_scope("temp_declaration_copy_construct", temp_cpy_ctst, parent_chain->top()) add_to_scope("~enclosing_scope", parent_chain->top(), temp_cpy_ctst) - var declaration = ast_declaration_statement_ptr(temp_cpy_ctst, backing.expression) + var declaration = _declaration(temp_cpy_ctst, backing.expression) add_after_in(make_method_call(backing.identifier, "copy_construct", vec(make_operator_call("&", vec(temp_cpy_ctst)))), node, parent_chain->top()) // do second so the order's right @@ -264,7 +264,7 @@ fun obj_lower(name_ast_map: *map,*ast_node>>, ast_to_syn backing.expression = null() } if (has_method(ident_type->type_def, "destruct", vec<*type>())) { - add_after_in(ast_defer_statement_ptr(make_method_call(backing.identifier, "destruct", vec<*ast_node>())), + add_after_in(_defer(make_method_call(backing.identifier, "destruct", vec<*ast_node>())), node, parent_chain->top()) } } @@ -284,10 +284,10 @@ fun obj_lower(name_ast_map: *map,*ast_node>>, ast_to_syn if (return_value) { if (get_ast_type(enclosing_function)->return_type->is_ref) return_value = make_operator_call("&", vec(return_value)) - var temp_return = ast_identifier_ptr("temp_boom_return", get_ast_type(return_value)->clone_without_ref(), block) + var temp_return = _ident("temp_boom_return", get_ast_type(return_value)->clone_without_ref(), block) add_to_scope("temp_boom_return", temp_return, block) add_to_scope("~enclosing_scope", block, temp_return) - var declaration_statement = ast_declaration_statement_ptr(temp_return, null()) + var declaration_statement = _declaration(temp_return, null()) var assign_statement = assign_or_copy_construct_statement(temp_return, return_value) add_before_in(declaration_statement, node, block) add_before_in(assign_statement, node, block) diff --git a/stdlib/pass_common.krak b/stdlib/pass_common.krak index 98e4b4c..bcd6938 100644 --- a/stdlib/pass_common.krak +++ b/stdlib/pass_common.krak @@ -174,12 +174,12 @@ fun make_method_call(object_ident: *ast_node, method: *ast_node, parameters: vec var access_op = "." if (get_ast_type(object_ident)->indirection) access_op = "->" - var method_access = ast_function_call_ptr(get_builtin_function(str(access_op), vec(get_ast_type(object_ident), get_ast_type(method))), vec(object_ident, method)) - return ast_function_call_ptr(method_access, parameters) + var method_access = _func_call(get_builtin_function(str(access_op), vec(get_ast_type(object_ident), get_ast_type(method))), vec(object_ident, method)) + return _func_call(method_access, parameters) } fun make_operator_call(func: *char, params: vec<*ast_node>): *ast_node return make_operator_call(str(func), params); fun make_operator_call(func: str, params: vec<*ast_node>): *ast_node { - return ast_function_call_ptr(get_builtin_function(func, params.map(fun(p:*ast_node): *type return get_ast_type(p);)), params) + return _func_call(get_builtin_function(func, params.map(fun(p:*ast_node): *type return get_ast_type(p);)), params) } fun get_builtin_function(name: *char, param_types: vec<*type>): *ast_node return get_builtin_function(str(name), param_types, null>()) @@ -189,32 +189,32 @@ fun get_builtin_function(name: str, param_types: vec<*type>, syntax: *treeclone_without_ref();) if (name == "==" || name == "!=" || name == ">" || name == "<" || name == "<=" || name == ">" || name == ">=" || name == "&&" || name == "||" || name == "!") - return ast_function_ptr(name, type_ptr(param_types, type_ptr(base_type::boolean()), 0, false, false, true), vec<*ast_node>(), false) + return _function(name, type_ptr(param_types, type_ptr(base_type::boolean()), 0, false, false, true), vec<*ast_node>(), false) if (name == "." || name == "->") { if (name == "->" && param_types[0]->indirection == 0) error(syntax, str("drereferencing not a pointer: ") + name) else if (name == "." && param_types[0]->indirection != 0) error(syntax, str("dot operator on a pointer: ") + name) else - return ast_function_ptr(name, type_ptr(param_types, param_types[1], 0, false, false, true), vec<*ast_node>(), false) + return _function(name, type_ptr(param_types, param_types[1], 0, false, false, true), vec<*ast_node>(), false) } if (name == "[]") { if (param_types[0]->indirection == 0) error(syntax, str("drereferencing not a pointer: ") + name) else - return ast_function_ptr(name, type_ptr(param_types, param_types[0]->clone_with_decreased_indirection(), 0, false, false, true), vec<*ast_node>(), false) + return _function(name, type_ptr(param_types, param_types[0]->clone_with_decreased_indirection(), 0, false, false, true), vec<*ast_node>(), false) } if (name == "&" && param_types.size == 1) - return ast_function_ptr(name, type_ptr(param_types, param_types[0]->clone_with_increased_indirection(), 0, false, false, true), vec<*ast_node>(), false) + return _function(name, type_ptr(param_types, param_types[0]->clone_with_increased_indirection(), 0, false, false, true), vec<*ast_node>(), false) if (name == "*" && param_types.size == 1) { if (param_types[0]->indirection == 0) error(syntax, str("drereferencing not a pointer: ") + name) else - return ast_function_ptr(name, type_ptr(param_types, param_types[0]->clone_with_decreased_indirection(), 0, false, false, true), vec<*ast_node>(), false) + return _function(name, type_ptr(param_types, param_types[0]->clone_with_decreased_indirection(), 0, false, false, true), vec<*ast_node>(), false) } if (param_types.size > 1 && param_types[1]->rank() > param_types[0]->rank()) - return ast_function_ptr(name, type_ptr(param_types, param_types[1], 0, false, false, true), vec<*ast_node>(), false) - return ast_function_ptr(name, type_ptr(param_types, param_types[0], 0, false, false, true), vec<*ast_node>(), false) + return _function(name, type_ptr(param_types, param_types[1], 0, false, false, true), vec<*ast_node>(), false) + return _function(name, type_ptr(param_types, param_types[0], 0, false, false, true), vec<*ast_node>(), false) } fun possible_object_equality(lvalue: *ast_node, rvalue: *ast_node): *ast_node { var ltype = get_ast_type(lvalue) @@ -223,7 +223,7 @@ fun possible_object_equality(lvalue: *ast_node, rvalue: *ast_node): *ast_node { return make_method_call(lvalue, "operator==", vec(rvalue)) } else if (ltype->is_object()) // return false if object but no operator== (right now don't try for templated) - return ast_value_ptr(str("false"), type_ptr(base_type::boolean())) + return _value(str("false"), type_ptr(base_type::boolean())) return make_operator_call("==", vec(lvalue, rvalue)) } fun concat_symbol_tree(node: *tree): str { @@ -265,7 +265,7 @@ fun assign_or_copy_construct_statement(lvalue: *ast_node, rvalue: *ast_node): *a var ltype = get_ast_type(lvalue) if (ltype->indirection == 0 && (ltype->is_object() && has_method(ltype->type_def, "copy_construct", vec(ltype->clone_with_increased_indirection())))) return make_method_call(lvalue, "copy_construct", vec(make_operator_call("&", vec(rvalue)))) - return ast_assignment_statement_ptr(lvalue, rvalue) + return _assign(lvalue, rvalue) } fun get_children_pointer(node: *ast_node): *vec<*ast_node> {