authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2017-01-23 16:40:17-05:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2017-01-23 16:40:17-05:00
log17cb85dfb837949cd3a559fe8e99dee1f72463a4
treea35d23e26938586ba0fb706964e2b7c2b4b894f7
parent1826a961608037405237f12df5aec94f8f5f3a10

basic support for functions with variable length arguments

See #77

11 files changed, 257 insertions(+), 63 deletions(-)

doc/langref.md+1-1
......@@ -33,7 +33,7 @@ FnDef = option("inline" | "extern") FnProto Block
3333
3434ParamDeclList = "(" list(ParamDecl, ",") ")"
3535
36ParamDecl = option("noalias" | "comptime") option(Symbol ":") TypeExpr | "..."
36ParamDecl = option("noalias" | "comptime") option(Symbol ":") (TypeExpr | "...")
3737
3838Block = "{" list(option(Statement), ";") "}"
3939
src/all_types.hpp+11
......@@ -122,6 +122,11 @@ struct ConstBoundFnValue {
122122 IrInstruction *first_arg;
123123};
124124
125struct ConstArgTuple {
126 size_t start_index;
127 size_t end_index;
128};
129
125130enum ConstValSpecial {
126131 ConstValSpecialRuntime,
127132 ConstValSpecialStatic,
......@@ -163,6 +168,7 @@ struct ConstExprValue {
163168 ConstPtrValue x_ptr;
164169 ImportTableEntry *x_import;
165170 Scope *x_block;
171 ConstArgTuple x_arg_tuple;
166172
167173 // populated if special == ConstValSpecialRuntime
168174 RuntimeHintErrorUnion rh_error_union;
......@@ -325,6 +331,7 @@ struct AstNodeParamDecl {
325331 AstNode *type;
326332 bool is_noalias;
327333 bool is_inline;
334 bool is_var_args;
328335};
329336
330337struct AstNodeBlock {
......@@ -936,6 +943,7 @@ enum TypeTableEntryId {
936943 TypeTableEntryIdNamespace,
937944 TypeTableEntryIdBlock,
938945 TypeTableEntryIdBoundFn,
946 TypeTableEntryIdArgTuple,
939947};
940948
941949struct TypeTableEntry {
......@@ -1034,6 +1042,8 @@ struct FnTableEntry {
10341042
10351043 ZigList<IrInstruction *> alloca_list;
10361044 ZigList<VariableTableEntry *> variable_list;
1045
1046 VariableTableEntry *var_args_var;
10371047};
10381048
10391049uint32_t fn_table_entry_hash(FnTableEntry*);
......@@ -1155,6 +1165,7 @@ struct CodeGen {
11551165 TypeTableEntry *entry_environ_enum;
11561166 TypeTableEntry *entry_oformat_enum;
11571167 TypeTableEntry *entry_atomic_order_enum;
1168 TypeTableEntry *entry_arg_tuple;
11581169 } builtin_types;
11591170
11601171 ZigTarget zig_target;
src/analyze.cpp+52-10
......@@ -208,6 +208,7 @@ bool type_is_complete(TypeTableEntry *type_entry) {
208208 case TypeTableEntryIdBlock:
209209 case TypeTableEntryIdBoundFn:
210210 case TypeTableEntryIdEnumTag:
211 case TypeTableEntryIdArgTuple:
211212 return true;
212213 }
213214 zig_unreachable();
......@@ -245,6 +246,7 @@ bool type_has_zero_bits_known(TypeTableEntry *type_entry) {
245246 case TypeTableEntryIdBlock:
246247 case TypeTableEntryIdBoundFn:
247248 case TypeTableEntryIdEnumTag:
249 case TypeTableEntryIdArgTuple:
248250 return true;
249251 }
250252 zig_unreachable();
......@@ -921,6 +923,7 @@ static TypeTableEntry *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *c
921923 assert(param_node->type == NodeTypeParamDecl);
922924
923925 bool param_is_inline = param_node->data.param_decl.is_inline;
926 bool param_is_var_args = param_node->data.param_decl.is_var_args;
924927
925928 if (param_is_inline) {
926929 if (fn_type_id.is_extern) {
......@@ -929,6 +932,13 @@ static TypeTableEntry *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *c
929932 return g->builtin_types.entry_invalid;
930933 }
931934 return get_generic_fn_type(g, &fn_type_id);
935 } else if (param_is_var_args) {
936 if (fn_type_id.is_extern) {
937 fn_type_id.param_count = fn_type_id.next_param_index;
938 continue;
939 } else {
940 return get_generic_fn_type(g, &fn_type_id);
941 }
932942 }
933943
934944 TypeTableEntry *type_entry = analyze_type_expr(g, child_scope, param_node->data.param_decl.type);
......@@ -939,6 +949,7 @@ static TypeTableEntry *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *c
939949 case TypeTableEntryIdUnreachable:
940950 case TypeTableEntryIdUndefLit:
941951 case TypeTableEntryIdNullLit:
952 case TypeTableEntryIdArgTuple:
942953 add_node_error(g, param_node->data.param_decl.type,
943954 buf_sprintf("parameter of type '%s' not allowed", buf_ptr(&type_entry->name)));
944955 return g->builtin_types.entry_invalid;
......@@ -989,6 +1000,7 @@ static TypeTableEntry *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *c
9891000
9901001 case TypeTableEntryIdUndefLit:
9911002 case TypeTableEntryIdNullLit:
1003 case TypeTableEntryIdArgTuple:
9921004 add_node_error(g, fn_proto->return_type,
9931005 buf_sprintf("return type '%s' not allowed", buf_ptr(&fn_type_id.return_type->name)));
9941006 return g->builtin_types.entry_invalid;
......@@ -1558,13 +1570,6 @@ static void resolve_decl_fn(CodeGen *g, TldFn *tld_fn) {
15581570
15591571 AstNode *fn_def_node = fn_proto->fn_def_node;
15601572
1561 if (fn_def_node && fn_proto->is_var_args) {
1562 add_node_error(g, proto_node,
1563 buf_sprintf("variadic arguments only allowed in extern function declarations"));
1564 tld_fn->base.resolution = TldResolutionInvalid;
1565 return;
1566 }
1567
15681573 FnTableEntry *fn_table_entry = create_fn(tld_fn->base.source_node);
15691574 get_fully_qualified_decl_name(&fn_table_entry->symbol_name, &tld_fn->base, '_');
15701575
......@@ -1799,6 +1804,7 @@ TypeTableEntry *validate_var_type(CodeGen *g, AstNode *source_node, TypeTableEnt
17991804 case TypeTableEntryIdUndefLit:
18001805 case TypeTableEntryIdNullLit:
18011806 case TypeTableEntryIdBlock:
1807 case TypeTableEntryIdArgTuple:
18021808 add_node_error(g, source_node, buf_sprintf("variable of type '%s' not allowed",
18031809 buf_ptr(&underlying_type->name)));
18041810 return g->builtin_types.entry_invalid;
......@@ -2210,6 +2216,7 @@ static bool is_container(TypeTableEntry *type_entry) {
22102216 case TypeTableEntryIdBlock:
22112217 case TypeTableEntryIdBoundFn:
22122218 case TypeTableEntryIdEnumTag:
2219 case TypeTableEntryIdArgTuple:
22132220 return false;
22142221 }
22152222 zig_unreachable();
......@@ -2260,6 +2267,7 @@ void resolve_container_type(CodeGen *g, TypeTableEntry *type_entry) {
22602267 case TypeTableEntryIdInvalid:
22612268 case TypeTableEntryIdVar:
22622269 case TypeTableEntryIdEnumTag:
2270 case TypeTableEntryIdArgTuple:
22632271 zig_unreachable();
22642272 }
22652273}
......@@ -2290,7 +2298,13 @@ void define_local_param_variables(CodeGen *g, FnTableEntry *fn_table_entry, Vari
22902298 for (size_t i = 0; i < fn_type_id->param_count; i += 1) {
22912299 FnTypeParamInfo *param_info = &fn_type_id->param_info[i];
22922300 AstNode *param_decl_node = get_param_decl_node(fn_table_entry, i);
2293 Buf *param_name = param_decl_node ? param_decl_node->data.param_decl.name : buf_sprintf("arg%zu", i);
2301 Buf *param_name;
2302 bool is_var_args = param_decl_node && param_decl_node->data.param_decl.is_var_args;
2303 if (param_decl_node && !is_var_args) {
2304 param_name = param_decl_node->data.param_decl.name;
2305 } else {
2306 param_name = buf_sprintf("arg%zu", i);
2307 }
22942308
22952309 TypeTableEntry *param_type = param_info->type;
22962310 bool is_noalias = param_info->is_noalias;
......@@ -2308,6 +2322,7 @@ void define_local_param_variables(CodeGen *g, FnTableEntry *fn_table_entry, Vari
23082322 param_name, true, create_const_runtime(param_type));
23092323 var->src_arg_index = i;
23102324 fn_table_entry->child_scope = var->child_scope;
2325 var->shadowable = var->shadowable || is_var_args;
23112326
23122327 if (type_has_bits(param_type)) {
23132328 fn_table_entry->variable_list.append(var);
......@@ -2627,6 +2642,7 @@ bool handle_is_ptr(TypeTableEntry *type_entry) {
26272642 case TypeTableEntryIdBlock:
26282643 case TypeTableEntryIdBoundFn:
26292644 case TypeTableEntryIdVar:
2645 case TypeTableEntryIdArgTuple:
26302646 zig_unreachable();
26312647 case TypeTableEntryIdUnreachable:
26322648 case TypeTableEntryIdVoid:
......@@ -2742,6 +2758,9 @@ static uint32_t hash_const_val(ConstExprValue *const_val) {
27422758 case TypeTableEntryIdFloat:
27432759 case TypeTableEntryIdNumLitFloat:
27442760 return const_val->data.x_bignum.data.x_float * UINT32_MAX;
2761 case TypeTableEntryIdArgTuple:
2762 return const_val->data.x_arg_tuple.start_index * 281907309 +
2763 const_val->data.x_arg_tuple.end_index * 2290442768;
27452764 case TypeTableEntryIdPointer:
27462765 return hash_ptr(const_val->data.x_ptr.base_ptr) + hash_size(const_val->data.x_ptr.index);
27472766 case TypeTableEntryIdUndefLit:
......@@ -2805,7 +2824,7 @@ uint32_t generic_fn_type_id_hash(GenericFnTypeId *id) {
28052824bool generic_fn_type_id_eql(GenericFnTypeId *a, GenericFnTypeId *b) {
28062825 assert(a->fn_entry);
28072826 if (a->fn_entry != b->fn_entry) return false;
2808 assert(a->param_count == b->param_count);
2827 if (a->param_count != b->param_count) return false;
28092828 for (size_t i = 0; i < a->param_count; i += 1) {
28102829 ConstExprValue *a_val = &a->params[i];
28112830 ConstExprValue *b_val = &b->params[i];
......@@ -2904,6 +2923,7 @@ static TypeTableEntry *type_of_first_thing_in_memory(TypeTableEntry *type_entry)
29042923 case TypeTableEntryIdBlock:
29052924 case TypeTableEntryIdBoundFn:
29062925 case TypeTableEntryIdVar:
2926 case TypeTableEntryIdArgTuple:
29072927 zig_unreachable();
29082928 case TypeTableEntryIdArray:
29092929 return type_of_first_thing_in_memory(type_entry->data.array.child_type);
......@@ -2946,6 +2966,7 @@ bool type_requires_comptime(TypeTableEntry *type_entry) {
29462966 case TypeTableEntryIdNamespace:
29472967 case TypeTableEntryIdBlock:
29482968 case TypeTableEntryIdBoundFn:
2969 case TypeTableEntryIdArgTuple:
29492970 return true;
29502971 case TypeTableEntryIdArray:
29512972 case TypeTableEntryIdStruct:
......@@ -3155,6 +3176,20 @@ ConstExprValue *create_const_ptr(CodeGen *g, ConstExprValue *base_ptr, size_t in
31553176 return const_val;
31563177}
31573178
3179void init_const_arg_tuple(CodeGen *g, ConstExprValue *const_val, size_t arg_index_start, size_t arg_index_end) {
3180 const_val->special = ConstValSpecialStatic;
3181 const_val->type = g->builtin_types.entry_arg_tuple;
3182 const_val->data.x_arg_tuple.start_index = arg_index_start;
3183 const_val->data.x_arg_tuple.end_index = arg_index_end;
3184}
3185
3186ConstExprValue *create_const_arg_tuple(CodeGen *g, size_t arg_index_start, size_t arg_index_end) {
3187 ConstExprValue *const_val = allocate<ConstExprValue>(1);
3188 init_const_arg_tuple(g, const_val, arg_index_start, arg_index_end);
3189 return const_val;
3190}
3191
3192
31583193void ensure_complete_type(CodeGen *g, TypeTableEntry *type_entry) {
31593194 if (type_entry->id == TypeTableEntryIdStruct) {
31603195 if (!type_entry->data.structure.complete)
......@@ -3245,6 +3280,9 @@ bool const_values_equal(ConstExprValue *a, ConstExprValue *b) {
32453280 return a->data.x_import == b->data.x_import;
32463281 case TypeTableEntryIdBlock:
32473282 return a->data.x_block == b->data.x_block;
3283 case TypeTableEntryIdArgTuple:
3284 return a->data.x_arg_tuple.start_index == b->data.x_arg_tuple.start_index &&
3285 a->data.x_arg_tuple.end_index == b->data.x_arg_tuple.end_index;
32483286 case TypeTableEntryIdBoundFn:
32493287 case TypeTableEntryIdInvalid:
32503288 case TypeTableEntryIdUnreachable:
......@@ -3506,7 +3544,11 @@ void render_const_value(Buf *buf, ConstExprValue *const_val) {
35063544 buf_appendf(buf, "%s.%s", buf_ptr(&enum_type->name), buf_ptr(field->name));
35073545 return;
35083546 }
3547 case TypeTableEntryIdArgTuple:
3548 {
3549 buf_appendf(buf, "(args value)");
3550 return;
3551 }
35093552 }
35103553 zig_unreachable();
35113554}
3512
src/analyze.hpp+3
......@@ -133,4 +133,7 @@ void init_const_slice(CodeGen *g, ConstExprValue *const_val, ConstExprValue *arr
133133 size_t start, size_t len, bool is_const);
134134ConstExprValue *create_const_slice(CodeGen *g, ConstExprValue *array_val, size_t start, size_t len, bool is_const);
135135
136void init_const_arg_tuple(CodeGen *g, ConstExprValue *const_val, size_t arg_index_start, size_t arg_index_end);
137ConstExprValue *create_const_arg_tuple(CodeGen *g, size_t arg_index_start, size_t arg_index_end);
138
136139#endif
src/ast_render.cpp+6-6
......@@ -393,7 +393,6 @@ static void render_node_extra(AstRender *ar, AstNode *node, bool grouped) {
393393 print_symbol(ar, node->data.fn_proto.name);
394394 fprintf(ar->f, "(");
395395 int arg_count = node->data.fn_proto.params.length;
396 bool is_var_args = node->data.fn_proto.is_var_args;
397396 for (int arg_i = 0; arg_i < arg_count; arg_i += 1) {
398397 AstNode *param_decl = node->data.fn_proto.params.at(arg_i);
399398 assert(param_decl->type == NodeTypeParamDecl);
......@@ -404,15 +403,16 @@ static void render_node_extra(AstRender *ar, AstNode *node, bool grouped) {
404403 print_symbol(ar, param_decl->data.param_decl.name);
405404 fprintf(ar->f, ": ");
406405 }
407 render_node_grouped(ar, param_decl->data.param_decl.type);
406 if (param_decl->data.param_decl.is_var_args) {
407 fprintf(ar->f, "...");
408 } else {
409 render_node_grouped(ar, param_decl->data.param_decl.type);
410 }
408411
409 if (arg_i + 1 < arg_count || is_var_args) {
412 if (arg_i + 1 < arg_count) {
410413 fprintf(ar->f, ", ");
411414 }
412415 }
413 if (is_var_args) {
414 fprintf(ar->f, "...");
415 }
416416 fprintf(ar->f, ")");
417417
418418 AstNode *return_type_node = node->data.fn_proto.return_type;
src/codegen.cpp+8
......@@ -2636,6 +2636,7 @@ static LLVMValueRef gen_const_val(CodeGen *g, ConstExprValue *const_val) {
26362636 case TypeTableEntryIdBlock:
26372637 case TypeTableEntryIdBoundFn:
26382638 case TypeTableEntryIdVar:
2639 case TypeTableEntryIdArgTuple:
26392640 zig_unreachable();
26402641
26412642 }
......@@ -3179,6 +3180,12 @@ static void define_builtin_types(CodeGen *g) {
31793180 buf_init_from_str(&entry->name, "(var)");
31803181 g->builtin_types.entry_var = entry;
31813182 }
3183 {
3184 TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdArgTuple);
3185 buf_init_from_str(&entry->name, "(args)");
3186 entry->zero_bits = true;
3187 g->builtin_types.entry_arg_tuple = entry;
3188 }
31823189
31833190 for (size_t int_size_i = 0; int_size_i < array_length(int_sizes_in_bits); int_size_i += 1) {
31843191 size_t size_in_bits = int_sizes_in_bits[int_size_i];
......@@ -3947,6 +3954,7 @@ static void get_c_type(CodeGen *g, TypeTableEntry *type_entry, Buf *out_buf) {
39473954 case TypeTableEntryIdUndefLit:
39483955 case TypeTableEntryIdNullLit:
39493956 case TypeTableEntryIdVar:
3957 case TypeTableEntryIdArgTuple:
39503958 zig_unreachable();
39513959 }
39523960}
src/ir.cpp+120-29
......@@ -4347,8 +4347,7 @@ static IrInstruction *ir_gen_for_expr(IrBuilder *irb, Scope *parent_scope, AstNo
43474347
43484348 IrInstruction *array_val = ir_build_load_ptr(irb, parent_scope, array_node, array_val_ptr);
43494349
4350 IrInstruction *array_type = ir_build_typeof(irb, parent_scope, array_node, array_val);
4351 IrInstruction *pointer_type = ir_build_to_ptr_type(irb, parent_scope, array_node, array_type);
4350 IrInstruction *pointer_type = ir_build_to_ptr_type(irb, parent_scope, array_node, array_val);
43524351 IrInstruction *elem_var_type;
43534352 if (node->data.for_expr.elem_is_ptr) {
43544353 elem_var_type = pointer_type;
......@@ -6887,6 +6886,7 @@ static TypeTableEntry *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp
68876886 case TypeTableEntryIdNamespace:
68886887 case TypeTableEntryIdBlock:
68896888 case TypeTableEntryIdBoundFn:
6889 case TypeTableEntryIdArgTuple:
68906890 if (!is_equality_cmp) {
68916891 ir_add_error_node(ira, source_node,
68926892 buf_sprintf("operator not allowed for type '%s'", buf_ptr(&resolved_type->name)));
......@@ -7449,6 +7449,7 @@ static TypeTableEntry *ir_analyze_instruction_decl_var(IrAnalyze *ira, IrInstruc
74497449 case TypeTableEntryIdFn:
74507450 case TypeTableEntryIdBoundFn:
74517451 case TypeTableEntryIdEnumTag:
7452 case TypeTableEntryIdArgTuple:
74527453 // OK
74537454 break;
74547455 }
......@@ -7520,21 +7521,35 @@ static bool ir_analyze_fn_call_generic_arg(IrAnalyze *ira, AstNode *fn_proto_nod
75207521{
75217522 AstNode *param_decl_node = fn_proto_node->data.fn_proto.params.at(*next_proto_i);
75227523 assert(param_decl_node->type == NodeTypeParamDecl);
7523 AstNode *param_type_node = param_decl_node->data.param_decl.type;
7524 TypeTableEntry *param_type = analyze_type_expr(ira->codegen, *child_scope, param_type_node);
7525 if (param_type->id == TypeTableEntryIdInvalid)
7526 return false;
7524 bool is_var_args = param_decl_node->data.param_decl.is_var_args;
7525 bool arg_part_of_generic_id = false;
7526 IrInstruction *casted_arg;
7527 if (is_var_args) {
7528 arg_part_of_generic_id = true;
7529 casted_arg = arg;
7530 } else {
7531 AstNode *param_type_node = param_decl_node->data.param_decl.type;
7532 TypeTableEntry *param_type = analyze_type_expr(ira->codegen, *child_scope, param_type_node);
7533 if (param_type->id == TypeTableEntryIdInvalid)
7534 return false;
75277535
7528 IrInstruction *casted_arg = ir_implicit_cast(ira, arg, param_type);
7529 if (casted_arg->value.type->id == TypeTableEntryIdInvalid)
7530 return false;
7536 bool is_var_type = (param_type->id == TypeTableEntryIdVar);
7537 if (is_var_type) {
7538 arg_part_of_generic_id = true;
7539 casted_arg = arg;
7540 } else {
7541 casted_arg = ir_implicit_cast(ira, arg, param_type);
7542 if (casted_arg->value.type->id == TypeTableEntryIdInvalid)
7543 return false;
7544 }
7545 }
75317546
7532 bool inline_arg = param_decl_node->data.param_decl.is_inline;
7533 bool is_var_type = (param_type->id == TypeTableEntryIdVar);
7547 bool comptime_arg = param_decl_node->data.param_decl.is_inline;
75347548
75357549 ConstExprValue *arg_val;
75367550
7537 if (inline_arg) {
7551 if (comptime_arg) {
7552 arg_part_of_generic_id = true;
75387553 arg_val = ir_resolve_const(ira, casted_arg, UndefBad);
75397554 if (!arg_val)
75407555 return false;
......@@ -7544,26 +7559,41 @@ static bool ir_analyze_fn_call_generic_arg(IrAnalyze *ira, AstNode *fn_proto_nod
75447559 } else {
75457560 arg_val = create_const_runtime(casted_arg->value.type);
75467561 }
7562 if (arg_part_of_generic_id) {
7563 generic_id->params[generic_id->param_count] = *arg_val;
7564 generic_id->param_count += 1;
7565 }
75477566
75487567 Buf *param_name = param_decl_node->data.param_decl.name;
7549 VariableTableEntry *var = add_variable(ira->codegen, param_decl_node,
7550 *child_scope, param_name, true, arg_val);
7551 var->value.depends_on_compile_var = true;
7552 *child_scope = var->child_scope;
7568 if (is_var_args) {
7569 if (!impl_fn->var_args_var) {
7570 ConstExprValue *var_args_val = create_const_arg_tuple(ira->codegen,
7571 fn_type_id->param_count, fn_type_id->param_count + 1);
7572 VariableTableEntry *var = add_variable(ira->codegen, param_decl_node,
7573 *child_scope, param_name, true, var_args_val);
7574 var->value.depends_on_compile_var = true;
7575 *child_scope = var->child_scope;
7576 impl_fn->var_args_var = var;
7577 }
7578 impl_fn->var_args_var->value.data.x_arg_tuple.end_index = fn_type_id->param_count + 1;
75537579
7554 if (inline_arg || is_var_type) {
7555 generic_id->params[generic_id->param_count] = *arg_val;
7556 generic_id->param_count += 1;
7580 } else {
7581 VariableTableEntry *var = add_variable(ira->codegen, param_decl_node,
7582 *child_scope, param_name, true, arg_val);
7583 var->value.depends_on_compile_var = true;
7584 *child_scope = var->child_scope;
7585 var->shadowable = !comptime_arg;
7586
7587 *next_proto_i += 1;
75577588 }
7558 if (!inline_arg) {
7559 if (type_requires_comptime(var->value.type)) {
7560 ir_add_error(ira, arg,
7561 buf_sprintf("parameter of type '%s' not allowed", buf_ptr(&var->value.type->name)));
7589
7590 if (!comptime_arg) {
7591 if (type_requires_comptime(casted_arg->value.type)) {
7592 ir_add_error(ira, casted_arg,
7593 buf_sprintf("parameter of type '%s' requires comptime", buf_ptr(&casted_arg->value.type->name)));
75627594 return false;
75637595 }
75647596
7565 var->shadowable = true;
7566
75677597 casted_args[fn_type_id->param_count] = casted_arg;
75687598 FnTypeParamInfo *param_info = &fn_type_id->param_info[fn_type_id->param_count];
75697599 param_info->type = casted_arg->value.type;
......@@ -7571,7 +7601,7 @@ static bool ir_analyze_fn_call_generic_arg(IrAnalyze *ira, AstNode *fn_proto_nod
75717601 impl_fn->param_source_nodes[fn_type_id->param_count] = param_decl_node;
75727602 fn_type_id->param_count += 1;
75737603 }
7574 *next_proto_i += 1;
7604
75757605 return true;
75767606}
75777607
......@@ -7682,6 +7712,7 @@ static TypeTableEntry *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *cal
76827712 FnTypeId inst_fn_type_id = {0};
76837713 init_fn_type_id(&inst_fn_type_id, fn_proto_node);
76847714 inst_fn_type_id.param_count = 0;
7715 inst_fn_type_id.is_var_args = false;
76857716
76867717 // TODO maybe GenericFnTypeId can be replaced with using the child_scope directly
76877718 // as the key in generic_table
......@@ -7918,6 +7949,7 @@ static TypeTableEntry *ir_analyze_unary_prefix_op_err(IrAnalyze *ira, IrInstruct
79187949 case TypeTableEntryIdBlock:
79197950 case TypeTableEntryIdUnreachable:
79207951 case TypeTableEntryIdVar:
7952 case TypeTableEntryIdArgTuple:
79217953 ir_add_error_node(ira, un_op_instruction->base.source_node,
79227954 buf_sprintf("unable to wrap type '%s' in error type", buf_ptr(&meta_type->name)));
79237955 // TODO if meta_type is type decl, add note pointing to type decl declaration
......@@ -7990,6 +8022,7 @@ static TypeTableEntry *ir_analyze_maybe(IrAnalyze *ira, IrInstructionUnOp *un_op
79908022 case TypeTableEntryIdBlock:
79918023 case TypeTableEntryIdBoundFn:
79928024 case TypeTableEntryIdEnumTag:
8025 case TypeTableEntryIdArgTuple:
79938026 {
79948027 ConstExprValue *out_val = ir_build_const_from(ira, &un_op_instruction->base,
79958028 value->value.depends_on_compile_var);
......@@ -8327,6 +8360,30 @@ static TypeTableEntry *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstruc
83278360 return_type = array_type;
83288361 } else if (is_slice(array_type)) {
83298362 return_type = array_type->data.structure.fields[0].type_entry;
8363 } else if (array_type->id == TypeTableEntryIdArgTuple) {
8364 ConstExprValue *ptr_val = ir_resolve_const(ira, array_ptr, UndefBad);
8365 if (!ptr_val)
8366 return ira->codegen->builtin_types.entry_invalid;
8367 ConstExprValue *args_val = const_ptr_pointee(ptr_val);
8368 size_t start = args_val->data.x_arg_tuple.start_index;
8369 size_t end = args_val->data.x_arg_tuple.end_index;
8370 ConstExprValue *elem_index_val = ir_resolve_const(ira, elem_index, UndefBad);
8371 if (!elem_index_val)
8372 return ira->codegen->builtin_types.entry_invalid;
8373 size_t index = bignum_to_twos_complement(&elem_index_val->data.x_bignum);
8374 size_t len = end - start;
8375 if (index >= len) {
8376 ir_add_error(ira, &elem_ptr_instruction->base,
8377 buf_sprintf("index %zu outside argument list of size %zu", index, len));
8378 return ira->codegen->builtin_types.entry_invalid;
8379 }
8380 size_t abs_index = start + index;
8381 FnTableEntry *fn_entry = exec_fn_entry(ira->new_irb.exec);
8382 assert(fn_entry);
8383 VariableTableEntry *var = fn_entry->variable_list.at(abs_index);
8384 bool depends_on_compile_var = array_ptr->value.depends_on_compile_var ||
8385 elem_index->value.depends_on_compile_var;
8386 return ir_analyze_var_ptr(ira, &elem_ptr_instruction->base, var, true, depends_on_compile_var);
83308387 } else {
83318388 ir_add_error_node(ira, elem_ptr_instruction->base.source_node,
83328389 buf_sprintf("array access of non-array type '%s'", buf_ptr(&array_type->name)));
......@@ -8572,6 +8629,29 @@ static TypeTableEntry *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstru
85728629 ConstExprValue *len_val = allocate<ConstExprValue>(1);
85738630 init_const_usize(ira->codegen, len_val, container_type->data.array.len);
85748631
8632 TypeTableEntry *usize = ira->codegen->builtin_types.entry_usize;
8633 bool ptr_is_const = true;
8634 return ir_analyze_const_ptr(ira, &field_ptr_instruction->base, len_val,
8635 usize, false, ConstPtrSpecialNone, ptr_is_const);
8636 } else {
8637 ir_add_error_node(ira, source_node,
8638 buf_sprintf("no member named '%s' in '%s'", buf_ptr(field_name),
8639 buf_ptr(&container_type->name)));
8640 return ira->codegen->builtin_types.entry_invalid;
8641 }
8642 } else if (container_type->id == TypeTableEntryIdArgTuple) {
8643 ConstExprValue *container_ptr_val = ir_resolve_const(ira, container_ptr, UndefBad);
8644 if (!container_ptr_val)
8645 return ira->codegen->builtin_types.entry_invalid;
8646
8647 assert(container_ptr->value.type->id == TypeTableEntryIdPointer);
8648 ConstExprValue *child_val = const_ptr_pointee(container_ptr_val);
8649
8650 if (buf_eql_str(field_name, "len")) {
8651 ConstExprValue *len_val = allocate<ConstExprValue>(1);
8652 size_t len = child_val->data.x_arg_tuple.end_index - child_val->data.x_arg_tuple.start_index;
8653 init_const_usize(ira->codegen, len_val, len);
8654
85758655 TypeTableEntry *usize = ira->codegen->builtin_types.entry_usize;
85768656 bool ptr_is_const = true;
85778657 return ir_analyze_const_ptr(ira, &field_ptr_instruction->base, len_val,
......@@ -8830,6 +8910,7 @@ static TypeTableEntry *ir_analyze_instruction_typeof(IrAnalyze *ira, IrInstructi
88308910 case TypeTableEntryIdFn:
88318911 case TypeTableEntryIdTypeDecl:
88328912 case TypeTableEntryIdEnumTag:
8913 case TypeTableEntryIdArgTuple:
88338914 {
88348915 ConstExprValue *out_val = ir_build_const_from(ira, &typeof_instruction->base, false);
88358916 // TODO depends_on_compile_var should be set based on whether the type of the expression
......@@ -8847,8 +8928,8 @@ static TypeTableEntry *ir_analyze_instruction_typeof(IrAnalyze *ira, IrInstructi
88478928static TypeTableEntry *ir_analyze_instruction_to_ptr_type(IrAnalyze *ira,
88488929 IrInstructionToPtrType *to_ptr_type_instruction)
88498930{
8850 IrInstruction *type_value = to_ptr_type_instruction->value->other;
8851 TypeTableEntry *type_entry = ir_resolve_type(ira, type_value);
8931 IrInstruction *value = to_ptr_type_instruction->value->other;
8932 TypeTableEntry *type_entry = value->value.type;
88528933 if (type_entry->id == TypeTableEntryIdInvalid)
88538934 return type_entry;
88548935
......@@ -8857,6 +8938,11 @@ static TypeTableEntry *ir_analyze_instruction_to_ptr_type(IrAnalyze *ira,
88578938 ptr_type = get_pointer_to_type(ira->codegen, type_entry->data.array.child_type, false);
88588939 } else if (is_slice(type_entry)) {
88598940 ptr_type = type_entry->data.structure.fields[0].type_entry;
8941 } else if (type_entry->id == TypeTableEntryIdArgTuple) {
8942 ConstExprValue *arg_tuple_val = ir_resolve_const(ira, value, UndefBad);
8943 if (!arg_tuple_val)
8944 return ira->codegen->builtin_types.entry_invalid;
8945 zig_panic("TODO for loop on var args");
88608946 } else {
88618947 ir_add_error_node(ira, to_ptr_type_instruction->base.source_node,
88628948 buf_sprintf("expected array type, found '%s'", buf_ptr(&type_entry->name)));
......@@ -8864,7 +8950,7 @@ static TypeTableEntry *ir_analyze_instruction_to_ptr_type(IrAnalyze *ira,
88648950 }
88658951
88668952 ConstExprValue *out_val = ir_build_const_from(ira, &to_ptr_type_instruction->base,
8867 type_value->value.depends_on_compile_var);
8953 value->value.depends_on_compile_var);
88688954 out_val->data.x_type = ptr_type;
88698955 return ira->codegen->builtin_types.entry_type;
88708956}
......@@ -9027,6 +9113,7 @@ static TypeTableEntry *ir_analyze_instruction_slice_type(IrAnalyze *ira,
90279113 case TypeTableEntryIdUndefLit:
90289114 case TypeTableEntryIdNullLit:
90299115 case TypeTableEntryIdBlock:
9116 case TypeTableEntryIdArgTuple:
90309117 ir_add_error_node(ira, slice_type_instruction->base.source_node,
90319118 buf_sprintf("slice of type '%s' not allowed", buf_ptr(&resolved_child_type->name)));
90329119 // TODO if this is a typedecl, add error note showing the declaration of the type decl
......@@ -9118,6 +9205,7 @@ static TypeTableEntry *ir_analyze_instruction_array_type(IrAnalyze *ira,
91189205 case TypeTableEntryIdUndefLit:
91199206 case TypeTableEntryIdNullLit:
91209207 case TypeTableEntryIdBlock:
9208 case TypeTableEntryIdArgTuple:
91219209 ir_add_error_node(ira, array_type_instruction->base.source_node,
91229210 buf_sprintf("array of type '%s' not allowed", buf_ptr(&child_type->name)));
91239211 // TODO if this is a typedecl, add error note showing the declaration of the type decl
......@@ -9214,6 +9302,7 @@ static TypeTableEntry *ir_analyze_instruction_size_of(IrAnalyze *ira,
92149302 case TypeTableEntryIdMetaType:
92159303 case TypeTableEntryIdFn:
92169304 case TypeTableEntryIdNamespace:
9305 case TypeTableEntryIdArgTuple:
92179306 ir_add_error_node(ira, size_of_instruction->base.source_node,
92189307 buf_sprintf("no size available for type '%s'", buf_ptr(&type_entry->name)));
92199308 // TODO if this is a typedecl, add error note showing the declaration of the type decl
......@@ -9559,6 +9648,7 @@ static TypeTableEntry *ir_analyze_instruction_switch_target(IrAnalyze *ira,
95599648 case TypeTableEntryIdUnion:
95609649 case TypeTableEntryIdBlock:
95619650 case TypeTableEntryIdBoundFn:
9651 case TypeTableEntryIdArgTuple:
95629652 ir_add_error(ira, &switch_target_instruction->base,
95639653 buf_sprintf("invalid switch target type '%s'", buf_ptr(&target_type->name)));
95649654 // TODO if this is a typedecl, add error note showing the declaration of the type decl
......@@ -10075,6 +10165,7 @@ static TypeTableEntry *ir_analyze_min_max(IrAnalyze *ira, IrInstruction *source_
1007510165 case TypeTableEntryIdNamespace:
1007610166 case TypeTableEntryIdBlock:
1007710167 case TypeTableEntryIdBoundFn:
10168 case TypeTableEntryIdArgTuple:
1007810169 {
1007910170 const char *err_format = is_max ?
1008010171 "no max value available for type '%s'" :
src/parser.cpp+12-13
......@@ -250,16 +250,11 @@ static AstNode *ast_parse_type_expr(ParseContext *pc, size_t *token_index, bool
250250}
251251
252252/*
253ParamDecl = option("noalias" | "comptime") option(Symbol ":") TypeExpr | "..."
253ParamDecl = option("noalias" | "comptime") option(Symbol ":") (TypeExpr | "...")
254254*/
255255static AstNode *ast_parse_param_decl(ParseContext *pc, size_t *token_index) {
256256 Token *token = &pc->tokens->at(*token_index);
257257
258 if (token->id == TokenIdEllipsis) {
259 *token_index += 1;
260 return nullptr;
261 }
262
263258 AstNode *node = ast_create_node(pc, NodeTypeParamDecl, token);
264259
265260 if (token->id == TokenIdKeywordNoAlias) {
......@@ -282,7 +277,13 @@ static AstNode *ast_parse_param_decl(ParseContext *pc, size_t *token_index) {
282277 }
283278 }
284279
285 node->data.param_decl.type = ast_parse_type_expr(pc, token_index, true);
280 Token *ellipsis_tok = &pc->tokens->at(*token_index);
281 if (ellipsis_tok->id == TokenIdEllipsis) {
282 *token_index += 1;
283 node->data.param_decl.is_var_args = true;
284 } else {
285 node->data.param_decl.type = ast_parse_type_expr(pc, token_index, true);
286 }
286287
287288 return node;
288289}
......@@ -304,12 +305,10 @@ static void ast_parse_param_decl_list(ParseContext *pc, size_t *token_index,
304305 for (;;) {
305306 AstNode *param_decl_node = ast_parse_param_decl(pc, token_index);
306307 bool expect_end = false;
307 if (param_decl_node) {
308 params->append(param_decl_node);
309 } else {
310 *is_var_args = true;
311 expect_end = true;
312 }
308 assert(param_decl_node);
309 params->append(param_decl_node);
310 expect_end = param_decl_node->data.param_decl.is_var_args;
311 *is_var_args = expect_end;
313312
314313 Token *token = &pc->tokens->at(*token_index);
315314 *token_index += 1;
test/cases/var_args.zig created+16
......@@ -0,0 +1,16 @@
1const assert = @import("std").debug.assert;
2
3fn add(args: ...) -> i32 {
4 var sum = i32(0);
5 {comptime var i: usize = 0; inline while (i < args.len; i += 1) {
6 sum += args[i];
7 }}
8 return sum;
9}
10
11fn testAddArbitraryArgs() {
12 @setFnTest(this);
13
14 assert(add(i32(1), i32(2), i32(3), i32(4)) == 10);
15 assert(add(i32(1234)) == 1234);
16}
test/run_tests.cpp+27-4
......@@ -832,10 +832,6 @@ fn f() {
832832 )SOURCE", 2, ".tmp_source.zig:5:11: error: expected type 'usize', found 'bool'",
833833 ".tmp_source.zig:5:24: error: expected type 'usize', found 'bool'");
834834
835 add_compile_fail_case("variadic functions only allowed in extern", R"SOURCE(
836fn f(...) {}
837 )SOURCE", 1, ".tmp_source.zig:2:1: error: variadic arguments only allowed in extern function declarations");
838
839835 add_compile_fail_case("write to const global variable", R"SOURCE(
840836const x : i32 = 99;
841837fn f() {
......@@ -1633,6 +1629,33 @@ pub fn maybeInt() -> ?i32 {
16331629 return 0;
16341630}
16351631 )SOURCE", 1, ".tmp_source.zig:5:11: error: cannot return from defer expression");
1632
1633 add_compile_fail_case("attempt to access var args out of bounds", R"SOURCE(
1634fn add(args: ...) -> i32 {
1635 args[0] + args[1]
1636}
1637
1638fn foo() -> i32 {
1639 add(i32(1234))
1640}
1641 )SOURCE", 2,
1642 ".tmp_source.zig:3:19: error: index 1 outside argument list of size 1",
1643 ".tmp_source.zig:7:8: note: called from here");
1644
1645 add_compile_fail_case("pass integer literal to var args", R"SOURCE(
1646fn add(args: ...) -> i32 {
1647 var sum = i32(0);
1648 {comptime var i: usize = 0; inline while (i < args.len; i += 1) {
1649 sum += args[i];
1650 }}
1651 return sum;
1652}
1653
1654fn bar() -> i32 {
1655 add(1, 2, 3, 4)
1656}
1657 )SOURCE", 1, ".tmp_source.zig:11:9: error: parameter of type '(integer literal)' requires comptime");
1658
16361659}
16371660
16381661//////////////////////////////////////////////////////////////////////////////
test/self_hosted.zig+1
......@@ -28,4 +28,5 @@ const test_switch = @import("cases/switch.zig");
2828const test_switch_prong_err_enum = @import("cases/switch_prong_err_enum.zig");
2929const test_switch_prong_implicit_cast = @import("cases/switch_prong_implicit_cast.zig");
3030const test_this = @import("cases/this.zig");
31const test_var_args = @import("cases/var_args.zig");
3132const test_while = @import("cases/while.zig");