diff options
Diffstat (limited to 'src/analyze.cpp')
| -rw-r--r-- | src/analyze.cpp | 497 |
1 files changed, 176 insertions, 321 deletions
diff --git a/src/analyze.cpp b/src/analyze.cpp index 62b560f0c3..244bdc5fc6 100644 --- a/src/analyze.cpp +++ b/src/analyze.cpp @@ -13,6 +13,7 @@ #include "parseh.hpp" #include "config.h" #include "ast_render.hpp" +#include "eval.hpp" static TypeTableEntry *analyze_expression(CodeGen *g, ImportTableEntry *import, BlockContext *context, TypeTableEntry *expected_type, AstNode *node); @@ -34,7 +35,8 @@ static TypeTableEntry *resolve_expr_const_val_as_type(CodeGen *g, AstNode *node, static TypeTableEntry *resolve_expr_const_val_as_unsigned_num_lit(CodeGen *g, AstNode *node, TypeTableEntry *expected_type, uint64_t x); static AstNode *find_decl(BlockContext *context, Buf *name); -static TypeTableEntry *analyze_decl_ref(CodeGen *g, AstNode *source_node, AstNode *decl_node, bool pointer_only); +static TypeTableEntry *analyze_decl_ref(CodeGen *g, AstNode *source_node, AstNode *decl_node, + bool pointer_only, BlockContext *block_context); static TopLevelDecl *get_as_top_level_decl(AstNode *node); static VariableTableEntry *analyze_variable_declaration_raw(CodeGen *g, ImportTableEntry *import, BlockContext *context, AstNode *source_node, @@ -206,6 +208,7 @@ TypeTableEntry *get_smallest_unsigned_int_type(CodeGen *g, uint64_t x) { static TypeTableEntry *get_generic_fn_type(CodeGen *g, AstNode *decl_node) { TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdGenericFn); buf_init_from_str(&entry->name, "(generic function)"); + entry->deep_const = true; entry->zero_bits = true; entry->data.generic_fn.decl_node = decl_node; return entry; @@ -219,6 +222,8 @@ TypeTableEntry *get_pointer_to_type(CodeGen *g, TypeTableEntry *child_type, bool } else { TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdPointer); + entry->deep_const = is_const && child_type->deep_const; + const char *const_str = is_const ? "const " : ""; buf_resize(&entry->name, 0); buf_appendf(&entry->name, "&%s%s", const_str, buf_ptr(&child_type->name)); @@ -260,6 +265,8 @@ TypeTableEntry *get_maybe_type(CodeGen *g, TypeTableEntry *child_type) { assert(child_type->type_ref); assert(child_type->di_type); + entry->deep_const = child_type->deep_const; + buf_resize(&entry->name, 0); buf_appendf(&entry->name, "?%s", buf_ptr(&child_type->name)); @@ -343,6 +350,8 @@ static TypeTableEntry *get_error_type(CodeGen *g, TypeTableEntry *child_type) { entry->data.error.child_type = child_type; + entry->deep_const = child_type->deep_const; + if (!type_has_bits(child_type)) { entry->type_ref = g->err_tag_type->type_ref; entry->di_type = g->err_tag_type->di_type; @@ -414,6 +423,7 @@ TypeTableEntry *get_array_type(CodeGen *g, TypeTableEntry *child_type, uint64_t TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdArray); entry->type_ref = LLVMArrayType(child_type->type_ref, array_size); entry->zero_bits = (array_size == 0) || child_type->zero_bits; + entry->deep_const = child_type->deep_const; buf_resize(&entry->name, 0); buf_appendf(&entry->name, "[%" PRIu64 "]%s", array_size, buf_ptr(&child_type->name)); @@ -464,6 +474,8 @@ TypeTableEntry *get_slice_type(CodeGen *g, TypeTableEntry *child_type, bool is_c TypeTableEntry *var_peer = get_slice_type(g, child_type, false); TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdStruct); + entry->deep_const = child_type->deep_const; + buf_resize(&entry->name, 0); buf_appendf(&entry->name, "[]const %s", buf_ptr(&child_type->name)); @@ -549,6 +561,7 @@ TypeTableEntry *get_typedecl_type(CodeGen *g, const char *name, TypeTableEntry * buf_init_from_str(&entry->name, name); + entry->deep_const = child_type->deep_const; entry->type_ref = child_type->type_ref; entry->di_type = child_type->di_type; entry->zero_bits = child_type->zero_bits; @@ -572,6 +585,7 @@ TypeTableEntry *get_fn_type(CodeGen *g, FnTypeId *fn_type_id) { } TypeTableEntry *fn_type = new_type_table_entry(TypeTableEntryIdFn); + fn_type->deep_const = true; fn_type->data.fn.fn_type_id = *fn_type_id; if (fn_type_id->param_info == &fn_type_id->prealloc_param_info[0]) { fn_type->data.fn.fn_type_id.param_info = &fn_type->data.fn.fn_type_id.prealloc_param_info[0]; @@ -944,6 +958,19 @@ static void resolve_function_proto(CodeGen *g, AstNode *node, FnTableEntry *fn_t add_node_error(g, directive_node, buf_sprintf("#condition valid only on exported symbols")); } + } else if (buf_eql_str(name, "static_eval_enable")) { + if (fn_table_entry->is_extern) { + add_node_error(g, directive_node, + buf_sprintf("#static_val_enable invalid on extern functions")); + } else { + bool enable; + bool ok = resolve_const_expr_bool(g, import, import->block_context, + &directive_node->data.directive.expr, &enable); + if (!enable || !ok) { + fn_table_entry->is_pure = false; + } + // TODO cause compile error if enable is true and impure fn + } } else { add_node_error(g, directive_node, buf_sprintf("invalid directive: '%s'", buf_ptr(name))); @@ -1037,6 +1064,8 @@ static void resolve_enum_type(CodeGen *g, ImportTableEntry *import, TypeTableEnt assert(enum_type->di_type); + enum_type->deep_const = true; + uint32_t field_count = decl_node->data.struct_decl.fields.length; enum_type->data.enumeration.field_count = field_count; @@ -1064,6 +1093,10 @@ static void resolve_enum_type(CodeGen *g, ImportTableEntry *import, TypeTableEnt type_enum_field->type_entry = field_type; type_enum_field->value = i; + if (!field_type->deep_const) { + enum_type->deep_const = false; + } + di_enumerators[i] = LLVMZigCreateDebugEnumerator(g->dbuilder, buf_ptr(type_enum_field->name), i); @@ -1224,6 +1257,8 @@ static void resolve_struct_type(CodeGen *g, ImportTableEntry *import, TypeTableE assert(struct_type->di_type); + struct_type->deep_const = true; + int field_count = decl_node->data.struct_decl.fields.length; struct_type->data.structure.src_field_count = field_count; @@ -1247,6 +1282,10 @@ static void resolve_struct_type(CodeGen *g, ImportTableEntry *import, TypeTableE type_struct_field->src_index = i; type_struct_field->gen_index = -1; + if (!field_type->deep_const) { + struct_type->deep_const = false; + } + if (field_type->id == TypeTableEntryIdStruct) { resolve_struct_type(g, import, field_type); } else if (field_type->id == TypeTableEntryIdEnum) { @@ -1374,6 +1413,7 @@ static void preview_fn_proto_instance(CodeGen *g, ImportTableEntry *import, AstN fn_table_entry->proto_node = proto_node; fn_table_entry->fn_def_node = fn_def_node; fn_table_entry->is_extern = is_extern; + fn_table_entry->is_pure = !is_extern; get_fully_qualified_decl_name(&fn_table_entry->symbol_name, proto_node, '_'); @@ -2201,9 +2241,9 @@ static TypeTableEntry *analyze_container_init_expr(CodeGen *g, ImportTableEntry const_val->ok = false; } } - if (!const_val->ok) { - context->fn_entry->struct_val_expr_alloca_list.append(codegen); - } + } + if (!const_val->ok) { + context->fn_entry->struct_val_expr_alloca_list.append(codegen); } for (int i = 0; i < actual_field_count; i += 1) { @@ -2355,7 +2395,7 @@ static TypeTableEntry *analyze_field_access_expr(CodeGen *g, ImportTableEntry *i AstNode *decl_node = entry ? entry->value : nullptr; if (decl_node) { bool pointer_only = false; - return analyze_decl_ref(g, node, decl_node, pointer_only); + return analyze_decl_ref(g, node, decl_node, pointer_only, context); } else { add_node_error(g, node, buf_sprintf("container '%s' has no member called '%s'", @@ -2382,7 +2422,7 @@ static TypeTableEntry *analyze_field_access_expr(CodeGen *g, ImportTableEntry *i add_error_note(g, msg, decl_node, buf_sprintf("declared here")); } bool pointer_only = false; - return analyze_decl_ref(g, node, decl_node, pointer_only); + return analyze_decl_ref(g, node, decl_node, pointer_only, context); } else { const char *import_name = namespace_import->path ? buf_ptr(namespace_import->path) : "(C import)"; add_node_error(g, node, @@ -2443,6 +2483,12 @@ static TypeTableEntry *analyze_slice_expr(CodeGen *g, ImportTableEntry *import, return return_type; } +static void mark_impure_fn(BlockContext *context) { + if (context->fn_entry) { + context->fn_entry->is_pure = false; + } +} + static TypeTableEntry *analyze_array_access_expr(CodeGen *g, ImportTableEntry *import, BlockContext *context, AstNode *node) { @@ -2607,26 +2653,6 @@ static TypeTableEntry *resolve_expr_const_val_as_float_num_lit(CodeGen *g, AstNo return g->builtin_types.entry_num_lit_float; } -static TypeTableEntry *resolve_expr_const_val_as_bignum_op(CodeGen *g, AstNode *node, - bool (*bignum_fn)(BigNum *, BigNum *, BigNum *), AstNode *op1, AstNode *op2, - TypeTableEntry *resolved_type) -{ - ConstExprValue *const_val = &get_resolved_expr(node)->const_val; - ConstExprValue *op1_val = &get_resolved_expr(op1)->const_val; - ConstExprValue *op2_val = &get_resolved_expr(op2)->const_val; - - const_val->ok = true; - - if (bignum_fn(&const_val->data.x_bignum, &op1_val->data.x_bignum, &op2_val->data.x_bignum)) { - add_node_error(g, node, - buf_sprintf("value cannot be represented in any integer type")); - } else { - num_lit_fits_in_other_type(g, node, resolved_type); - } - - return resolved_type; -} - static TypeTableEntry *analyze_error_literal_expr(CodeGen *g, ImportTableEntry *import, BlockContext *context, AstNode *node, Buf *err_name) { @@ -2642,8 +2668,21 @@ static TypeTableEntry *analyze_error_literal_expr(CodeGen *g, ImportTableEntry * return g->builtin_types.entry_invalid; } -static TypeTableEntry *analyze_var_ref(CodeGen *g, AstNode *source_node, VariableTableEntry *var) { +static bool var_is_pure(VariableTableEntry *var, BlockContext *context) { + if (var->block_context->fn_entry == context->fn_entry) { + // variable was declared in the current function, so it's OK. + return true; + } + return var->is_const && var->type->deep_const; +} + +static TypeTableEntry *analyze_var_ref(CodeGen *g, AstNode *source_node, VariableTableEntry *var, + BlockContext *context) +{ get_resolved_expr(source_node)->variable = var; + if (!var_is_pure(var, context)) { + mark_impure_fn(context); + } if (var->is_const && var->val_node) { ConstExprValue *other_const_val = &get_resolved_expr(var->val_node)->const_val; if (other_const_val->ok) { @@ -2654,7 +2693,7 @@ static TypeTableEntry *analyze_var_ref(CodeGen *g, AstNode *source_node, Variabl } static TypeTableEntry *analyze_decl_ref(CodeGen *g, AstNode *source_node, AstNode *decl_node, - bool pointer_only) + bool pointer_only, BlockContext *block_context) { resolve_top_level_decl(g, decl_node, pointer_only); TopLevelDecl *tld = get_as_top_level_decl(decl_node); @@ -2664,7 +2703,7 @@ static TypeTableEntry *analyze_decl_ref(CodeGen *g, AstNode *source_node, AstNod if (decl_node->type == NodeTypeVariableDeclaration) { VariableTableEntry *var = decl_node->data.variable_declaration.variable; - return analyze_var_ref(g, source_node, var); + return analyze_var_ref(g, source_node, var, block_context); } else if (decl_node->type == NodeTypeFnProto) { if (decl_node->data.fn_proto.generic_params.length > 0) { TypeTableEntry *type_entry = decl_node->data.fn_proto.generic_fn_type; @@ -2700,12 +2739,13 @@ static TypeTableEntry *analyze_symbol_expr(CodeGen *g, ImportTableEntry *import, VariableTableEntry *var = find_variable(g, context, variable_name); if (var) { - return analyze_var_ref(g, node, var); + TypeTableEntry *var_type = analyze_var_ref(g, node, var, context); + return var_type; } AstNode *decl_node = find_decl(context, variable_name); if (decl_node) { - return analyze_decl_ref(g, node, decl_node, pointer_only); + return analyze_decl_ref(g, node, decl_node, pointer_only, context); } if (import->any_imports_failed) { @@ -2840,71 +2880,6 @@ static TypeTableEntry *analyze_lvalue(CodeGen *g, ImportTableEntry *import, Bloc return expected_rhs_type; } -static bool eval_bool_bin_op_bool(bool a, BinOpType bin_op, bool b) { - if (bin_op == BinOpTypeBoolOr) { - return a || b; - } else if (bin_op == BinOpTypeBoolAnd) { - return a && b; - } else { - zig_unreachable(); - } -} - -static bool const_values_equal(ConstExprValue *a, ConstExprValue *b, TypeTableEntry *type_entry) { - switch (type_entry->id) { - case TypeTableEntryIdEnum: - { - ConstEnumValue *enum1 = &a->data.x_enum; - ConstEnumValue *enum2 = &b->data.x_enum; - if (enum1->tag == enum2->tag) { - TypeEnumField *enum_field = &type_entry->data.enumeration.fields[enum1->tag]; - if (type_has_bits(enum_field->type_entry)) { - zig_panic("TODO const expr analyze enum special value for equality"); - } else { - return true; - } - } - return false; - } - case TypeTableEntryIdMetaType: - return a->data.x_type == b->data.x_type; - case TypeTableEntryIdVoid: - return true; - case TypeTableEntryIdPureError: - return a->data.x_err.err == b->data.x_err.err; - case TypeTableEntryIdFn: - return a->data.x_fn == b->data.x_fn; - case TypeTableEntryIdBool: - return a->data.x_bool == b->data.x_bool; - case TypeTableEntryIdInt: - case TypeTableEntryIdFloat: - case TypeTableEntryIdNumLitFloat: - case TypeTableEntryIdNumLitInt: - return bignum_cmp_eq(&a->data.x_bignum, &b->data.x_bignum); - case TypeTableEntryIdPointer: - zig_panic("TODO"); - case TypeTableEntryIdArray: - zig_panic("TODO"); - case TypeTableEntryIdStruct: - zig_panic("TODO"); - case TypeTableEntryIdUndefLit: - zig_panic("TODO"); - case TypeTableEntryIdMaybe: - zig_panic("TODO"); - case TypeTableEntryIdErrorUnion: - zig_panic("TODO"); - case TypeTableEntryIdTypeDecl: - zig_panic("TODO"); - case TypeTableEntryIdNamespace: - zig_panic("TODO"); - case TypeTableEntryIdGenericFn: - case TypeTableEntryIdInvalid: - case TypeTableEntryIdUnreachable: - zig_unreachable(); - } - zig_unreachable(); -} - static TypeTableEntry *analyze_bool_bin_op_expr(CodeGen *g, ImportTableEntry *import, BlockContext *context, AstNode *node) { @@ -2944,39 +2919,11 @@ static TypeTableEntry *analyze_bool_bin_op_expr(CodeGen *g, ImportTableEntry *im return g->builtin_types.entry_bool; } - bool answer; - if (type_can_gt_lt_cmp) { - bool (*bignum_cmp)(BigNum *, BigNum *); - if (bin_op_type == BinOpTypeCmpEq) { - bignum_cmp = bignum_cmp_eq; - } else if (bin_op_type == BinOpTypeCmpNotEq) { - bignum_cmp = bignum_cmp_neq; - } else if (bin_op_type == BinOpTypeCmpLessThan) { - bignum_cmp = bignum_cmp_lt; - } else if (bin_op_type == BinOpTypeCmpGreaterThan) { - bignum_cmp = bignum_cmp_gt; - } else if (bin_op_type == BinOpTypeCmpLessOrEq) { - bignum_cmp = bignum_cmp_lte; - } else if (bin_op_type == BinOpTypeCmpGreaterOrEq) { - bignum_cmp = bignum_cmp_gte; - } else { - zig_unreachable(); - } - answer = bignum_cmp(&op1_val->data.x_bignum, &op2_val->data.x_bignum); - } else { - bool are_equal = const_values_equal(op1_val, op2_val, resolved_type); - if (bin_op_type == BinOpTypeCmpEq) { - answer = are_equal; - } else if (bin_op_type == BinOpTypeCmpNotEq) { - answer = !are_equal; - } else { - zig_unreachable(); - } - } + ConstExprValue *out_val = &get_resolved_expr(node)->const_val; + eval_const_expr_bin_op(op1_val, op1_type, bin_op_type, op2_val, op2_type, out_val); + return g->builtin_types.entry_bool; - bool depends_on_compile_var = op1_val->depends_on_compile_var || op2_val->depends_on_compile_var; - return resolve_expr_const_val_as_bool(g, node, answer, depends_on_compile_var); } static TypeTableEntry *analyze_logic_bin_op_expr(CodeGen *g, ImportTableEntry *import, BlockContext *context, @@ -3002,9 +2949,9 @@ static TypeTableEntry *analyze_logic_bin_op_expr(CodeGen *g, ImportTableEntry *i return g->builtin_types.entry_bool; } - bool answer = eval_bool_bin_op_bool(op1_val->data.x_bool, bin_op_type, op2_val->data.x_bool); - bool depends_on_compile_var = op1_val->depends_on_compile_var || op2_val->depends_on_compile_var; - return resolve_expr_const_val_as_bool(g, node, answer, depends_on_compile_var); + ConstExprValue *out_val = &get_resolved_expr(node)->const_val; + eval_const_expr_bin_op(op1_val, op1_type, bin_op_type, op2_val, op2_type, out_val); + return g->builtin_types.entry_bool; } static TypeTableEntry *analyze_bin_op_expr(CodeGen *g, ImportTableEntry *import, BlockContext *context, @@ -3041,6 +2988,7 @@ static TypeTableEntry *analyze_bin_op_expr(CodeGen *g, ImportTableEntry *import, } analyze_expression(g, import, context, expected_rhs_type, node->data.bin_op_expr.op2); + // not const ok because expression has side effects return g->builtin_types.entry_void; } case BinOpTypeBoolOr: @@ -3106,37 +3054,23 @@ static TypeTableEntry *analyze_bin_op_expr(CodeGen *g, ImportTableEntry *import, return resolved_type; } - if (bin_op_type == BinOpTypeAdd) { - return resolve_expr_const_val_as_bignum_op(g, node, bignum_add, *op1, *op2, resolved_type); - } else if (bin_op_type == BinOpTypeSub) { - return resolve_expr_const_val_as_bignum_op(g, node, bignum_sub, *op1, *op2, resolved_type); - } else if (bin_op_type == BinOpTypeMult) { - return resolve_expr_const_val_as_bignum_op(g, node, bignum_mul, *op1, *op2, resolved_type); - } else if (bin_op_type == BinOpTypeDiv) { - ConstExprValue *op2_val = &get_resolved_expr(*op2)->const_val; - if ((is_int && op2_val->data.x_bignum.data.x_uint == 0) || - (is_float && op2_val->data.x_bignum.data.x_float == 0.0)) - { + ConstExprValue *out_val = &get_resolved_expr(node)->const_val; + int err; + if ((err = eval_const_expr_bin_op(op1_val, resolved_type, bin_op_type, + op2_val, resolved_type, out_val))) + { + if (err == ErrorDivByZero) { add_node_error(g, node, buf_sprintf("division by zero is undefined")); return g->builtin_types.entry_invalid; - } else { - return resolve_expr_const_val_as_bignum_op(g, node, bignum_div, *op1, *op2, resolved_type); + } else if (err == ErrorOverflow) { + add_node_error(g, node, buf_sprintf("value cannot be represented in any integer type")); + return g->builtin_types.entry_invalid; } - } else if (bin_op_type == BinOpTypeMod) { - return resolve_expr_const_val_as_bignum_op(g, node, bignum_mod, *op1, *op2, resolved_type); - } else if (bin_op_type == BinOpTypeBinOr) { - return resolve_expr_const_val_as_bignum_op(g, node, bignum_or, *op1, *op2, resolved_type); - } else if (bin_op_type == BinOpTypeBinAnd) { - return resolve_expr_const_val_as_bignum_op(g, node, bignum_and, *op1, *op2, resolved_type); - } else if (bin_op_type == BinOpTypeBinXor) { - return resolve_expr_const_val_as_bignum_op(g, node, bignum_xor, *op1, *op2, resolved_type); - } else if (bin_op_type == BinOpTypeBitShiftLeft) { - return resolve_expr_const_val_as_bignum_op(g, node, bignum_shl, *op1, *op2, resolved_type); - } else if (bin_op_type == BinOpTypeBitShiftRight) { - return resolve_expr_const_val_as_bignum_op(g, node, bignum_shr, *op1, *op2, resolved_type); - } else { - zig_unreachable(); + return g->builtin_types.entry_invalid; } + + num_lit_fits_in_other_type(g, node, resolved_type); + return resolved_type; } case BinOpTypeUnwrapMaybe: { @@ -3720,6 +3654,10 @@ static TypeTableEntry *analyze_if_bool_expr(CodeGen *g, ImportTableEntry *import } ConstExprValue *cond_val = &get_resolved_expr(*cond)->const_val; + if (cond_val->undef) { + add_node_error(g, first_executing_node(*cond), buf_sprintf("branch on undefined value")); + return cond_type; + } if (cond_val->ok && !cond_val->depends_on_compile_var) { const char *str_val = cond_val->data.x_bool ? "true" : "false"; add_node_error(g, first_executing_node(*cond), @@ -3762,17 +3700,6 @@ static TypeTableEntry *analyze_if_var_expr(CodeGen *g, ImportTableEntry *import, node, then_node, else_node, cond_is_const, cond_bool_val); } -static bool int_type_depends_on_compile_var(CodeGen *g, TypeTableEntry *int_type) { - assert(int_type->id == TypeTableEntryIdInt); - - for (int i = 0; i < CIntTypeCount; i += 1) { - if (int_type == g->builtin_types.entry_c_int[i]) { - return true; - } - } - return false; -} - static TypeTableEntry *analyze_min_max_value(CodeGen *g, ImportTableEntry *import, BlockContext *context, AstNode *node, const char *err_format, bool is_max) { @@ -3781,67 +3708,15 @@ static TypeTableEntry *analyze_min_max_value(CodeGen *g, ImportTableEntry *impor 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) { - ConstExprValue *const_val = &get_resolved_expr(node)->const_val; - const_val->ok = true; - const_val->depends_on_compile_var = int_type_depends_on_compile_var(g, type_entry); - if (is_max) { - if (type_entry->data.integral.is_signed) { - int64_t val; - if (type_entry->data.integral.bit_count == 64) { - val = INT64_MAX; - } else if (type_entry->data.integral.bit_count == 32) { - val = INT32_MAX; - } else if (type_entry->data.integral.bit_count == 16) { - val = INT16_MAX; - } else if (type_entry->data.integral.bit_count == 8) { - val = INT8_MAX; - } else { - zig_unreachable(); - } - bignum_init_signed(&const_val->data.x_bignum, val); - } else { - uint64_t val; - if (type_entry->data.integral.bit_count == 64) { - val = UINT64_MAX; - } else if (type_entry->data.integral.bit_count == 32) { - val = UINT32_MAX; - } else if (type_entry->data.integral.bit_count == 16) { - val = UINT16_MAX; - } else if (type_entry->data.integral.bit_count == 8) { - val = UINT8_MAX; - } else { - zig_unreachable(); - } - bignum_init_unsigned(&const_val->data.x_bignum, val); - } - } else { - if (type_entry->data.integral.is_signed) { - int64_t val; - if (type_entry->data.integral.bit_count == 64) { - val = INT64_MIN; - } else if (type_entry->data.integral.bit_count == 32) { - val = INT32_MIN; - } else if (type_entry->data.integral.bit_count == 16) { - val = INT16_MIN; - } else if (type_entry->data.integral.bit_count == 8) { - val = INT8_MIN; - } else { - zig_unreachable(); - } - bignum_init_signed(&const_val->data.x_bignum, val); - } else { - bignum_init_unsigned(&const_val->data.x_bignum, 0); - } - } - return type_entry; - } else if (type_entry->id == TypeTableEntryIdFloat) { - zig_panic("TODO analyze_min_max_value float"); + } else if (type_entry->id == TypeTableEntryIdInt || + type_entry->id == TypeTableEntryIdFloat || + type_entry->id == TypeTableEntryIdBool) + { + eval_min_max_value(g, type_entry, &get_resolved_expr(node)->const_val, is_max); return type_entry; - } else if (type_entry->id == TypeTableEntryIdBool) { - return resolve_expr_const_val_as_bool(g, node, is_max, false); } else { add_node_error(g, node, buf_sprintf(err_format, buf_ptr(&type_entry->name))); @@ -3849,92 +3724,19 @@ static TypeTableEntry *analyze_min_max_value(CodeGen *g, ImportTableEntry *impor } } -static void eval_const_expr_implicit_cast(CodeGen *g, AstNode *node, AstNode *expr_node) { - assert(node->type == NodeTypeFnCallExpr); - ConstExprValue *other_val = &get_resolved_expr(expr_node)->const_val; - ConstExprValue *const_val = &get_resolved_expr(node)->const_val; - if (!other_val->ok) { - return; - } - const_val->depends_on_compile_var = other_val->depends_on_compile_var; - const_val->undef = other_val->undef; - - assert(other_val != const_val); - switch (node->data.fn_call_expr.cast_op) { - case CastOpNoCast: - zig_unreachable(); - case CastOpNoop: - case CastOpWidenOrShorten: - case CastOpPointerReinterpret: - *const_val = *other_val; - break; - case CastOpPtrToInt: - case CastOpIntToPtr: - // can't do it - break; - case CastOpToUnknownSizeArray: - { - TypeTableEntry *other_type = get_resolved_expr(expr_node)->type_entry; - assert(other_type->id == TypeTableEntryIdArray); - - ConstExprValue *all_fields = allocate<ConstExprValue>(2); - ConstExprValue *ptr_field = &all_fields[0]; - ConstExprValue *len_field = &all_fields[1]; - - const_val->data.x_struct.fields = allocate<ConstExprValue*>(2); - const_val->data.x_struct.fields[0] = ptr_field; - const_val->data.x_struct.fields[1] = len_field; - - ptr_field->ok = true; - ptr_field->data.x_ptr.ptr = other_val->data.x_array.fields; - ptr_field->data.x_ptr.len = other_type->data.array.len; - - len_field->ok = true; - bignum_init_unsigned(&len_field->data.x_bignum, other_type->data.array.len); - - const_val->ok = true; - break; - } - case CastOpMaybeWrap: - const_val->data.x_maybe = other_val; - const_val->ok = true; - break; - case CastOpErrorWrap: - const_val->data.x_err.err = nullptr; - const_val->data.x_err.payload = other_val; - const_val->ok = true; - break; - case CastOpPureErrorWrap: - const_val->data.x_err.err = other_val->data.x_err.err; - const_val->ok = true; - break; - case CastOpErrToInt: - { - uint64_t value = other_val->data.x_err.err ? other_val->data.x_err.err->value : 0; - bignum_init_unsigned(&const_val->data.x_bignum, value); - const_val->ok = true; - break; - } - case CastOpIntToFloat: - bignum_cast_to_float(&const_val->data.x_bignum, &other_val->data.x_bignum); - const_val->ok = true; - break; - case CastOpFloatToInt: - bignum_cast_to_int(&const_val->data.x_bignum, &other_val->data.x_bignum); - const_val->ok = true; - break; - case CastOpBoolToInt: - bignum_init_unsigned(&const_val->data.x_bignum, other_val->data.x_bool ? 1 : 0); - const_val->ok = true; - break; - } -} - static TypeTableEntry *resolve_cast(CodeGen *g, BlockContext *context, AstNode *node, AstNode *expr_node, TypeTableEntry *wanted_type, CastOp op, bool need_alloca) { node->data.fn_call_expr.cast_op = op; - eval_const_expr_implicit_cast(g, node, expr_node); + + ConstExprValue *other_val = &get_resolved_expr(expr_node)->const_val; + TypeTableEntry *other_type = get_resolved_expr(expr_node)->type_entry; + ConstExprValue *const_val = &get_resolved_expr(node)->const_val; + if (other_val->ok) { + eval_const_expr_implicit_cast(node->data.fn_call_expr.cast_op, other_val, other_type, + const_val, wanted_type); + } + if (need_alloca) { if (context->fn_entry) { context->fn_entry->cast_alloca_list.append(node); @@ -4630,13 +4432,15 @@ static TypeTableEntry *analyze_builtin_fn_call_expr(CodeGen *g, ImportTableEntry case BuiltinFnIdErrName: return analyze_err_name(g, import, context, node); case BuiltinFnIdBreakpoint: + mark_impure_fn(context); return g->builtin_types.entry_void; } zig_unreachable(); } static TypeTableEntry *analyze_fn_call_ptr(CodeGen *g, ImportTableEntry *import, BlockContext *context, - TypeTableEntry *expected_type, AstNode *node, TypeTableEntry *fn_type, TypeTableEntry *struct_type) + TypeTableEntry *expected_type, AstNode *node, TypeTableEntry *fn_type, + AstNode *struct_node) { assert(node->type == NodeTypeFnCallExpr); @@ -4648,31 +4452,49 @@ static TypeTableEntry *analyze_fn_call_ptr(CodeGen *g, ImportTableEntry *import, int src_param_count = fn_type->data.fn.fn_type_id.param_count; int actual_param_count = node->data.fn_call_expr.params.length; - if (struct_type) { + if (struct_node) { actual_param_count += 1; } + bool ok_invocation = true; + if (fn_type->data.fn.fn_type_id.is_var_args) { if (actual_param_count < src_param_count) { + ok_invocation = false; add_node_error(g, node, buf_sprintf("expected at least %d arguments, got %d", src_param_count, actual_param_count)); } } else if (src_param_count != actual_param_count) { + ok_invocation = false; add_node_error(g, node, buf_sprintf("expected %d arguments, got %d", src_param_count, actual_param_count)); } + bool all_args_const_expr = true; + + if (struct_node) { + ConstExprValue *struct_const_val = &get_resolved_expr(struct_node)->const_val; + if (!struct_const_val->ok) { + all_args_const_expr = false; + } + } + // analyze each parameter. in the case of a method, we already analyzed the // first parameter in order to figure out which struct we were calling a method on. for (int i = 0; i < node->data.fn_call_expr.params.length; i += 1) { - AstNode *child = node->data.fn_call_expr.params.at(i); + AstNode **child = &node->data.fn_call_expr.params.at(i); // determine the expected type for each parameter TypeTableEntry *expected_param_type = nullptr; - int fn_proto_i = i + (struct_type ? 1 : 0); + int fn_proto_i = i + (struct_node ? 1 : 0); if (fn_proto_i < src_param_count) { expected_param_type = fn_type->data.fn.fn_type_id.param_info[fn_proto_i].type; } - analyze_expression(g, import, context, expected_param_type, child); + analyze_expression(g, import, context, expected_param_type, *child); + + ConstExprValue *const_arg_val = &get_resolved_expr(*child)->const_val; + if (!const_arg_val->ok) { + all_args_const_expr = false; + } } TypeTableEntry *return_type = fn_type->data.fn.fn_type_id.return_type; @@ -4681,6 +4503,27 @@ static TypeTableEntry *analyze_fn_call_ptr(CodeGen *g, ImportTableEntry *import, return return_type; } + FnTableEntry *fn_table_entry = node->data.fn_call_expr.fn_entry; + if (ok_invocation && fn_table_entry && fn_table_entry->is_pure) { + if (fn_table_entry->anal_state == FnAnalStateReady) { + analyze_fn_body(g, fn_table_entry); + } + if (all_args_const_expr) { + if (fn_table_entry->is_pure && fn_table_entry->anal_state == FnAnalStateComplete) { + ConstExprValue *result_val = &get_resolved_expr(node)->const_val; + if (eval_fn(g, node, fn_table_entry, result_val, 1000, struct_node)) { + // function evaluation generated an error + return g->builtin_types.entry_invalid; + } + return return_type; + } + } + } + if (!ok_invocation || !fn_table_entry || !fn_table_entry->is_pure) { + // calling an impure fn is impure + mark_impure_fn(context); + } + if (handle_is_ptr(return_type)) { context->fn_entry->cast_alloca_list.append(node); } @@ -4689,13 +4532,13 @@ static TypeTableEntry *analyze_fn_call_ptr(CodeGen *g, ImportTableEntry *import, } static TypeTableEntry *analyze_fn_call_raw(CodeGen *g, ImportTableEntry *import, BlockContext *context, - TypeTableEntry *expected_type, AstNode *node, FnTableEntry *fn_table_entry, TypeTableEntry *struct_type) + TypeTableEntry *expected_type, AstNode *node, FnTableEntry *fn_table_entry, AstNode *struct_node) { assert(node->type == NodeTypeFnCallExpr); node->data.fn_call_expr.fn_entry = fn_table_entry; - return analyze_fn_call_ptr(g, import, context, expected_type, node, fn_table_entry->type_entry, struct_type); + return analyze_fn_call_ptr(g, import, context, expected_type, node, fn_table_entry->type_entry, struct_node); } static TypeTableEntry *analyze_generic_fn_call(CodeGen *g, ImportTableEntry *import, BlockContext *parent_context, @@ -4721,7 +4564,7 @@ static TypeTableEntry *analyze_generic_fn_call(CodeGen *g, ImportTableEntry *imp generic_fn_type_id->generic_param_count = actual_param_count; generic_fn_type_id->generic_params = allocate<GenericParamValue>(actual_param_count); - BlockContext *child_context = import->block_context; + BlockContext *child_context = decl_node->owner->block_context; for (int i = 0; i < actual_param_count; i += 1) { AstNode *generic_param_decl_node = decl_node->data.fn_proto.generic_params.at(i); assert(generic_param_decl_node->type == NodeTypeParamDecl); @@ -4861,17 +4704,17 @@ static TypeTableEntry *analyze_fn_call_expr(CodeGen *g, ImportTableEntry *import return analyze_cast_expr(g, import, context, node); } } else if (invoke_type_entry->id == TypeTableEntryIdFn) { - TypeTableEntry *bare_struct_type; + AstNode *struct_node; if (fn_ref_expr->type == NodeTypeFieldAccessExpr && fn_ref_expr->data.field_access_expr.is_member_fn) { - bare_struct_type = fn_ref_expr->data.field_access_expr.bare_struct_type; + struct_node = fn_ref_expr->data.field_access_expr.struct_expr; } else { - bare_struct_type = nullptr; + struct_node = nullptr; } return analyze_fn_call_raw(g, import, context, expected_type, node, - const_val->data.x_fn, bare_struct_type); + const_val->data.x_fn, struct_node); } else if (invoke_type_entry->id == TypeTableEntryIdGenericFn) { return analyze_generic_fn_call(g, import, context, expected_type, node, const_val->data.x_type); } else { @@ -5421,6 +5264,8 @@ static TypeTableEntry *analyze_block_expr(CodeGen *g, ImportTableEntry *import, static TypeTableEntry *analyze_asm_expr(CodeGen *g, ImportTableEntry *import, BlockContext *context, TypeTableEntry *expected_type, AstNode *node) { + mark_impure_fn(context); + node->data.asm_expr.return_count = 0; TypeTableEntry *return_type = g->builtin_types.entry_void; for (int i = 0; i < node->data.asm_expr.output_list.length; i += 1) { @@ -5641,8 +5486,10 @@ static void analyze_fn_body(CodeGen *g, FnTableEntry *fn_table_entry) { if (fn_proto_node->data.fn_proto.skip) { // we detected an error with this function definition which prevents us // from further analyzing it. + fn_table_entry->anal_state = FnAnalStateSkipped; return; } + fn_table_entry->anal_state = FnAnalStateProbing; BlockContext *context = node->data.fn_def.block_context; @@ -5676,6 +5523,10 @@ static void analyze_fn_body(CodeGen *g, FnTableEntry *fn_table_entry) { param_decl_node->data.param_decl.variable = var; var->gen_arg_index = fn_type->data.fn.gen_param_info[i].gen_index; + + if (!type->deep_const) { + fn_table_entry->is_pure = false; + } } TypeTableEntry *expected_type = fn_type->data.fn.fn_type_id.return_type; @@ -5697,6 +5548,8 @@ static void analyze_fn_body(CodeGen *g, FnTableEntry *fn_table_entry) { buf_ptr(&label->decl_node->data.label.name))); } } + + fn_table_entry->anal_state = FnAnalStateComplete; } static void add_top_level_decl(CodeGen *g, ImportTableEntry *import, BlockContext *block_context, @@ -6005,7 +5858,9 @@ void semantic_analyze(CodeGen *g) { for (int i = 0; i < g->fn_defs.length; i += 1) { FnTableEntry *fn_entry = g->fn_defs.at(i); - analyze_fn_body(g, fn_entry); + if (fn_entry->anal_state == FnAnalStateReady) { + analyze_fn_body(g, fn_entry); + } } } |