Commit c42c91ee7c630d47e6adc0a940b5f10bbe04d13a | zig

author	Andrew Kelley <andrew@ziglang.org> 2017-05-26 14:39:18-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2017-05-26 14:39:18-04:00
log	c42c91ee7c630d47e6adc0a940b5f10bbe04d13a
tree	e953816629530d2d532c097cbac3bb846e51763f
parent	fcdd808c5c1b866c2582a17839a53ce7bbbb78d6

fix segfault with array of generic functions

closes #377

5 files changed, 67 insertions(+), 21 deletions(-)

src
- analyze.cpp
- ir.cpp
test
- cases
  - generics.zig
  - var_args.zig
- compile_errors.zig

src/analyze.cpp+12-9

 @@ -1033,10 +1033,10 @@ static TypeTableEntry *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *c
         AstNode *param_node = fn_proto->params.at(fn_type_id.next_param_index);
         assert(param_node->type == NodeTypeParamDecl);
-        bool param_is_inline = param_node->data.param_decl.is_inline;
+        bool param_is_comptime = param_node->data.param_decl.is_inline;
         bool param_is_var_args = param_node->data.param_decl.is_var_args;
-        if (param_is_inline) {
+        if (param_is_comptime) {
             if (fn_type_id.is_extern) {
                 add_node_error(g, param_node,
                         buf_sprintf("comptime parameter not allowed in extern function"));
 @@ -2507,7 +2507,10 @@ bool types_match_const_cast_only(TypeTableEntry *expected_type, TypeTableEntry *
         if (expected_type->data.fn.fn_type_id.is_var_args != actual_type->data.fn.fn_type_id.is_var_args) {
             return false;
         }
-        if (!expected_type->data.fn.fn_type_id.is_var_args &&
+        if (expected_type->data.fn.is_generic != actual_type->data.fn.is_generic) {
+            return false;
+        }
+        if (!expected_type->data.fn.is_generic &&
             actual_type->data.fn.fn_type_id.return_type->id != TypeTableEntryIdUnreachable &&
             !types_match_const_cast_only(
                 expected_type->data.fn.fn_type_id.return_type,
 @@ -2518,12 +2521,12 @@ bool types_match_const_cast_only(TypeTableEntry *expected_type, TypeTableEntry *
         if (expected_type->data.fn.fn_type_id.param_count != actual_type->data.fn.fn_type_id.param_count) {
             return false;
         }
-        for (size_t i = 0; i < expected_type->data.fn.fn_type_id.param_count; i += 1) {
+        if (expected_type->data.fn.fn_type_id.next_param_index != actual_type->data.fn.fn_type_id.next_param_index) {
-            if (i == expected_type->data.fn.fn_type_id.param_count - 1 &&
+            return false;
-                expected_type->data.fn.fn_type_id.is_var_args)
+        }
-            {
+        assert(expected_type->data.fn.is_generic ||
-                continue;
+                expected_type->data.fn.fn_type_id.next_param_index  == expected_type->data.fn.fn_type_id.param_count);
-            }
+        for (size_t i = 0; i < expected_type->data.fn.fn_type_id.next_param_index; i += 1) {
             // note it's reversed for parameters
             FnTypeParamInfo *actual_param_info = &actual_type->data.fn.fn_type_id.param_info[i];
             FnTypeParamInfo *expected_param_info = &expected_type->data.fn.fn_type_id.param_info[i];

src/ir.cpp+8

 @@ -13089,12 +13089,20 @@ static TypeTableEntry *ir_analyze_instruction_fn_proto(IrAnalyze *ira, IrInstruc
             }
         }
         IrInstruction *param_type_value = instruction->param_types[fn_type_id.next_param_index]->other;
+        if (type_is_invalid(param_type_value->value.type))
+            return ira->codegen->builtin_types.entry_invalid;
         FnTypeParamInfo *param_info = &fn_type_id.param_info[fn_type_id.next_param_index];
         param_info->is_noalias = param_node->data.param_decl.is_noalias;
         param_info->type = ir_resolve_type(ira, param_type_value);
         if (type_is_invalid(param_info->type))
             return ira->codegen->builtin_types.entry_invalid;
+        if (param_info->type->id == TypeTableEntryIdVar) {
+            ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
+            out_val->data.x_type = get_generic_fn_type(ira->codegen, &fn_type_id);
+            return ira->codegen->builtin_types.entry_type;
+        }
     }
     IrInstruction *return_type_value = instruction->return_type->other;

test/cases/generics.zig+24-12

 @@ -1,6 +1,6 @@
 const assert = @import("std").debug.assert;
-test "simpleGenericFn" {
+test "simple generic fn" {
     assert(max(i32, 3, -1) == 3);
     assert(max(f32, 0.123, 0.456) == 0.456);
     assert(add(2, 3) == 5);
 @@ -15,7 +15,7 @@ fn add(comptime a: i32, b: i32) -> i32 {
 }
 const the_max = max(u32, 1234, 5678);
-test "compileTimeGenericEval" {
+test "compile time generic eval" {
     assert(the_max == 5678);
 }
 @@ -31,21 +31,22 @@ fn sameButWithFloats(a: f64, b: f64) -> f64 {
     max(f64, a, b)
 }
-test "fnWithInlineArgs" {
+test "fn with comptime args" {
     assert(gimmeTheBigOne(1234, 5678) == 5678);
     assert(shouldCallSameInstance(34, 12) == 34);
     assert(sameButWithFloats(0.43, 0.49) == 0.49);
 }
-test "varParams" {
+test "var params" {
     assert(max_i32(12, 34) == 34);
     assert(max_f64(1.2, 3.4) == 3.4);
 }
-// TODO `_`
+comptime {
-const _1 = assert(max_i32(12, 34) == 34);
+    assert(max_i32(12, 34) == 34);
-const _2 = assert(max_f64(1.2, 3.4) == 3.4);
+    assert(max_f64(1.2, 3.4) == 3.4);
+}
 fn max_var(a: var, b: var) -> @typeOf(a + b) {
     if (a > b) a else b
 @@ -72,7 +73,7 @@ pub fn SmallList(comptime T: type, comptime STATIC_SIZE: usize) -> type {
     }
 }
-test "functionWithReturnTypeType" {
+test "function with return type type" {
     var list: List(i32) = undefined;
     var list2: List(i32) = undefined;
     list.length = 10;
 @@ -82,7 +83,7 @@ test "functionWithReturnTypeType" {
 }
-test "genericStruct" {
+test "generic struct" {
     var a1 = GenNode(i32) {.value = 13, .next = null,};
     var b1 = GenNode(bool) {.value = true, .next = null,};
     assert(a1.value == 13);
 @@ -97,7 +98,7 @@ fn GenNode(comptime T: type) -> type {
     }
 }
-test "constDeclsInStruct" {
+test "const decls in struct" {
     assert(GenericDataThing(3).count_plus_one == 4);
 }
 fn GenericDataThing(comptime count: isize) -> type {
 @@ -107,7 +108,7 @@ fn GenericDataThing(comptime count: isize) -> type {
 }
-test "useGenericParamInGenericParam" {
+test "use generic param in generic param" {
     assert(aGenericFn(i32, 3, 4) == 7);
 }
 fn aGenericFn(comptime T: type, comptime a: T, b: T) -> T {
 @@ -115,7 +116,7 @@ fn aGenericFn(comptime T: type, comptime a: T, b: T) -> T {
 }
-test "genericFnWithImplicitCast" {
+test "generic fn with implicit cast" {
     assert(getFirstByte(u8, []u8 {13}) == 13);
     assert(getFirstByte(u16, []u16 {0, 13}) == 0);
 }
 @@ -123,3 +124,14 @@ fn getByte(ptr: ?&const u8) -> u8 {*??ptr}
 fn getFirstByte(comptime T: type, mem: []const T) -> u8 {
     getByte(@ptrCast(&const u8, &mem[0]))
 }
+const foos = []fn(var) -> bool { foo1, foo2 };
+fn foo1(arg: var) -> bool { arg }
+fn foo2(arg: var) -> bool { !arg }
+test "array of generic fns" {
+    assert(foos[0](true));
+    assert(!foos[1](true));
+}

test/cases/var_args.zig+11

...	@@ -54,3 +54,14 @@ fn extraFn(extra: u32, args: ...) -> usize {	...	@@ -54,3 +54,14 @@ fn extraFn(extra: u32, args: ...) -> usize {
54	}	54	}
55	return args.len;	55	return args.len;
56	}	56	}
		57
		58
		59	const foos = []fn(...) -> bool { foo1, foo2 };
		60
		61	fn foo1(args: ...) -> bool { true }
		62	fn foo2(args: ...) -> bool { false }
		63
		64	test "array of var args functions" {
		65	assert(foos[0]());
		66	assert(!foos[1]());
		67	}

test/compile_errors.zig+12

...	@@ -1904,4 +1904,16 @@ pub fn addCases(cases: &tests.CompileErrorContext) {	...	@@ -1904,4 +1904,16 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
1904	\\}	1904	\\}
1905	,	1905	,
1906	".tmp_source.zig:7:9: error: calling a generic function requires compile-time known function value");	1906	".tmp_source.zig:7:9: error: calling a generic function requires compile-time known function value");
		1907
		1908	cases.add("calling a generic function only known at runtime",
		1909	\\var foos = []fn(var) { foo1, foo2 };
		1910	\\
		1911	\\fn foo1(arg: var) {}
		1912	\\fn foo2(arg: var) {}
		1913	\\
		1914	\\pub fn main() -> %void {
		1915	\\ foos[0](true);
		1916	\\}
		1917	,
		1918	".tmp_source.zig:7:9: error: calling a generic function requires compile-time known function value");
1907	}	1919	}