Commit 400a91e1c644228a66aa1702b9d800f018712105 | zig

author	Alexandros Naskos <alex_naskos@hotmail.com> 2020-05-18 19:15:44+03:00
committer	Alexandros Naskos <alex_naskos@hotmail.com> 2020-05-18 19:15:44+03:00
log	400a91e1c644228a66aa1702b9d800f018712105
tree	e5c6dc1cba4df2235a88681a6273a8d6bb2aed18
parent	37fa418a94fc5da695f8799b6b021b632bb1d500

Add TypeOf resolution of dereferences and struct fields of undefined values

3 files changed, 67 insertions(+), 50 deletions(-)

src
- ir.cpp
test
- stage1
  - behavior
    bugs
    4328.zig
    4328_5305.zig

src/ir.cpp+18-1

 @@ -15406,6 +15406,12 @@ static IrInstGen *ir_get_deref(IrAnalyze *ira, IrInst* source_instruction, IrIns
     }
     if (instr_is_comptime(ptr)) {
         if (ptr->value->special == ConstValSpecialUndef) {
+            // If we are in a TypeOf call, we return an undefined value instead of erroring
+            // since we know the type.
+            if (get_scope_typeof(source_instruction->scope)) {
+                return ir_const_undef(ira, source_instruction, child_type);
+            }
             ir_add_error(ira, &ptr->base, buf_sprintf("attempt to dereference undefined value"));
             return ira->codegen->invalid_inst_gen;
         }
 @@ -19709,7 +19715,7 @@ static IrInstGen *ir_analyze_fn_call(IrAnalyze *ira, IrInst* source_instr,
     if (modifier == CallModifierCompileTime) {
         // If we are evaluating an extern function in a TypeOf call, we can return an undefined value
         // of its return type.
-        if (fn_entry != nullptr && source_instr->scope->id == ScopeIdTypeOf &&
+        if (fn_entry != nullptr && get_scope_typeof(source_instr->scope) != nullptr &&
             fn_proto_node->data.fn_proto.is_extern) {
             assert(fn_entry->body_node == nullptr);
 @@ -21842,6 +21848,11 @@ static IrInstGen *ir_analyze_container_field_ptr(IrAnalyze *ira, Buf *field_name
         return ir_analyze_inferred_field_ptr(ira, field_name, source_instr, container_ptr, bare_type);
     }
+    // Tracks wether we should return an undefined value of the correct type.
+    // We do this if the container pointer is undefined and we are in a TypeOf call.
+    bool return_undef = container_ptr->value->special == ConstValSpecialUndef && \
+                         get_scope_typeof(source_instr->scope) != nullptr;
     if ((err = type_resolve(ira->codegen, bare_type, ResolveStatusZeroBitsKnown)))
         return ira->codegen->invalid_inst_gen;
 @@ -21849,6 +21860,12 @@ static IrInstGen *ir_analyze_container_field_ptr(IrAnalyze *ira, Buf *field_name
     if (bare_type->id == ZigTypeIdStruct) {
         TypeStructField *field = find_struct_type_field(bare_type, field_name);
         if (field != nullptr) {
+            if (return_undef) {
+                ZigType *field_ptr_type = get_pointer_to_type(ira->codegen, resolve_struct_field_type(ira->codegen, field),
+                                                              container_ptr->value->type->data.pointer.is_const);
+                return ir_const_undef(ira, source_instr, field_ptr_type);
+            }
             return ir_analyze_struct_field_ptr(ira, source_instr, field, container_ptr, bare_type, initializing);
         } else {
             return ir_analyze_container_member_access_inner(ira, bare_type, field_name,

test/stage1/behavior/bugs/4328.zig deleted-49

...	@@ -1,49 +0,0 @@
1	const expectEqual = @import("std").testing.expectEqual;
2
3	const FILE = extern struct {
4	dummy_field: u8,
5	};
6	extern fn printf([*c]const u8, ...) c_int;
7	extern fn fputs([c]const u8, noalias [c]FILE) c_int;
8	extern fn ftell([*c]FILE) c_long;
9
10	const S = extern struct {
11	state: c_short,
12
13	extern fn s_do_thing([*c]S, b: c_int) c_short;
14	};
15
16	test "Extern function calls in @TypeOf" {
17	const Test = struct {
18	fn test_fn_1(a: var, b: var) @TypeOf(printf("%d %s\n", a, b)) {
19	return 0;
20	}
21
22	fn test_fn_2(a: var) @TypeOf((S{ .state = 0 }).s_do_thing(a)) {
23	return 1;
24	}
25
26	fn doTheTest() void {
27	expectEqual(c_int, @TypeOf(test_fn_1(0, 42)));
28	expectEqual(c_short, @TypeOf(test_fn_2(0)));
29	}
30	};
31
32	Test.doTheTest();
33	comptime Test.doTheTest();
34	}
35
36	test "Peer resolution of extern function calls in @TypeOf" {
37	const Test = struct {
38	fn test_fn() @TypeOf(ftell(null), fputs(null, null)) {
39	return 0;
40	}
41
42	fn doTheTest() void {
43	expectEqual(c_long, @TypeOf(test_fn()));
44	}
45	};
46
47	Test.doTheTest();
48	comptime Test.doTheTest();
49	}

test/stage1/behavior/bugs/4328_5305.zig created+49

...	@@ -0,0 +1,49 @@
1	const expectEqual = @import("std").testing.expectEqual;
2
3	const FILE = extern struct {
4	dummy_field: u8,
5	};
6	extern fn printf([*c]const u8, ...) c_int;
7	extern fn fputs([c]const u8, noalias [c]FILE) c_int;
8	extern fn ftell([*c]FILE) c_long;
9
10	const S = extern struct {
11	state: c_short,
12
13	extern fn s_do_thing([*c]S, b: c_int) c_short;
14	};
15
16	test "Extern function calls in @TypeOf" {
17	const Test = struct {
18	fn test_fn_1(a: var, b: var) @TypeOf(printf("%d %s\n", a, b)) {
19	return 0;
20	}
21
22	fn test_fn_2(a: var) @TypeOf((S{ .state = 0 }).s_do_thing(a)) {
23	return 1;
24	}
25
26	fn doTheTest() void {
27	expectEqual(c_int, @TypeOf(test_fn_1(0, 42)));
28	expectEqual(c_short, @TypeOf(test_fn_2(0)));
29	}
30	};
31
32	Test.doTheTest();
33	comptime Test.doTheTest();
34	}
35
36	test "Peer resolution of extern function calls in @TypeOf" {
37	const Test = struct {
38	fn test_fn() @TypeOf(ftell(null), fputs(null, null)) {
39	return 0;
40	}
41
42	fn doTheTest() void {
43	expectEqual(c_long, @TypeOf(test_fn()));
44	}
45	};
46
47	Test.doTheTest();
48	comptime Test.doTheTest();
49	}