authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2019-08-30 20:06:02-04:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2019-08-30 20:06:02-04:00
log6ab8b2aab4b146a7d1d882686199eace19989011
tree8ef3d1b06c79982b3c8709d93b8b1db25be2eac2
parent2148943fff5af1e31f75b1e6651f0b7614e7e36a
signaturelock-open Commit is signed but in an unrecognized format.

support recursive async and non-async functions

which heap allocate their own frames related: #1006

9 files changed, 157 insertions(+), 23 deletions(-)

src/all_types.hpp+1-1
......@@ -627,7 +627,7 @@ struct AstNodeParamDecl {
627627 AstNode *type;
628628 Token *var_token;
629629 bool is_noalias;
630 bool is_inline;
630 bool is_comptime;
631631 bool is_var_args;
632632};
633633
src/analyze.cpp+5-2
......@@ -1556,7 +1556,7 @@ static ZigType *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *child_sc
15561556 AstNode *param_node = fn_proto->params.at(fn_type_id.next_param_index);
15571557 assert(param_node->type == NodeTypeParamDecl);
15581558
1559 bool param_is_comptime = param_node->data.param_decl.is_inline;
1559 bool param_is_comptime = param_node->data.param_decl.is_comptime;
15601560 bool param_is_var_args = param_node->data.param_decl.is_var_args;
15611561
15621562 if (param_is_comptime) {
......@@ -8234,6 +8234,10 @@ static void resolve_llvm_types_anyerror(CodeGen *g) {
82348234}
82358235
82368236static void resolve_llvm_types_async_frame(CodeGen *g, ZigType *frame_type, ResolveStatus wanted_resolve_status) {
8237 Error err;
8238 if ((err = type_resolve(g, frame_type, ResolveStatusSizeKnown)))
8239 zig_unreachable();
8240
82378241 ZigType *passed_frame_type = fn_is_async(frame_type->data.frame.fn) ? frame_type : nullptr;
82388242 resolve_llvm_types_struct(g, frame_type->data.frame.locals_struct, wanted_resolve_status, passed_frame_type);
82398243 frame_type->llvm_type = frame_type->data.frame.locals_struct->llvm_type;
......@@ -8375,7 +8379,6 @@ static void resolve_llvm_types_any_frame(CodeGen *g, ZigType *any_frame_type, Re
83758379}
83768380
83778381static void resolve_llvm_types(CodeGen *g, ZigType *type, ResolveStatus wanted_resolve_status) {
8378 assert(type->id == ZigTypeIdOpaque || type_is_resolved(type, ResolveStatusSizeKnown));
83798382 assert(wanted_resolve_status > ResolveStatusSizeKnown);
83808383 switch (type->id) {
83818384 case ZigTypeIdInvalid:
src/ast_render.cpp+1-1
......@@ -448,7 +448,7 @@ static void render_node_extra(AstRender *ar, AstNode *node, bool grouped) {
448448 assert(param_decl->type == NodeTypeParamDecl);
449449 if (param_decl->data.param_decl.name != nullptr) {
450450 const char *noalias_str = param_decl->data.param_decl.is_noalias ? "noalias " : "";
451 const char *inline_str = param_decl->data.param_decl.is_inline ? "inline " : "";
451 const char *inline_str = param_decl->data.param_decl.is_comptime ? "comptime " : "";
452452 fprintf(ar->f, "%s%s", noalias_str, inline_str);
453453 print_symbol(ar, param_decl->data.param_decl.name);
454454 fprintf(ar->f, ": ");
src/codegen.cpp+5-2
......@@ -6340,9 +6340,12 @@ static LLVMValueRef gen_const_val(CodeGen *g, ConstExprValue *const_val, const c
63406340 ZigType *type_entry = const_val->type;
63416341 assert(type_has_bits(type_entry));
63426342
6343 switch (const_val->special) {
6343check: switch (const_val->special) {
63446344 case ConstValSpecialLazy:
6345 zig_unreachable();
6345 if ((err = ir_resolve_lazy(g, nullptr, const_val))) {
6346 report_errors_and_exit(g);
6347 }
6348 goto check;
63466349 case ConstValSpecialRuntime:
63476350 zig_unreachable();
63486351 case ConstValSpecialUndef:
src/ir.cpp+68-15
......@@ -9012,7 +9012,42 @@ static bool ir_num_lit_fits_in_other_type(IrAnalyze *ira, IrInstruction *instruc
90129012 return false;
90139013 }
90149014
9015 ConstExprValue *const_val = ir_resolve_const(ira, instruction, UndefBad);
9015 ConstExprValue *const_val = ir_resolve_const(ira, instruction, LazyOkNoUndef);
9016 if (const_val == nullptr)
9017 return false;
9018
9019 if (const_val->special == ConstValSpecialLazy) {
9020 switch (const_val->data.x_lazy->id) {
9021 case LazyValueIdAlignOf: {
9022 // This is guaranteed to fit into a u29
9023 if (other_type->id == ZigTypeIdComptimeInt)
9024 return true;
9025 size_t align_bits = get_align_amt_type(ira->codegen)->data.integral.bit_count;
9026 if (other_type->id == ZigTypeIdInt && !other_type->data.integral.is_signed &&
9027 other_type->data.integral.bit_count >= align_bits)
9028 {
9029 return true;
9030 }
9031 break;
9032 }
9033 case LazyValueIdSizeOf: {
9034 // This is guaranteed to fit into a usize
9035 if (other_type->id == ZigTypeIdComptimeInt)
9036 return true;
9037 size_t usize_bits = ira->codegen->builtin_types.entry_usize->data.integral.bit_count;
9038 if (other_type->id == ZigTypeIdInt && !other_type->data.integral.is_signed &&
9039 other_type->data.integral.bit_count >= usize_bits)
9040 {
9041 return true;
9042 }
9043 break;
9044 }
9045 default:
9046 break;
9047 }
9048 }
9049
9050 const_val = ir_resolve_const(ira, instruction, UndefBad);
90169051 if (const_val == nullptr)
90179052 return false;
90189053
......@@ -10262,7 +10297,7 @@ static void copy_const_val(ConstExprValue *dest, ConstExprValue *src, bool same_
1026210297 memcpy(dest, src, sizeof(ConstExprValue));
1026310298 if (!same_global_refs) {
1026410299 dest->global_refs = global_refs;
10265 if (src->special == ConstValSpecialUndef)
10300 if (src->special != ConstValSpecialStatic)
1026610301 return;
1026710302 if (dest->type->id == ZigTypeIdStruct) {
1026810303 dest->data.x_struct.fields = create_const_vals(dest->type->data.structure.src_field_count);
......@@ -11213,7 +11248,7 @@ static IrInstruction *ir_get_ref(IrAnalyze *ira, IrInstruction *source_instructi
1121311248 return ira->codegen->invalid_instruction;
1121411249
1121511250 if (instr_is_comptime(value)) {
11216 ConstExprValue *val = ir_resolve_const(ira, value, UndefOk);
11251 ConstExprValue *val = ir_resolve_const(ira, value, LazyOk);
1121711252 if (!val)
1121811253 return ira->codegen->invalid_instruction;
1121911254 return ir_get_const_ptr(ira, source_instruction, val, value->value.type,
......@@ -12125,7 +12160,8 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
1212512160 if (wanted_type->id == ZigTypeIdComptimeInt || wanted_type->id == ZigTypeIdInt) {
1212612161 IrInstruction *result = ir_const(ira, source_instr, wanted_type);
1212712162 if (actual_type->id == ZigTypeIdComptimeInt || actual_type->id == ZigTypeIdInt) {
12128 bigint_init_bigint(&result->value.data.x_bigint, &value->value.data.x_bigint);
12163 copy_const_val(&result->value, &value->value, false);
12164 result->value.type = wanted_type;
1212912165 } else {
1213012166 float_init_bigint(&result->value.data.x_bigint, &value->value);
1213112167 }
......@@ -15301,7 +15337,7 @@ static bool ir_analyze_fn_call_generic_arg(IrAnalyze *ira, AstNode *fn_proto_nod
1530115337 }
1530215338 }
1530315339
15304 bool comptime_arg = param_decl_node->data.param_decl.is_inline ||
15340 bool comptime_arg = param_decl_node->data.param_decl.is_comptime ||
1530515341 casted_arg->value.type->id == ZigTypeIdComptimeInt || casted_arg->value.type->id == ZigTypeIdComptimeFloat;
1530615342
1530715343 ConstExprValue *arg_val;
......@@ -17594,6 +17630,11 @@ static IrInstruction *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstruc
1759417630 ConstExprValue *child_val = const_ptr_pointee(ira, ira->codegen, container_ptr_val, source_node);
1759517631 if (child_val == nullptr)
1759617632 return ira->codegen->invalid_instruction;
17633 if ((err = ir_resolve_const_val(ira->codegen, ira->new_irb.exec,
17634 field_ptr_instruction->base.source_node, child_val, UndefBad)))
17635 {
17636 return ira->codegen->invalid_instruction;
17637 }
1759717638 ZigType *child_type = child_val->data.x_type;
1759817639
1759917640 if (type_is_invalid(child_type)) {
......@@ -21293,8 +21334,10 @@ static IrInstruction *ir_analyze_instruction_from_bytes(IrAnalyze *ira, IrInstru
2129321334 src_ptr_align = get_abi_alignment(ira->codegen, target->value.type);
2129421335 }
2129521336
21296 if ((err = type_resolve(ira->codegen, dest_child_type, ResolveStatusSizeKnown)))
21297 return ira->codegen->invalid_instruction;
21337 if (src_ptr_align != 0) {
21338 if ((err = type_resolve(ira->codegen, dest_child_type, ResolveStatusAlignmentKnown)))
21339 return ira->codegen->invalid_instruction;
21340 }
2129821341
2129921342 ZigType *dest_ptr_type = get_pointer_to_type_extra(ira->codegen, dest_child_type,
2130021343 src_ptr_const, src_ptr_volatile, PtrLenUnknown,
......@@ -21337,6 +21380,8 @@ static IrInstruction *ir_analyze_instruction_from_bytes(IrAnalyze *ira, IrInstru
2133721380 }
2133821381
2133921382 if (have_known_len) {
21383 if ((err = type_resolve(ira->codegen, dest_child_type, ResolveStatusSizeKnown)))
21384 return ira->codegen->invalid_instruction;
2134021385 uint64_t child_type_size = type_size(ira->codegen, dest_child_type);
2134121386 uint64_t remainder = known_len % child_type_size;
2134221387 if (remainder != 0) {
......@@ -23963,15 +24008,23 @@ static IrInstruction *ir_analyze_instruction_ptr_type(IrAnalyze *ira, IrInstruct
2396324008}
2396424009
2396524010static IrInstruction *ir_analyze_instruction_align_cast(IrAnalyze *ira, IrInstructionAlignCast *instruction) {
23966 uint32_t align_bytes;
23967 IrInstruction *align_bytes_inst = instruction->align_bytes->child;
23968 if (!ir_resolve_align(ira, align_bytes_inst, nullptr, &align_bytes))
23969 return ira->codegen->invalid_instruction;
23970
2397124011 IrInstruction *target = instruction->target->child;
2397224012 if (type_is_invalid(target->value.type))
2397324013 return ira->codegen->invalid_instruction;
2397424014
24015 ZigType *elem_type = nullptr;
24016 if (is_slice(target->value.type)) {
24017 ZigType *slice_ptr_type = target->value.type->data.structure.fields[slice_ptr_index].type_entry;
24018 elem_type = slice_ptr_type->data.pointer.child_type;
24019 } else if (target->value.type->id == ZigTypeIdPointer) {
24020 elem_type = target->value.type->data.pointer.child_type;
24021 }
24022
24023 uint32_t align_bytes;
24024 IrInstruction *align_bytes_inst = instruction->align_bytes->child;
24025 if (!ir_resolve_align(ira, align_bytes_inst, elem_type, &align_bytes))
24026 return ira->codegen->invalid_instruction;
24027
2397524028 IrInstruction *result = ir_align_cast(ira, target, align_bytes, true);
2397624029 if (type_is_invalid(result->value.type))
2397724030 return ira->codegen->invalid_instruction;
......@@ -25644,7 +25697,7 @@ static Error ir_resolve_lazy_raw(AstNode *source_node, ConstExprValue *val) {
2564425697 }
2564525698
2564625699 val->special = ConstValSpecialStatic;
25647 assert(val->type->id == ZigTypeIdComptimeInt);
25700 assert(val->type->id == ZigTypeIdComptimeInt || val->type->id == ZigTypeIdInt);
2564825701 bigint_init_unsigned(&val->data.x_bigint, align_in_bytes);
2564925702 return ErrorNone;
2565025703 }
......@@ -25699,7 +25752,7 @@ static Error ir_resolve_lazy_raw(AstNode *source_node, ConstExprValue *val) {
2569925752 }
2570025753
2570125754 val->special = ConstValSpecialStatic;
25702 assert(val->type->id == ZigTypeIdComptimeInt);
25755 assert(val->type->id == ZigTypeIdComptimeInt || val->type->id == ZigTypeIdInt);
2570325756 bigint_init_unsigned(&val->data.x_bigint, abi_size);
2570425757 return ErrorNone;
2570525758 }
......@@ -25885,7 +25938,7 @@ static Error ir_resolve_lazy_raw(AstNode *source_node, ConstExprValue *val) {
2588525938Error ir_resolve_lazy(CodeGen *codegen, AstNode *source_node, ConstExprValue *val) {
2588625939 Error err;
2588725940 if ((err = ir_resolve_lazy_raw(source_node, val))) {
25888 if (codegen->trace_err != nullptr && !source_node->already_traced_this_node) {
25941 if (codegen->trace_err != nullptr && source_node != nullptr && !source_node->already_traced_this_node) {
2588925942 source_node->already_traced_this_node = true;
2589025943 codegen->trace_err = add_error_note(codegen, codegen->trace_err, source_node,
2589125944 buf_create_from_str("referenced here"));
src/parser.cpp+1-1
......@@ -2075,7 +2075,7 @@ static AstNode *ast_parse_param_decl(ParseContext *pc) {
20752075 res->column = first->start_column;
20762076 res->data.param_decl.name = token_buf(name);
20772077 res->data.param_decl.is_noalias = first->id == TokenIdKeywordNoAlias;
2078 res->data.param_decl.is_inline = first->id == TokenIdKeywordCompTime;
2078 res->data.param_decl.is_comptime = first->id == TokenIdKeywordCompTime;
20792079 return res;
20802080}
20812081
std/mem.zig+9-1
......@@ -117,7 +117,15 @@ pub const Allocator = struct {
117117 const byte_slice = try self.reallocFn(self, ([*]u8)(undefined)[0..0], undefined, byte_count, a);
118118 assert(byte_slice.len == byte_count);
119119 @memset(byte_slice.ptr, undefined, byte_slice.len);
120 return @bytesToSlice(T, @alignCast(a, byte_slice));
120 if (alignment == null) {
121 // TODO This is a workaround for zig not being able to successfully do
122 // @bytesToSlice(T, @alignCast(a, byte_slice)) without resolving alignment of T,
123 // which causes a circular dependency in async functions which try to heap-allocate
124 // their own frame with @Frame(func).
125 return @intToPtr([*]T, @ptrToInt(byte_slice.ptr))[0..n];
126 } else {
127 return @bytesToSlice(T, @alignCast(a, byte_slice));
128 }
121129 }
122130
123131 /// This function requests a new byte size for an existing allocation,
test/compile_errors.zig+2
......@@ -1051,6 +1051,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
10511051 \\const Foo = struct {};
10521052 \\export fn a() void {
10531053 \\ const T = [*c]Foo;
1054 \\ var t: T = undefined;
10541055 \\}
10551056 ,
10561057 "tmp.zig:3:19: error: C pointers cannot point to non-C-ABI-compatible type 'Foo'",
......@@ -2290,6 +2291,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
22902291 "error union operator with non error set LHS",
22912292 \\comptime {
22922293 \\ const z = i32!i32;
2294 \\ var x: z = undefined;
22932295 \\}
22942296 ,
22952297 "tmp.zig:2:15: error: expected error set type, found type 'i32'",
test/stage1/behavior/async_fn.zig+65
......@@ -854,3 +854,68 @@ test "await does not force async if callee is blocking" {
854854 var x = async S.simple();
855855 expect(await x == 1234);
856856}
857
858test "recursive async function" {
859 expect(recursiveAsyncFunctionTest(false).doTheTest() == 55);
860 expect(recursiveAsyncFunctionTest(true).doTheTest() == 55);
861}
862
863fn recursiveAsyncFunctionTest(comptime suspending_implementation: bool) type {
864 return struct {
865 fn fib(allocator: *std.mem.Allocator, x: u32) error{OutOfMemory}!u32 {
866 if (x <= 1) return x;
867
868 if (suspending_implementation) {
869 suspend {
870 resume @frame();
871 }
872 }
873
874 const f1 = try allocator.create(@Frame(fib));
875 defer allocator.destroy(f1);
876
877 const f2 = try allocator.create(@Frame(fib));
878 defer allocator.destroy(f2);
879
880 f1.* = async fib(allocator, x - 1);
881 var f1_awaited = false;
882 errdefer if (!f1_awaited) {
883 _ = await f1;
884 };
885
886 f2.* = async fib(allocator, x - 2);
887 var f2_awaited = false;
888 errdefer if (!f2_awaited) {
889 _ = await f2;
890 };
891
892 var sum: u32 = 0;
893
894 f1_awaited = true;
895 const result_f1 = await f1; // TODO https://github.com/ziglang/zig/issues/3077
896 sum += try result_f1;
897
898 f2_awaited = true;
899 const result_f2 = await f2; // TODO https://github.com/ziglang/zig/issues/3077
900 sum += try result_f2;
901
902 return sum;
903 }
904
905 fn doTheTest() u32 {
906 if (suspending_implementation) {
907 var result: u32 = undefined;
908 _ = async amain(&result);
909 return result;
910 } else {
911 return fib(std.heap.direct_allocator, 10) catch unreachable;
912 }
913 }
914
915 fn amain(result: *u32) void {
916 var x = async fib(std.heap.direct_allocator, 10);
917 const res = await x; // TODO https://github.com/ziglang/zig/issues/3077
918 result.* = res catch unreachable;
919 }
920 };
921}