Commit 84549b42678fa1f2755b2ec7bf4f4936d8f513af | zig

author	LemonBoy <thatlemon@gmail.com> 2020-12-19 22:27:24+01:00
committer	Andrew Kelley <andrew@ziglang.org> 2020-12-19 19:45:48-05:00
log	84549b42678fa1f2755b2ec7bf4f4936d8f513af
tree	6d1b3222ce827cc7e166f6cc15b6d81d4421b8c8
parent	dd7b816d98840f26988c993eda9be21fa9b0ab50

stage1: Fix for generic fn monomorphization

Don't use the instantiation argument types to build the function
parameter array.

f416535768fc30195cad6cd481f73fd1e80082aa worked around the problem, this
commit solves it.

3 files changed, 27 insertions(+), 5 deletions(-)

lib
- std
  - crypto
    tlcsprng.zig
src
- stage1
  - ir.cpp
test
- stage1
  - behavior
    generics.zig

lib/std/crypto/tlcsprng.zig+1-3

 @@ -117,9 +117,7 @@ fn setupPthreadAtforkAndFill(buffer: []u8) void {
 }
 fn childAtForkHandler() callconv(.C) void {
-    // TODO this is a workaround for https://github.com/ziglang/zig/issues/7495
+    const wipe_slice = @ptrCast([*]u8, &wipe_me)[0..@sizeOf(@TypeOf(wipe_me))];
-    var wipe_slice: []u8 = undefined;
-    wipe_slice = @ptrCast([*]u8, &wipe_me)[0..@sizeOf(@TypeOf(wipe_me))];
     std.crypto.utils.secureZero(u8, wipe_slice);
 }

src/stage1/ir.cpp+7-1

 @@ -20226,9 +20226,12 @@ static bool ir_analyze_fn_call_generic_arg(IrAnalyze *ira, AstNode *fn_proto_nod
     bool is_var_args = param_decl_node->data.param_decl.is_var_args;
     bool arg_part_of_generic_id = false;
     IrInstGen *casted_arg;
+    ZigType *param_info_type = nullptr;
     if (is_var_args) {
         arg_part_of_generic_id = true;
         casted_arg = arg;
+        param_info_type = arg->value->type;
     } else {
         if (param_decl_node->data.param_decl.anytype_token == nullptr) {
             AstNode *param_type_node = param_decl_node->data.param_decl.type;
 @@ -20239,9 +20242,12 @@ static bool ir_analyze_fn_call_generic_arg(IrAnalyze *ira, AstNode *fn_proto_nod
             casted_arg = ir_implicit_cast2(ira, arg_src, arg, param_type);
             if (type_is_invalid(casted_arg->value->type))
                 return false;
+            param_info_type = param_type;
         } else {
             arg_part_of_generic_id = true;
             casted_arg = arg;
+            param_info_type = arg->value->type;
         }
     }
 @@ -20298,7 +20304,7 @@ static bool ir_analyze_fn_call_generic_arg(IrAnalyze *ira, AstNode *fn_proto_nod
     if (!comptime_arg) {
         casted_args[fn_type_id->param_count] = casted_arg;
         FnTypeParamInfo *param_info = &fn_type_id->param_info[fn_type_id->param_count];
-        param_info->type = casted_arg->value->type;
+        param_info->type = param_info_type;
         param_info->is_noalias = param_decl_node->data.param_decl.is_noalias;
         impl_fn->param_source_nodes[fn_type_id->param_count] = param_decl_node;
         fn_type_id->param_count += 1;

test/stage1/behavior/generics.zig+19-1

...	@@ -1,4 +1,7 @@	...	@@ -1,4 +1,7 @@
1	const expect = @import("std").testing.expect;	1	const std = @import("std");
		2	const testing = std.testing;
		3	const expect = testing.expect;
		4	const expectEqual = testing.expectEqual;
2		5
3	test "simple generic fn" {	6	test "simple generic fn" {
4	expect(max(i32, 3, -1) == 3);	7	expect(max(i32, 3, -1) == 3);
...	@@ -149,3 +152,18 @@ test "array of generic fns" {	...	@@ -149,3 +152,18 @@ test "array of generic fns" {
149	expect(foos[0](true));	152	expect(foos[0](true));
150	expect(!foos[1](true));	153	expect(!foos[1](true));
151	}	154	}
		155
		156	test "generic fn keeps non-generic parameter types" {
		157	const A = 128;
		158
		159	const S = struct {
		160	fn f(comptime T: type, s: []T) void {
		161	expect(A != @typeInfo(@TypeOf(s)).Pointer.alignment);
		162	}
		163	};
		164
		165	// The compiler monomorphizes `S.f` for `T=u8` on its first use, check that
		166	// `x` type not affect `s` parameter type.
		167	var x: [16]u8 align(A) = undefined;
		168	S.f(u8, &x);
		169	}