IR if statements WIP

1 files changed, 2 insertions, 1305 deletions

diff --git a/src/analyze.cpp b/src/analyze.cpp
index 0bb212f8d1..451b259e24 100644
--- a/src/analyze.cpp
+++ b/src/analyze.cpp
@@ -1067,76 +1067,6 @@ static TypeTableEntry *analyze_fn_proto_type(CodeGen *g, ImportTableEntry *impor
     return get_fn_type(g, &fn_type_id, gen_debug_info);
 }
 
-static Buf *resolve_const_expr_str(CodeGen *g, ImportTableEntry *import, BlockContext *context, AstNode **node) {
-    TypeTableEntry *str_type = get_slice_type(g, g->builtin_types.entry_u8, true);
-    TypeTableEntry *resolved_type = analyze_expression(g, import, context, str_type, *node);
-
-    if (resolved_type->id == TypeTableEntryIdInvalid) {
-        return nullptr;
-    }
-
-    ConstExprValue *const_str_val = &get_resolved_expr(*node)->const_val;
-
-    if (!const_str_val->ok) {
-        add_node_error(g, *node, buf_sprintf("unable to evaluate constant expression"));
-        return nullptr;
-    }
-
-    ConstExprValue *ptr_field = const_str_val->data.x_struct.fields[0];
-    uint64_t len = ptr_field->data.x_ptr.len;
-    Buf *result = buf_alloc();
-    for (uint64_t i = 0; i < len; i += 1) {
-        ConstExprValue *char_val = ptr_field->data.x_ptr.ptr[i];
-        uint64_t big_c = char_val->data.x_bignum.data.x_uint;
-        assert(big_c <= UINT8_MAX);
-        uint8_t c = big_c;
-        buf_append_char(result, c);
-    }
-    return result;
-}
-
-static bool resolve_const_expr_bool(CodeGen *g, ImportTableEntry *import, BlockContext *context,
-        AstNode **node, bool *value)
-{
-    TypeTableEntry *resolved_type = analyze_expression(g, import, context, g->builtin_types.entry_bool, *node);
-
-    if (resolved_type->id == TypeTableEntryIdInvalid) {
-        return false;
-    }
-
-    ConstExprValue *const_bool_val = &get_resolved_expr(*node)->const_val;
-
-    if (!const_bool_val->ok) {
-        add_node_error(g, *node, buf_sprintf("unable to evaluate constant expression"));
-        return false;
-    }
-
-    *value = const_bool_val->data.x_bool;
-    return true;
-}
-
-static FnTableEntry *resolve_const_expr_fn(CodeGen *g, ImportTableEntry *import, BlockContext *context,
-        AstNode **node)
-{
-    TypeTableEntry *resolved_type = analyze_expression(g, import, context, nullptr, *node);
-
-    if (resolved_type->id == TypeTableEntryIdInvalid) {
-        return nullptr;
-    } else if (resolved_type->id == TypeTableEntryIdFn) {
-        ConstExprValue *const_val = &get_resolved_expr(*node)->const_val;
-
-        if (!const_val->ok) {
-            add_node_error(g, *node, buf_sprintf("unable to evaluate constant expression"));
-            return nullptr;
-        }
-
-        return const_val->data.x_fn;
-    } else {
-        add_node_error(g, *node, buf_sprintf("expected function, got '%s'", buf_ptr(&resolved_type->name)));
-        return nullptr;
-    }
-}
-
 static void resolve_function_proto(CodeGen *g, AstNode *node, FnTableEntry *fn_table_entry,
         ImportTableEntry *import, BlockContext *containing_context)
 {
@@ -3073,16 +3003,6 @@ static TypeTableEntry *resolve_expr_const_val_as_bool(CodeGen *g, AstNode *node,
     return g->builtin_types.entry_bool;
 }
 
-static TypeTableEntry *resolve_expr_const_val_as_non_null(CodeGen *g, AstNode *node,
-        TypeTableEntry *type, ConstExprValue *other_val)
-{
-    assert(other_val->ok);
-    Expr *expr = get_resolved_expr(node);
-    expr->const_val.ok = true;
-    expr->const_val.data.x_maybe = other_val;
-    return type;
-}
-
 static TypeTableEntry *resolve_expr_const_val_as_c_string_lit(CodeGen *g, AstNode *node, Buf *str) {
     Expr *expr = get_resolved_expr(node);
     expr->const_val.ok = true;
@@ -4432,33 +4352,6 @@ static TypeTableEntry *analyze_if_var_expr(CodeGen *g, ImportTableEntry *import,
             node, then_node, else_node, cond_is_const, cond_bool_val);
 }
 
-static TypeTableEntry *analyze_min_max_value(CodeGen *g, ImportTableEntry *import, BlockContext *context,
-        AstNode *node, const char *err_format, bool is_max)
-{
-    assert(node->type == NodeTypeFnCallExpr);
-    assert(node->data.fn_call_expr.params.length == 1);
-
-    AstNode *type_node = node->data.fn_call_expr.params.at(0);
-    TypeTableEntry *type_entry = analyze_type_expr(g, import, context, type_node);
-
-    if (type_entry->id == TypeTableEntryIdInvalid) {
-        return g->builtin_types.entry_invalid;
-    } else if (type_entry->id == TypeTableEntryIdInt) {
-        eval_min_max_value(g, type_entry, &get_resolved_expr(node)->const_val, is_max);
-        return g->builtin_types.entry_num_lit_int;
-    } else if (type_entry->id == TypeTableEntryIdFloat) {
-        eval_min_max_value(g, type_entry, &get_resolved_expr(node)->const_val, is_max);
-        return g->builtin_types.entry_num_lit_float;
-    } else if (type_entry->id == TypeTableEntryIdBool) {
-        eval_min_max_value(g, type_entry, &get_resolved_expr(node)->const_val, is_max);
-        return type_entry;
-    } else {
-        add_node_error(g, node,
-                buf_sprintf(err_format, buf_ptr(&type_entry->name)));
-        return g->builtin_types.entry_invalid;
-    }
-}
-
 bool type_is_codegen_pointer(TypeTableEntry *type) {
     if (type->id == TypeTableEntryIdPointer) return true;
     if (type->id == TypeTableEntryIdFn) return true;
@@ -4469,986 +4362,6 @@ bool type_is_codegen_pointer(TypeTableEntry *type) {
     return false;
 }
 
-static TypeTableEntry *analyze_import(CodeGen *g, ImportTableEntry *import, BlockContext *context,
-        AstNode *node)
-{
-    assert(node->type == NodeTypeFnCallExpr);
-
-    if (context->fn_entry) {
-        add_node_error(g, node, buf_sprintf("@import invalid inside function bodies"));
-        return g->builtin_types.entry_invalid;
-    }
-
-    AstNode *first_param_node = node->data.fn_call_expr.params.at(0);
-    Buf *import_target_str = resolve_const_expr_str(g, import, context, first_param_node->parent_field);
-    if (!import_target_str) {
-        return g->builtin_types.entry_invalid;
-    }
-
-    Buf *import_target_path;
-    Buf *search_dir;
-    assert(import->package);
-    PackageTableEntry *target_package;
-    auto package_entry = import->package->package_table.maybe_get(import_target_str);
-    if (package_entry) {
-        target_package = package_entry->value;
-        import_target_path = &target_package->root_src_path;
-        search_dir = &target_package->root_src_dir;
-    } else {
-        // try it as a filename
-        target_package = import->package;
-        import_target_path = import_target_str;
-        search_dir = &import->package->root_src_dir;
-    }
-
-    Buf full_path = BUF_INIT;
-    os_path_join(search_dir, import_target_path, &full_path);
-
-    Buf *import_code = buf_alloc();
-    Buf *abs_full_path = buf_alloc();
-    int err;
-    if ((err = os_path_real(&full_path, abs_full_path))) {
-        if (err == ErrorFileNotFound) {
-            add_node_error(g, node,
-                    buf_sprintf("unable to find '%s'", buf_ptr(import_target_path)));
-            return g->builtin_types.entry_invalid;
-        } else {
-            g->error_during_imports = true;
-            add_node_error(g, node,
-                    buf_sprintf("unable to open '%s': %s", buf_ptr(&full_path), err_str(err)));
-            return g->builtin_types.entry_invalid;
-        }
-    }
-
-    auto import_entry = g->import_table.maybe_get(abs_full_path);
-    if (import_entry) {
-        return resolve_expr_const_val_as_import(g, node, import_entry->value);
-    }
-
-    if ((err = os_fetch_file_path(abs_full_path, import_code))) {
-        if (err == ErrorFileNotFound) {
-            add_node_error(g, node,
-                    buf_sprintf("unable to find '%s'", buf_ptr(import_target_path)));
-            return g->builtin_types.entry_invalid;
-        } else {
-            add_node_error(g, node,
-                    buf_sprintf("unable to open '%s': %s", buf_ptr(&full_path), err_str(err)));
-            return g->builtin_types.entry_invalid;
-        }
-    }
-    ImportTableEntry *target_import = add_source_file(g, target_package,
-            abs_full_path, search_dir, import_target_path, import_code);
-
-    scan_decls(g, target_import, target_import->block_context, target_import->root);
-
-    return resolve_expr_const_val_as_import(g, node, target_import);
-}
-
-static TypeTableEntry *analyze_c_import(CodeGen *g, ImportTableEntry *parent_import,
-        BlockContext *parent_context, AstNode *node)
-{
-    assert(node->type == NodeTypeFnCallExpr);
-
-    if (parent_context->fn_entry) {
-        add_node_error(g, node, buf_sprintf("@c_import invalid inside function bodies"));
-        return g->builtin_types.entry_invalid;
-    }
-
-    AstNode *block_node = node->data.fn_call_expr.params.at(0);
-
-    BlockContext *child_context = new_block_context(node, parent_context);
-    child_context->c_import_buf = buf_alloc();
-
-    TypeTableEntry *resolved_type = analyze_expression(g, parent_import, child_context,
-            g->builtin_types.entry_void, block_node);
-
-    if (resolved_type->id == TypeTableEntryIdInvalid) {
-        return resolved_type;
-    }
-
-    find_libc_include_path(g);
-
-    ImportTableEntry *child_import = allocate<ImportTableEntry>(1);
-    child_import->c_import_node = node;
-
-    ZigList<ErrorMsg *> errors = {0};
-
-    int err;
-    if ((err = parse_h_buf(child_import, &errors, child_context->c_import_buf, g, node))) {
-        zig_panic("unable to parse h file: %s\n", err_str(err));
-    }
-
-    if (errors.length > 0) {
-        ErrorMsg *parent_err_msg = add_node_error(g, node, buf_sprintf("C import failed"));
-        for (size_t i = 0; i < errors.length; i += 1) {
-            ErrorMsg *err_msg = errors.at(i);
-            err_msg_add_note(parent_err_msg, err_msg);
-        }
-
-        return g->builtin_types.entry_invalid;
-    }
-
-    if (g->verbose) {
-        fprintf(stderr, "\nc_import:\n");
-        fprintf(stderr, "-----------\n");
-        ast_render(stderr, child_import->root, 4);
-    }
-
-    child_import->di_file = parent_import->di_file;
-    child_import->block_context = new_block_context(child_import->root, nullptr);
-
-    scan_decls(g, child_import, child_import->block_context, child_import->root);
-    return resolve_expr_const_val_as_import(g, node, child_import);
-}
-
-static TypeTableEntry *analyze_err_name(CodeGen *g, ImportTableEntry *import,
-        BlockContext *context, AstNode *node)
-{
-    assert(node->type == NodeTypeFnCallExpr);
-
-    AstNode *err_value = node->data.fn_call_expr.params.at(0);
-    TypeTableEntry *resolved_type = analyze_expression(g, import, context,
-            g->builtin_types.entry_pure_error, err_value);
-
-    if (resolved_type->id == TypeTableEntryIdInvalid) {
-        return resolved_type;
-    }
-
-    g->generate_error_name_table = true;
-
-    TypeTableEntry *str_type = get_slice_type(g, g->builtin_types.entry_u8, true);
-    return str_type;
-}
-
-static TypeTableEntry *analyze_embed_file(CodeGen *g, ImportTableEntry *import,
-        BlockContext *context, AstNode *node)
-{
-    assert(node->type == NodeTypeFnCallExpr);
-
-    AstNode **first_param_node = &node->data.fn_call_expr.params.at(0);
-    Buf *rel_file_path = resolve_const_expr_str(g, import, context, first_param_node);
-    if (!rel_file_path) {
-        return g->builtin_types.entry_invalid;
-    }
-
-    // figure out absolute path to resource
-    Buf source_dir_path = BUF_INIT;
-    os_path_dirname(import->path, &source_dir_path);
-
-    Buf file_path = BUF_INIT;
-    os_path_resolve(&source_dir_path, rel_file_path, &file_path);
-
-    // load from file system into const expr
-    Buf file_contents = BUF_INIT;
-    int err;
-    if ((err = os_fetch_file_path(&file_path, &file_contents))) {
-        if (err == ErrorFileNotFound) {
-            add_node_error(g, node,
-                    buf_sprintf("unable to find '%s'", buf_ptr(&file_path)));
-            return g->builtin_types.entry_invalid;
-        } else {
-            add_node_error(g, node,
-                    buf_sprintf("unable to open '%s': %s", buf_ptr(&file_path), err_str(err)));
-            return g->builtin_types.entry_invalid;
-        }
-    }
-
-    // TODO add dependency on the file we embedded so that we know if it changes
-    // we'll have to invalidate the cache
-
-    return resolve_expr_const_val_as_string_lit(g, node, &file_contents);
-}
-
-static TypeTableEntry *analyze_cmpxchg(CodeGen *g, ImportTableEntry *import,
-        BlockContext *context, AstNode *node)
-{
-    assert(node->type == NodeTypeFnCallExpr);
-
-    AstNode **ptr_arg = &node->data.fn_call_expr.params.at(0);
-    AstNode **cmp_arg = &node->data.fn_call_expr.params.at(1);
-    AstNode **new_arg = &node->data.fn_call_expr.params.at(2);
-    AstNode **success_order_arg = &node->data.fn_call_expr.params.at(3);
-    AstNode **failure_order_arg = &node->data.fn_call_expr.params.at(4);
-
-    TypeTableEntry *ptr_type = analyze_expression(g, import, context, nullptr, *ptr_arg);
-    if (ptr_type->id == TypeTableEntryIdInvalid) {
-        return g->builtin_types.entry_invalid;
-    } else if (ptr_type->id != TypeTableEntryIdPointer) {
-        add_node_error(g, *ptr_arg,
-            buf_sprintf("expected pointer argument, got '%s'", buf_ptr(&ptr_type->name)));
-        return g->builtin_types.entry_invalid;
-    }
-
-    TypeTableEntry *child_type = ptr_type->data.pointer.child_type;
-    TypeTableEntry *cmp_type = analyze_expression(g, import, context, child_type, *cmp_arg);
-    TypeTableEntry *new_type = analyze_expression(g, import, context, child_type, *new_arg);
-
-    TypeTableEntry *success_order_type = analyze_expression(g, import, context,
-            g->builtin_types.entry_atomic_order_enum, *success_order_arg);
-    TypeTableEntry *failure_order_type = analyze_expression(g, import, context,
-            g->builtin_types.entry_atomic_order_enum, *failure_order_arg);
-
-    if (cmp_type->id == TypeTableEntryIdInvalid ||
-        new_type->id == TypeTableEntryIdInvalid ||
-        success_order_type->id == TypeTableEntryIdInvalid ||
-        failure_order_type->id == TypeTableEntryIdInvalid)
-    {
-        return g->builtin_types.entry_invalid;
-    }
-
-    ConstExprValue *success_order_val = &get_resolved_expr(*success_order_arg)->const_val;
-    ConstExprValue *failure_order_val = &get_resolved_expr(*failure_order_arg)->const_val;
-    if (!success_order_val->ok) {
-        add_node_error(g, *success_order_arg, buf_sprintf("unable to evaluate constant expression"));
-        return g->builtin_types.entry_invalid;
-    } else if (!failure_order_val->ok) {
-        add_node_error(g, *failure_order_arg, buf_sprintf("unable to evaluate constant expression"));
-        return g->builtin_types.entry_invalid;
-    }
-
-    if (success_order_val->data.x_enum.tag < AtomicOrderMonotonic) {
-        add_node_error(g, *success_order_arg,
-                buf_sprintf("success atomic ordering must be Monotonic or stricter"));
-        return g->builtin_types.entry_invalid;
-    }
-    if (failure_order_val->data.x_enum.tag < AtomicOrderMonotonic) {
-        add_node_error(g, *failure_order_arg,
-                buf_sprintf("failure atomic ordering must be Monotonic or stricter"));
-        return g->builtin_types.entry_invalid;
-    }
-    if (failure_order_val->data.x_enum.tag > success_order_val->data.x_enum.tag) {
-        add_node_error(g, *failure_order_arg,
-                buf_sprintf("failure atomic ordering must be no stricter than success"));
-        return g->builtin_types.entry_invalid;
-    }
-    if (failure_order_val->data.x_enum.tag == AtomicOrderRelease ||
-        failure_order_val->data.x_enum.tag == AtomicOrderAcqRel)
-    {
-        add_node_error(g, *failure_order_arg,
-                buf_sprintf("failure atomic ordering must not be Release or AcqRel"));
-        return g->builtin_types.entry_invalid;
-    }
-
-    return g->builtin_types.entry_bool;
-}
-
-static TypeTableEntry *analyze_fence(CodeGen *g, ImportTableEntry *import,
-        BlockContext *context, AstNode *node)
-{
-    assert(node->type == NodeTypeFnCallExpr);
-
-    AstNode **atomic_order_arg = &node->data.fn_call_expr.params.at(0);
-    TypeTableEntry *atomic_order_type = analyze_expression(g, import, context,
-            g->builtin_types.entry_atomic_order_enum, *atomic_order_arg);
-
-    if (atomic_order_type->id == TypeTableEntryIdInvalid) {
-        return g->builtin_types.entry_invalid;
-    }
-
-    ConstExprValue *atomic_order_val = &get_resolved_expr(*atomic_order_arg)->const_val;
-
-    if (!atomic_order_val->ok) {
-        add_node_error(g, *atomic_order_arg, buf_sprintf("unable to evaluate constant expression"));
-        return g->builtin_types.entry_invalid;
-    }
-
-    return g->builtin_types.entry_void;
-}
-
-static TypeTableEntry *analyze_div_exact(CodeGen *g, ImportTableEntry *import,
-        BlockContext *context, AstNode *node)
-{
-    assert(node->type == NodeTypeFnCallExpr);
-
-    AstNode **op1 = &node->data.fn_call_expr.params.at(0);
-    AstNode **op2 = &node->data.fn_call_expr.params.at(1);
-
-    TypeTableEntry *op1_type = analyze_expression(g, import, context, nullptr, *op1);
-    TypeTableEntry *op2_type = analyze_expression(g, import, context, nullptr, *op2);
-
-    AstNode *op_nodes[] = {*op1, *op2};
-    TypeTableEntry *op_types[] = {op1_type, op2_type};
-    TypeTableEntry *result_type = resolve_peer_type_compatibility(g, import, context, node,
-            op_nodes, op_types, 2);
-
-    if (result_type->id == TypeTableEntryIdInvalid) {
-        return g->builtin_types.entry_invalid;
-    } else if (result_type->id == TypeTableEntryIdInt) {
-        return result_type;
-    } else if (result_type->id == TypeTableEntryIdNumLitInt) {
-        // check for division by zero
-        // check for non exact division
-        zig_panic("TODO");
-    } else {
-        add_node_error(g, node,
-                buf_sprintf("expected integer type, got '%s'", buf_ptr(&result_type->name)));
-        return g->builtin_types.entry_invalid;
-    }
-}
-
-static TypeTableEntry *analyze_truncate(CodeGen *g, ImportTableEntry *import,
-        BlockContext *context, AstNode *node)
-{
-    assert(node->type == NodeTypeFnCallExpr);
-
-    AstNode **op1 = &node->data.fn_call_expr.params.at(0);
-    AstNode **op2 = &node->data.fn_call_expr.params.at(1);
-
-    TypeTableEntry *dest_type = analyze_type_expr(g, import, context, *op1);
-    TypeTableEntry *src_type = analyze_expression(g, import, context, nullptr, *op2);
-
-    if (dest_type->id == TypeTableEntryIdInvalid || src_type->id == TypeTableEntryIdInvalid) {
-        return g->builtin_types.entry_invalid;
-    } else if (dest_type->id != TypeTableEntryIdInt) {
-        add_node_error(g, *op1,
-                buf_sprintf("expected integer type, got '%s'", buf_ptr(&dest_type->name)));
-        return g->builtin_types.entry_invalid;
-    } else if (src_type->id != TypeTableEntryIdInt) {
-        add_node_error(g, *op2,
-                buf_sprintf("expected integer type, got '%s'", buf_ptr(&src_type->name)));
-        return g->builtin_types.entry_invalid;
-    } else if (src_type->data.integral.is_signed != dest_type->data.integral.is_signed) {
-        const char *sign_str = dest_type->data.integral.is_signed ? "signed" : "unsigned";
-        add_node_error(g, *op2,
-                buf_sprintf("expected %s integer type, got '%s'", sign_str, buf_ptr(&src_type->name)));
-        return g->builtin_types.entry_invalid;
-    } else if (src_type->data.integral.bit_count <= dest_type->data.integral.bit_count) {
-        add_node_error(g, *op2,
-                buf_sprintf("type '%s' has same or fewer bits than destination type '%s'",
-                    buf_ptr(&src_type->name), buf_ptr(&dest_type->name)));
-        return g->builtin_types.entry_invalid;
-    }
-
-    // TODO const expr eval
-
-    return dest_type;
-}
-
-static TypeTableEntry *analyze_compile_err(CodeGen *g, ImportTableEntry *import,
-        BlockContext *context, AstNode *node)
-{
-    AstNode *first_param_node = node->data.fn_call_expr.params.at(0);
-    Buf *err_msg = resolve_const_expr_str(g, import, context, first_param_node->parent_field);
-    if (!err_msg) {
-        return g->builtin_types.entry_invalid;
-    }
-
-    add_node_error(g, node, err_msg);
-
-    return g->builtin_types.entry_invalid;
-}
-
-static TypeTableEntry *analyze_int_type(CodeGen *g, ImportTableEntry *import,
-        BlockContext *context, AstNode *node)
-{
-    AstNode **is_signed_node = &node->data.fn_call_expr.params.at(0);
-    AstNode **bit_count_node = &node->data.fn_call_expr.params.at(1);
-
-    TypeTableEntry *bool_type = g->builtin_types.entry_bool;
-    TypeTableEntry *usize_type = g->builtin_types.entry_usize;
-    TypeTableEntry *is_signed_type = analyze_expression(g, import, context, bool_type, *is_signed_node);
-    TypeTableEntry *bit_count_type = analyze_expression(g, import, context, usize_type, *bit_count_node);
-
-    if (is_signed_type->id == TypeTableEntryIdInvalid ||
-        bit_count_type->id == TypeTableEntryIdInvalid)
-    {
-        return g->builtin_types.entry_invalid;
-    }
-
-    ConstExprValue *is_signed_val = &get_resolved_expr(*is_signed_node)->const_val;
-    ConstExprValue *bit_count_val = &get_resolved_expr(*bit_count_node)->const_val;
-
-    AstNode *bad_node = nullptr;
-    if (!is_signed_val->ok) {
-        bad_node = *is_signed_node;
-    } else if (!bit_count_val->ok) {
-        bad_node = *bit_count_node;
-    }
-    if (bad_node) {
-        add_node_error(g, bad_node, buf_sprintf("unable to evaluate constant expression"));
-        return g->builtin_types.entry_invalid;
-    }
-
-    bool depends_on_compile_var = is_signed_val->depends_on_compile_var || bit_count_val->depends_on_compile_var;
-
-    TypeTableEntry *int_type = get_int_type(g, is_signed_val->data.x_bool,
-            bit_count_val->data.x_bignum.data.x_uint);
-    return resolve_expr_const_val_as_type(g, node, int_type, depends_on_compile_var);
-
-}
-
-static TypeTableEntry *analyze_set_fn_test(CodeGen *g, ImportTableEntry *import,
-        BlockContext *context, AstNode *node)
-{
-    AstNode **fn_node = &node->data.fn_call_expr.params.at(0);
-    AstNode **value_node = &node->data.fn_call_expr.params.at(1);
-
-    FnTableEntry *fn_entry = resolve_const_expr_fn(g, import, context, fn_node);
-    if (!fn_entry) {
-        return g->builtin_types.entry_invalid;
-    }
-
-    bool ok = resolve_const_expr_bool(g, import, context, value_node, &fn_entry->is_test);
-    if (!ok) {
-        return g->builtin_types.entry_invalid;
-    }
-
-    if (fn_entry->fn_test_set_node) {
-        ErrorMsg *msg = add_node_error(g, node, buf_sprintf("function test attribute set twice"));
-        add_error_note(g, msg, fn_entry->fn_test_set_node, buf_sprintf("first set here"));
-        return g->builtin_types.entry_invalid;
-    }
-    fn_entry->fn_test_set_node = node;
-
-    g->test_fn_count += 1;
-    return g->builtin_types.entry_void;
-}
-
-static TypeTableEntry *analyze_set_fn_no_inline(CodeGen *g, ImportTableEntry *import,
-        BlockContext *context, AstNode *node)
-{
-    AstNode **fn_node = &node->data.fn_call_expr.params.at(0);
-    AstNode **value_node = &node->data.fn_call_expr.params.at(1);
-
-    FnTableEntry *fn_entry = resolve_const_expr_fn(g, import, context, fn_node);
-    if (!fn_entry) {
-        return g->builtin_types.entry_invalid;
-    }
-
-    bool is_noinline;
-    bool ok = resolve_const_expr_bool(g, import, context, value_node, &is_noinline);
-    if (!ok) {
-        return g->builtin_types.entry_invalid;
-    }
-
-    if (fn_entry->fn_no_inline_set_node) {
-        ErrorMsg *msg = add_node_error(g, node, buf_sprintf("function no inline attribute set twice"));
-        add_error_note(g, msg, fn_entry->fn_no_inline_set_node, buf_sprintf("first set here"));
-        return g->builtin_types.entry_invalid;
-    }
-    fn_entry->fn_no_inline_set_node = node;
-
-    if (fn_entry->fn_inline == FnInlineAlways) {
-        add_node_error(g, node, buf_sprintf("function is both inline and noinline"));
-        fn_entry->proto_node->data.fn_proto.skip = true;
-        return g->builtin_types.entry_invalid;
-    } else if (is_noinline) {
-        fn_entry->fn_inline = FnInlineNever;
-    }
-
-    return g->builtin_types.entry_void;
-}
-
-static TypeTableEntry *analyze_set_fn_static_eval(CodeGen *g, ImportTableEntry *import,
-        BlockContext *context, AstNode *node)
-{
-    AstNode **fn_node = &node->data.fn_call_expr.params.at(0);
-    AstNode **value_node = &node->data.fn_call_expr.params.at(1);
-
-    FnTableEntry *fn_entry = resolve_const_expr_fn(g, import, context, fn_node);
-    if (!fn_entry) {
-        return g->builtin_types.entry_invalid;
-    }
-
-    bool want_static_eval;
-    bool ok = resolve_const_expr_bool(g, import, context, value_node, &want_static_eval);
-    if (!ok) {
-        return g->builtin_types.entry_invalid;
-    }
-
-    if (fn_entry->fn_static_eval_set_node) {
-        ErrorMsg *msg = add_node_error(g, node, buf_sprintf("function static eval attribute set twice"));
-        add_error_note(g, msg, fn_entry->fn_static_eval_set_node, buf_sprintf("first set here"));
-        return g->builtin_types.entry_invalid;
-    }
-    fn_entry->fn_static_eval_set_node = node;
-
-    if (want_static_eval && !context->fn_entry->is_pure) {
-        add_node_error(g, node, buf_sprintf("attribute appears too late within function"));
-        return g->builtin_types.entry_invalid;
-    }
-
-    if (want_static_eval) {
-        fn_entry->want_pure = WantPureTrue;
-        fn_entry->want_pure_attr_node = node;
-    } else {
-        fn_entry->want_pure = WantPureFalse;
-        fn_entry->is_pure = false;
-    }
-
-    return g->builtin_types.entry_void;
-}
-
-static TypeTableEntry *analyze_set_fn_visible(CodeGen *g, ImportTableEntry *import,
-        BlockContext *context, AstNode *node)
-{
-    AstNode **fn_node = &node->data.fn_call_expr.params.at(0);
-    AstNode **value_node = &node->data.fn_call_expr.params.at(1);
-
-    FnTableEntry *fn_entry = resolve_const_expr_fn(g, import, context, fn_node);
-    if (!fn_entry) {
-        return g->builtin_types.entry_invalid;
-    }
-
-    bool want_export;
-    bool ok = resolve_const_expr_bool(g, import, context, value_node, &want_export);
-    if (!ok) {
-        return g->builtin_types.entry_invalid;
-    }
-
-    if (fn_entry->fn_export_set_node) {
-        ErrorMsg *msg = add_node_error(g, node, buf_sprintf("function visibility set twice"));
-        add_error_note(g, msg, fn_entry->fn_export_set_node, buf_sprintf("first set here"));
-        return g->builtin_types.entry_invalid;
-    }
-    fn_entry->fn_export_set_node = node;
-
-    AstNodeFnProto *fn_proto = &fn_entry->proto_node->data.fn_proto;
-    if (fn_proto->top_level_decl.visib_mod != VisibModExport) {
-        ErrorMsg *msg = add_node_error(g, node,
-            buf_sprintf("function must be marked export to set function visibility"));
-        add_error_note(g, msg, fn_entry->proto_node, buf_sprintf("function declared here"));
-        return g->builtin_types.entry_void;
-    }
-    if (!want_export) {
-        fn_proto->top_level_decl.visib_mod = VisibModPub;
-    }
-
-    return g->builtin_types.entry_void;
-}
-
-static TypeTableEntry *analyze_set_debug_safety(CodeGen *g, ImportTableEntry *import,
-        BlockContext *parent_context, AstNode *node)
-{
-    AstNode **target_node = &node->data.fn_call_expr.params.at(0);
-    AstNode **value_node = &node->data.fn_call_expr.params.at(1);
-
-    TypeTableEntry *target_type = analyze_expression(g, import, parent_context, nullptr, *target_node);
-    BlockContext *target_context;
-    ConstExprValue *const_val = &get_resolved_expr(*target_node)->const_val;
-    if (target_type->id == TypeTableEntryIdInvalid) {
-        return g->builtin_types.entry_invalid;
-    }
-    if (!const_val->ok) {
-        add_node_error(g, *target_node, buf_sprintf("unable to evaluate constant expression"));
-        return g->builtin_types.entry_invalid;
-    }
-    if (target_type->id == TypeTableEntryIdBlock) {
-        target_context = const_val->data.x_block;
-    } else if (target_type->id == TypeTableEntryIdFn) {
-        target_context = const_val->data.x_fn->fn_def_node->data.fn_def.block_context;
-    } else if (target_type->id == TypeTableEntryIdMetaType) {
-        TypeTableEntry *type_arg = const_val->data.x_type;
-        if (type_arg->id == TypeTableEntryIdStruct) {
-            target_context = type_arg->data.structure.block_context;
-        } else if (type_arg->id == TypeTableEntryIdEnum) {
-            target_context = type_arg->data.enumeration.block_context;
-        } else if (type_arg->id == TypeTableEntryIdUnion) {
-            target_context = type_arg->data.unionation.block_context;
-        } else {
-            add_node_error(g, *target_node,
-                buf_sprintf("expected scope reference, got type '%s'", buf_ptr(&type_arg->name)));
-            return g->builtin_types.entry_invalid;
-        }
-    } else {
-        add_node_error(g, *target_node,
-            buf_sprintf("expected scope reference, got type '%s'", buf_ptr(&target_type->name)));
-        return g->builtin_types.entry_invalid;
-    }
-
-    bool want_debug_safety;
-    bool ok = resolve_const_expr_bool(g, import, parent_context, value_node, &want_debug_safety);
-    if (!ok) {
-        return g->builtin_types.entry_invalid;
-    }
-
-    if (target_context->safety_set_node) {
-        ErrorMsg *msg = add_node_error(g, node, buf_sprintf("debug safety for scope set twice"));
-        add_error_note(g, msg, target_context->safety_set_node, buf_sprintf("first set here"));
-        return g->builtin_types.entry_invalid;
-    }
-    target_context->safety_set_node = node;
-
-    target_context->safety_off = !want_debug_safety;
-
-    return g->builtin_types.entry_void;
-}
-
-static TypeTableEntry *analyze_builtin_fn_call_expr(CodeGen *g, ImportTableEntry *import, BlockContext *context,
-        TypeTableEntry *expected_type, AstNode *node)
-{
-    assert(node->type == NodeTypeFnCallExpr);
-
-    AstNode *fn_ref_expr = node->data.fn_call_expr.fn_ref_expr;
-    Buf *name = fn_ref_expr->data.symbol_expr.symbol;
-
-    auto entry = g->builtin_fn_table.maybe_get(name);
-
-    if (!entry) {
-        add_node_error(g, node,
-                buf_sprintf("invalid builtin function: '%s'", buf_ptr(name)));
-        return g->builtin_types.entry_invalid;
-    }
-
-    BuiltinFnEntry *builtin_fn = entry->value;
-    size_t actual_param_count = node->data.fn_call_expr.params.length;
-
-    node->data.fn_call_expr.builtin_fn = builtin_fn;
-
-    if (builtin_fn->param_count != actual_param_count) {
-        add_node_error(g, node,
-                buf_sprintf("expected %zu arguments, got %zu",
-                    builtin_fn->param_count, actual_param_count));
-        return g->builtin_types.entry_invalid;
-    }
-
-    builtin_fn->ref_count += 1;
-
-    switch (builtin_fn->id) {
-        case BuiltinFnIdInvalid:
-            zig_unreachable();
-        case BuiltinFnIdAddWithOverflow:
-        case BuiltinFnIdSubWithOverflow:
-        case BuiltinFnIdMulWithOverflow:
-        case BuiltinFnIdShlWithOverflow:
-            {
-                AstNode *type_node = node->data.fn_call_expr.params.at(0);
-                TypeTableEntry *int_type = analyze_type_expr(g, import, context, type_node);
-                if (int_type->id == TypeTableEntryIdInvalid) {
-                    return g->builtin_types.entry_bool;
-                } else if (int_type->id == TypeTableEntryIdInt) {
-                    AstNode *op1_node = node->data.fn_call_expr.params.at(1);
-                    AstNode *op2_node = node->data.fn_call_expr.params.at(2);
-                    AstNode *result_node = node->data.fn_call_expr.params.at(3);
-
-                    analyze_expression(g, import, context, int_type, op1_node);
-                    analyze_expression(g, import, context, int_type, op2_node);
-                    analyze_expression(g, import, context, get_pointer_to_type(g, int_type, false),
-                            result_node);
-                } else {
-                    add_node_error(g, type_node,
-                        buf_sprintf("expected integer type, got '%s'", buf_ptr(&int_type->name)));
-                }
-
-                // TODO constant expression evaluation
-
-                return g->builtin_types.entry_bool;
-            }
-        case BuiltinFnIdMemcpy:
-            {
-                AstNode *dest_node = node->data.fn_call_expr.params.at(0);
-                AstNode *src_node = node->data.fn_call_expr.params.at(1);
-                AstNode *len_node = node->data.fn_call_expr.params.at(2);
-                TypeTableEntry *dest_type = analyze_expression(g, import, context, nullptr, dest_node);
-                TypeTableEntry *src_type = analyze_expression(g, import, context, nullptr, src_node);
-                analyze_expression(g, import, context, builtin_fn->param_types[2], len_node);
-
-                if (dest_type->id != TypeTableEntryIdInvalid &&
-                    dest_type->id != TypeTableEntryIdPointer)
-                {
-                    add_node_error(g, dest_node,
-                            buf_sprintf("expected pointer argument, got '%s'", buf_ptr(&dest_type->name)));
-                }
-
-                if (src_type->id != TypeTableEntryIdInvalid &&
-                    src_type->id != TypeTableEntryIdPointer)
-                {
-                    add_node_error(g, src_node,
-                            buf_sprintf("expected pointer argument, got '%s'", buf_ptr(&src_type->name)));
-                }
-
-                if (dest_type->id == TypeTableEntryIdPointer &&
-                    src_type->id == TypeTableEntryIdPointer)
-                {
-                    uint64_t dest_align = get_memcpy_align(g, dest_type->data.pointer.child_type);
-                    uint64_t src_align = get_memcpy_align(g, src_type->data.pointer.child_type);
-                    if (dest_align != src_align) {
-                        add_node_error(g, dest_node, buf_sprintf(
-                            "misaligned memcpy, '%s' has alignment '%" PRIu64 ", '%s' has alignment %" PRIu64,
-                                    buf_ptr(&dest_type->name), dest_align,
-                                    buf_ptr(&src_type->name), src_align));
-                    }
-                }
-
-                return builtin_fn->return_type;
-            }
-        case BuiltinFnIdMemset:
-            {
-                AstNode *dest_node = node->data.fn_call_expr.params.at(0);
-                AstNode *char_node = node->data.fn_call_expr.params.at(1);
-                AstNode *len_node = node->data.fn_call_expr.params.at(2);
-                TypeTableEntry *dest_type = analyze_expression(g, import, context, nullptr, dest_node);
-                analyze_expression(g, import, context, builtin_fn->param_types[1], char_node);
-                analyze_expression(g, import, context, builtin_fn->param_types[2], len_node);
-
-                if (dest_type->id != TypeTableEntryIdInvalid &&
-                    dest_type->id != TypeTableEntryIdPointer)
-                {
-                    add_node_error(g, dest_node,
-                            buf_sprintf("expected pointer argument, got '%s'", buf_ptr(&dest_type->name)));
-                }
-
-                return builtin_fn->return_type;
-            }
-        case BuiltinFnIdSizeof:
-            {
-                AstNode *type_node = node->data.fn_call_expr.params.at(0);
-                TypeTableEntry *type_entry = analyze_type_expr(g, import, context, type_node);
-                if (type_entry->id == TypeTableEntryIdInvalid) {
-                    return g->builtin_types.entry_invalid;
-                } else if (type_entry->id == TypeTableEntryIdUnreachable) {
-                    add_node_error(g, first_executing_node(type_node),
-                            buf_sprintf("no size available for type '%s'", buf_ptr(&type_entry->name)));
-                    return g->builtin_types.entry_invalid;
-                } else {
-                    uint64_t size_in_bytes = type_size(g, type_entry);
-                    bool depends_on_compile_var = (type_entry == g->builtin_types.entry_usize ||
-                            type_entry == g->builtin_types.entry_isize);
-                    return resolve_expr_const_val_as_unsigned_num_lit(g, node, expected_type,
-                            size_in_bytes, depends_on_compile_var);
-                }
-            }
-        case BuiltinFnIdAlignof:
-            {
-                AstNode *type_node = node->data.fn_call_expr.params.at(0);
-                TypeTableEntry *type_entry = analyze_type_expr(g, import, context, type_node);
-                if (type_entry->id == TypeTableEntryIdInvalid) {
-                    return g->builtin_types.entry_invalid;
-                } else if (type_entry->id == TypeTableEntryIdUnreachable) {
-                    add_node_error(g, first_executing_node(type_node),
-                            buf_sprintf("no align available for type '%s'", buf_ptr(&type_entry->name)));
-                    return g->builtin_types.entry_invalid;
-                } else {
-                    uint64_t align_in_bytes = LLVMABISizeOfType(g->target_data_ref, type_entry->type_ref);
-                    return resolve_expr_const_val_as_unsigned_num_lit(g, node, expected_type,
-                            align_in_bytes, false);
-                }
-            }
-        case BuiltinFnIdMaxValue:
-            return analyze_min_max_value(g, import, context, node,
-                    "no max value available for type '%s'", true);
-        case BuiltinFnIdMinValue:
-            return analyze_min_max_value(g, import, context, node,
-                    "no min value available for type '%s'", false);
-        case BuiltinFnIdMemberCount:
-            {
-                AstNode *type_node = node->data.fn_call_expr.params.at(0);
-                TypeTableEntry *type_entry = analyze_type_expr(g, import, context, type_node);
-
-                if (type_entry->id == TypeTableEntryIdInvalid) {
-                    return type_entry;
-                } else if (type_entry->id == TypeTableEntryIdEnum) {
-                    uint64_t value_count = type_entry->data.enumeration.src_field_count;
-                    return resolve_expr_const_val_as_unsigned_num_lit(g, node, expected_type,
-                            value_count, false);
-                } else {
-                    add_node_error(g, node,
-                            buf_sprintf("no value count available for type '%s'", buf_ptr(&type_entry->name)));
-                    return g->builtin_types.entry_invalid;
-                }
-            }
-        case BuiltinFnIdTypeof:
-            {
-                AstNode *expr_node = node->data.fn_call_expr.params.at(0);
-                TypeTableEntry *type_entry = analyze_expression(g, import, context, nullptr, expr_node);
-
-                switch (type_entry->id) {
-                    case TypeTableEntryIdInvalid:
-                        return type_entry;
-                    case TypeTableEntryIdNumLitFloat:
-                    case TypeTableEntryIdNumLitInt:
-                    case TypeTableEntryIdUndefLit:
-                    case TypeTableEntryIdNullLit:
-                    case TypeTableEntryIdNamespace:
-                    case TypeTableEntryIdBlock:
-                    case TypeTableEntryIdGenericFn:
-                    case TypeTableEntryIdVar:
-                        add_node_error(g, expr_node,
-                                buf_sprintf("type '%s' not eligible for @typeOf", buf_ptr(&type_entry->name)));
-                        return g->builtin_types.entry_invalid;
-                    case TypeTableEntryIdMetaType:
-                    case TypeTableEntryIdVoid:
-                    case TypeTableEntryIdBool:
-                    case TypeTableEntryIdUnreachable:
-                    case TypeTableEntryIdInt:
-                    case TypeTableEntryIdFloat:
-                    case TypeTableEntryIdPointer:
-                    case TypeTableEntryIdArray:
-                    case TypeTableEntryIdStruct:
-                    case TypeTableEntryIdMaybe:
-                    case TypeTableEntryIdErrorUnion:
-                    case TypeTableEntryIdPureError:
-                    case TypeTableEntryIdEnum:
-                    case TypeTableEntryIdUnion:
-                    case TypeTableEntryIdFn:
-                    case TypeTableEntryIdTypeDecl:
-                        return resolve_expr_const_val_as_type(g, node, type_entry, false);
-                }
-            }
-        case BuiltinFnIdCInclude:
-            {
-                if (!context->c_import_buf) {
-                    add_node_error(g, node, buf_sprintf("@c_include valid only in c_import blocks"));
-                    return g->builtin_types.entry_invalid;
-                }
-
-                AstNode **str_node = node->data.fn_call_expr.params.at(0)->parent_field;
-                TypeTableEntry *str_type = get_slice_type(g, g->builtin_types.entry_u8, true);
-                TypeTableEntry *resolved_type = analyze_expression(g, import, context, str_type, *str_node);
-
-                if (resolved_type->id == TypeTableEntryIdInvalid) {
-                    return resolved_type;
-                }
-
-                ConstExprValue *const_str_val = &get_resolved_expr(*str_node)->const_val;
-
-                if (!const_str_val->ok) {
-                    add_node_error(g, *str_node, buf_sprintf("@c_include requires constant expression"));
-                    return g->builtin_types.entry_void;
-                }
-
-                buf_appendf(context->c_import_buf, "#include <");
-                ConstExprValue *ptr_field = const_str_val->data.x_struct.fields[0];
-                uint64_t len = ptr_field->data.x_ptr.len;
-                for (uint64_t i = 0; i < len; i += 1) {
-                    ConstExprValue *char_val = ptr_field->data.x_ptr.ptr[i];
-                    uint64_t big_c = char_val->data.x_bignum.data.x_uint;
-                    assert(big_c <= UINT8_MAX);
-                    uint8_t c = big_c;
-                    buf_append_char(context->c_import_buf, c);
-                }
-                buf_appendf(context->c_import_buf, ">\n");
-
-                return g->builtin_types.entry_void;
-            }
-        case BuiltinFnIdCDefine:
-            zig_panic("TODO");
-        case BuiltinFnIdCUndef:
-            zig_panic("TODO");
-
-        case BuiltinFnIdCompileVar:
-            {
-                AstNode **str_node = node->data.fn_call_expr.params.at(0)->parent_field;
-
-                Buf *var_name = resolve_const_expr_str(g, import, context, str_node);
-                if (!var_name) {
-                    return g->builtin_types.entry_invalid;
-                }
-
-                ConstExprValue *const_val = &get_resolved_expr(node)->const_val;
-                const_val->ok = true;
-                const_val->depends_on_compile_var = true;
-
-                if (buf_eql_str(var_name, "is_big_endian")) {
-                    return resolve_expr_const_val_as_bool(g, node, g->is_big_endian, true);
-                } else if (buf_eql_str(var_name, "is_release")) {
-                    return resolve_expr_const_val_as_bool(g, node, g->is_release_build, true);
-                } else if (buf_eql_str(var_name, "is_test")) {
-                    return resolve_expr_const_val_as_bool(g, node, g->is_test_build, true);
-                } else if (buf_eql_str(var_name, "os")) {
-                    const_val->data.x_enum.tag = g->target_os_index;
-                    return g->builtin_types.entry_os_enum;
-                } else if (buf_eql_str(var_name, "arch")) {
-                    const_val->data.x_enum.tag = g->target_arch_index;
-                    return g->builtin_types.entry_arch_enum;
-                } else if (buf_eql_str(var_name, "environ")) {
-                    const_val->data.x_enum.tag = g->target_environ_index;
-                    return g->builtin_types.entry_environ_enum;
-                } else if (buf_eql_str(var_name, "object_format")) {
-                    const_val->data.x_enum.tag = g->target_oformat_index;
-                    return g->builtin_types.entry_oformat_enum;
-                } else {
-                    add_node_error(g, *str_node,
-                        buf_sprintf("unrecognized compile variable: '%s'", buf_ptr(var_name)));
-                    return g->builtin_types.entry_invalid;
-                }
-            }
-        case BuiltinFnIdConstEval:
-            {
-                AstNode **expr_node = node->data.fn_call_expr.params.at(0)->parent_field;
-                TypeTableEntry *resolved_type = analyze_expression(g, import, context, expected_type, *expr_node);
-                if (resolved_type->id == TypeTableEntryIdInvalid) {
-                    return resolved_type;
-                }
-
-                ConstExprValue *const_expr_val = &get_resolved_expr(*expr_node)->const_val;
-
-                if (!const_expr_val->ok) {
-                    add_node_error(g, *expr_node, buf_sprintf("unable to evaluate constant expression"));
-                    return g->builtin_types.entry_invalid;
-                }
-
-                ConstExprValue *const_val = &get_resolved_expr(node)->const_val;
-                *const_val = *const_expr_val;
-
-                return resolved_type;
-            }
-        case BuiltinFnIdCtz:
-        case BuiltinFnIdClz:
-            {
-                AstNode *type_node = node->data.fn_call_expr.params.at(0);
-                TypeTableEntry *int_type = analyze_type_expr(g, import, context, type_node);
-                if (int_type->id == TypeTableEntryIdInvalid) {
-                    return int_type;
-                } else if (int_type->id == TypeTableEntryIdInt) {
-                    AstNode **expr_node = node->data.fn_call_expr.params.at(1)->parent_field;
-                    TypeTableEntry *resolved_type = analyze_expression(g, import, context, int_type, *expr_node);
-                    if (resolved_type->id == TypeTableEntryIdInvalid) {
-                        return resolved_type;
-                    }
-
-                    // TODO const expr eval
-
-                    return resolved_type;
-                } else {
-                    add_node_error(g, type_node,
-                        buf_sprintf("expected integer type, got '%s'", buf_ptr(&int_type->name)));
-                    return g->builtin_types.entry_invalid;
-                }
-            }
-        case BuiltinFnIdImport:
-            return analyze_import(g, import, context, node);
-        case BuiltinFnIdCImport:
-            return analyze_c_import(g, import, context, node);
-        case BuiltinFnIdErrName:
-            return analyze_err_name(g, import, context, node);
-        case BuiltinFnIdBreakpoint:
-            mark_impure_fn(g, context, node);
-            return g->builtin_types.entry_void;
-        case BuiltinFnIdReturnAddress:
-        case BuiltinFnIdFrameAddress:
-            mark_impure_fn(g, context, node);
-            return builtin_fn->return_type;
-        case BuiltinFnIdEmbedFile:
-            return analyze_embed_file(g, import, context, node);
-        case BuiltinFnIdCmpExchange:
-            return analyze_cmpxchg(g, import, context, node);
-        case BuiltinFnIdFence:
-            return analyze_fence(g, import, context, node);
-        case BuiltinFnIdDivExact:
-            return analyze_div_exact(g, import, context, node);
-        case BuiltinFnIdTruncate:
-            return analyze_truncate(g, import, context, node);
-        case BuiltinFnIdCompileErr:
-            return analyze_compile_err(g, import, context, node);
-        case BuiltinFnIdIntType:
-            return analyze_int_type(g, import, context, node);
-        case BuiltinFnIdUnreachable:
-            return g->builtin_types.entry_unreachable;
-        case BuiltinFnIdSetFnTest:
-            return analyze_set_fn_test(g, import, context, node);
-        case BuiltinFnIdSetFnNoInline:
-            return analyze_set_fn_no_inline(g, import, context, node);
-        case BuiltinFnIdSetFnStaticEval:
-            return analyze_set_fn_static_eval(g, import, context, node);
-        case BuiltinFnIdSetFnVisible:
-            return analyze_set_fn_visible(g, import, context, node);
-        case BuiltinFnIdSetDebugSafety:
-            return analyze_set_debug_safety(g, import, context, node);
-    }
-    zig_unreachable();
-}
-
 static TypeTableEntry *bad_method_call(CodeGen *g, AstNode *node, TypeTableEntry *container_type,
         TypeTableEntry *expected_param_type, FnTableEntry *fn_table_entry)
 {
@@ -5817,7 +4730,7 @@ static TypeTableEntry *analyze_fn_call_expr(CodeGen *g, ImportTableEntry *import
     AstNode *fn_ref_expr = node->data.fn_call_expr.fn_ref_expr;
 
     if (node->data.fn_call_expr.is_builtin) {
-        return analyze_builtin_fn_call_expr(g, import, context, expected_type, node);
+        zig_panic("moved builtin fn call code to ir.cpp");
     }
 
     TypeTableEntry *invoke_type_entry = analyze_expression(g, import, context, nullptr, fn_ref_expr);
@@ -5885,222 +4798,6 @@ static TypeTableEntry *analyze_fn_call_expr(CodeGen *g, ImportTableEntry *import
     }
 }
 
-static TypeTableEntry *analyze_prefix_op_expr(CodeGen *g, ImportTableEntry *import, BlockContext *context,
-        TypeTableEntry *expected_type, AstNode *node)
-{
-    PrefixOp prefix_op = node->data.prefix_op_expr.prefix_op;
-    AstNode **expr_node = &node->data.prefix_op_expr.primary_expr;
-    switch (prefix_op) {
-        case PrefixOpInvalid:
-            zig_unreachable();
-        case PrefixOpBoolNot:
-            {
-                TypeTableEntry *type_entry = analyze_expression(g, import, context, g->builtin_types.entry_bool,
-                        *expr_node);
-                if (type_entry->id == TypeTableEntryIdInvalid) {
-                    return g->builtin_types.entry_bool;
-                }
-
-                ConstExprValue *target_const_val = &get_resolved_expr(*expr_node)->const_val;
-                if (!target_const_val->ok) {
-                    return g->builtin_types.entry_bool;
-                }
-
-                bool answer = !target_const_val->data.x_bool;
-                return resolve_expr_const_val_as_bool(g, node, answer, target_const_val->depends_on_compile_var);
-            }
-        case PrefixOpBinNot:
-            {
-                TypeTableEntry *expr_type = analyze_expression(g, import, context, expected_type,
-                        *expr_node);
-                if (expr_type->id == TypeTableEntryIdInvalid) {
-                    return expr_type;
-                } else if (expr_type->id == TypeTableEntryIdInt) {
-                    return expr_type;
-                } else {
-                    add_node_error(g, node, buf_sprintf("unable to perform binary not operation on type '%s'",
-                            buf_ptr(&expr_type->name)));
-                    return g->builtin_types.entry_invalid;
-                }
-                // TODO const expr eval
-            }
-        case PrefixOpNegation:
-        case PrefixOpNegationWrap:
-            {
-                TypeTableEntry *expr_type = analyze_expression(g, import, context, nullptr, *expr_node);
-                if (expr_type->id == TypeTableEntryIdInvalid) {
-                    return expr_type;
-                } else if ((expr_type->id == TypeTableEntryIdInt &&
-                            expr_type->data.integral.is_signed) ||
-                            expr_type->id == TypeTableEntryIdNumLitInt ||
-                            ((expr_type->id == TypeTableEntryIdFloat ||
-                            expr_type->id == TypeTableEntryIdNumLitFloat) &&
-                            prefix_op != PrefixOpNegationWrap))
-                {
-                    ConstExprValue *target_const_val = &get_resolved_expr(*expr_node)->const_val;
-                    if (!target_const_val->ok) {
-                        return expr_type;
-                    }
-                    ConstExprValue *const_val = &get_resolved_expr(node)->const_val;
-                    const_val->ok = true;
-                    const_val->depends_on_compile_var = target_const_val->depends_on_compile_var;
-                    bignum_negate(&const_val->data.x_bignum, &target_const_val->data.x_bignum);
-                    if (expr_type->id == TypeTableEntryIdFloat ||
-                        expr_type->id == TypeTableEntryIdNumLitFloat ||
-                        expr_type->id == TypeTableEntryIdNumLitInt)
-                    {
-                        return expr_type;
-                    }
-
-                    bool overflow = !bignum_fits_in_bits(&const_val->data.x_bignum,
-                            expr_type->data.integral.bit_count, expr_type->data.integral.is_signed);
-                    if (prefix_op == PrefixOpNegationWrap) {
-                        if (overflow) {
-                            const_val->data.x_bignum.is_negative = true;
-                        }
-                    } else if (overflow) {
-                        add_node_error(g, *expr_node, buf_sprintf("negation caused overflow"));
-                        return g->builtin_types.entry_invalid;
-                    }
-                    return expr_type;
-                } else {
-                    const char *fmt = (prefix_op == PrefixOpNegationWrap) ?
-                        "invalid wrapping negation type: '%s'" : "invalid negation type: '%s'";
-                    add_node_error(g, node, buf_sprintf(fmt, buf_ptr(&expr_type->name)));
-                    return g->builtin_types.entry_invalid;
-                }
-            }
-        case PrefixOpAddressOf:
-        case PrefixOpConstAddressOf:
-            {
-                bool is_const = (prefix_op == PrefixOpConstAddressOf);
-
-                TypeTableEntry *child_type = analyze_lvalue(g, import, context,
-                        *expr_node, LValPurposeAddressOf, is_const);
-
-                if (child_type->id == TypeTableEntryIdInvalid) {
-                    return g->builtin_types.entry_invalid;
-                } else if (child_type->id == TypeTableEntryIdMetaType) {
-                    TypeTableEntry *meta_type = analyze_type_expr_pointer_only(g, import, context,
-                            *expr_node, true);
-                    if (meta_type->id == TypeTableEntryIdInvalid) {
-                        return g->builtin_types.entry_invalid;
-                    } else if (meta_type->id == TypeTableEntryIdUnreachable) {
-                        add_node_error(g, node, buf_create_from_str("pointer to unreachable not allowed"));
-                        return g->builtin_types.entry_invalid;
-                    } else {
-                        return resolve_expr_const_val_as_type(g, node,
-                                get_pointer_to_type(g, meta_type, is_const), false);
-                    }
-                } else if (child_type->id == TypeTableEntryIdNumLitInt ||
-                           child_type->id == TypeTableEntryIdNumLitFloat)
-                {
-                    add_node_error(g, *expr_node,
-                        buf_sprintf("unable to get address of type '%s'", buf_ptr(&child_type->name)));
-                    return g->builtin_types.entry_invalid;
-                } else {
-                    return get_pointer_to_type(g, child_type, is_const);
-                }
-            }
-        case PrefixOpDereference:
-            {
-                TypeTableEntry *type_entry = analyze_expression(g, import, context, nullptr, *expr_node);
-                if (type_entry->id == TypeTableEntryIdInvalid) {
-                    return type_entry;
-                } else if (type_entry->id == TypeTableEntryIdPointer) {
-                    return type_entry->data.pointer.child_type;
-                } else {
-                    add_node_error(g, *expr_node,
-                        buf_sprintf("indirection requires pointer operand ('%s' invalid)",
-                            buf_ptr(&type_entry->name)));
-                    return g->builtin_types.entry_invalid;
-                }
-            }
-        case PrefixOpMaybe:
-            {
-                TypeTableEntry *type_entry = analyze_expression(g, import, context, nullptr, *expr_node);
-
-                if (type_entry->id == TypeTableEntryIdInvalid) {
-                    return type_entry;
-                } else if (type_entry->id == TypeTableEntryIdMetaType) {
-                    TypeTableEntry *meta_type = resolve_type(g, *expr_node);
-                    if (meta_type->id == TypeTableEntryIdInvalid) {
-                        return g->builtin_types.entry_invalid;
-                    } else if (meta_type->id == TypeTableEntryIdUnreachable) {
-                        add_node_error(g, node, buf_create_from_str("unable to wrap unreachable in maybe type"));
-                        return g->builtin_types.entry_invalid;
-                    } else {
-                        return resolve_expr_const_val_as_type(g, node, get_maybe_type(g, meta_type), false);
-                    }
-                } else if (type_entry->id == TypeTableEntryIdUnreachable) {
-                    add_node_error(g, *expr_node, buf_sprintf("unable to wrap unreachable in maybe type"));
-                    return g->builtin_types.entry_invalid;
-                } else {
-                    ConstExprValue *target_const_val = &get_resolved_expr(*expr_node)->const_val;
-                    TypeTableEntry *maybe_type = get_maybe_type(g, type_entry);
-                    if (!target_const_val->ok) {
-                        return maybe_type;
-                    }
-                    return resolve_expr_const_val_as_non_null(g, node, maybe_type, target_const_val);
-                }
-            }
-        case PrefixOpError:
-            {
-                TypeTableEntry *type_entry = analyze_expression(g, import, context, nullptr, *expr_node);
-
-                if (type_entry->id == TypeTableEntryIdInvalid) {
-                    return type_entry;
-                } else if (type_entry->id == TypeTableEntryIdMetaType) {
-                    TypeTableEntry *meta_type = resolve_type(g, *expr_node);
-                    if (meta_type->id == TypeTableEntryIdInvalid) {
-                        return meta_type;
-                    } else if (meta_type->id == TypeTableEntryIdUnreachable) {
-                        add_node_error(g, node, buf_create_from_str("unable to wrap unreachable in error type"));
-                        return g->builtin_types.entry_invalid;
-                    } else {
-                        return resolve_expr_const_val_as_type(g, node, get_error_type(g, meta_type), false);
-                    }
-                } else if (type_entry->id == TypeTableEntryIdUnreachable) {
-                    add_node_error(g, *expr_node, buf_sprintf("unable to wrap unreachable in error type"));
-                    return g->builtin_types.entry_invalid;
-                } else {
-                    // TODO eval const expr
-                    return get_error_type(g, type_entry);
-                }
-
-            }
-        case PrefixOpUnwrapError:
-            {
-                TypeTableEntry *type_entry = analyze_expression(g, import, context, nullptr, *expr_node);
-
-                if (type_entry->id == TypeTableEntryIdInvalid) {
-                    return type_entry;
-                } else if (type_entry->id == TypeTableEntryIdErrorUnion) {
-                    return type_entry->data.error.child_type;
-                } else {
-                    add_node_error(g, *expr_node,
-                        buf_sprintf("expected error type, got '%s'", buf_ptr(&type_entry->name)));
-                    return g->builtin_types.entry_invalid;
-                }
-            }
-        case PrefixOpUnwrapMaybe:
-            {
-                TypeTableEntry *type_entry = analyze_expression(g, import, context, nullptr, *expr_node);
-
-                if (type_entry->id == TypeTableEntryIdInvalid) {
-                    return type_entry;
-                } else if (type_entry->id == TypeTableEntryIdMaybe) {
-                    return type_entry->data.maybe.child_type;
-                } else {
-                    add_node_error(g, *expr_node,
-                        buf_sprintf("expected maybe type, got '%s'", buf_ptr(&type_entry->name)));
-                    return g->builtin_types.entry_invalid;
-                }
-            }
-    }
-    zig_unreachable();
-}
-
 static TypeTableEntry *analyze_switch_expr(CodeGen *g, ImportTableEntry *import, BlockContext *context,
         TypeTableEntry *expected_type, AstNode *node)
 {
@@ -6665,7 +5362,7 @@ static TypeTableEntry *analyze_expression_pointer_only(CodeGen *g, ImportTableEn
             return_type = analyze_symbol_expr(g, import, context, expected_type, node, pointer_only);
             break;
         case NodeTypePrefixOpExpr:
-            return_type = analyze_prefix_op_expr(g, import, context, expected_type, node);
+            zig_panic("moved to ir.cpp");
             break;
         case NodeTypeIfBoolExpr:
             return_type = analyze_if_bool_expr(g, import, context, expected_type, node);