authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2017-01-10 16:28:49-05:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2017-01-10 16:28:49-05:00
logfde276a3bf3d20da5346bd302a736101ce440362
treede395f7e8e8624c99a4af3eea160437b89d4b3ee
parent430e33b869b004ca24faee2dfa9e51aa4e94093f

IR: implement error for missing or extra switch prongs

5 files changed, 155 insertions(+), 12 deletions(-)

src/all_types.hpp+14
......@@ -1484,6 +1484,7 @@ enum IrInstructionId {
14841484 IrInstructionIdIntToPtr,
14851485 IrInstructionIdPtrToInt,
14861486 IrInstructionIdIntToEnum,
1487 IrInstructionIdCheckSwitchProngs,
14871488};
14881489
14891490struct IrInstruction {
......@@ -2160,6 +2161,19 @@ struct IrInstructionIntToEnum {
21602161 IrInstruction *target;
21612162};
21622163
2164struct IrInstructionCheckSwitchProngsRange {
2165 IrInstruction *start;
2166 IrInstruction *end;
2167};
2168
2169struct IrInstructionCheckSwitchProngs {
2170 IrInstruction base;
2171
2172 IrInstruction *target_value;
2173 IrInstructionCheckSwitchProngsRange *ranges;
2174 size_t range_count;
2175};
2176
21632177enum LValPurpose {
21642178 LValPurposeNone,
21652179 LValPurposeAssign,
src/codegen.cpp+1
......@@ -2274,6 +2274,7 @@ static LLVMValueRef ir_render_instruction(CodeGen *g, IrExecutable *executable,
22742274 case IrInstructionIdFnProto:
22752275 case IrInstructionIdTestComptime:
22762276 case IrInstructionIdGeneratedCode:
2277 case IrInstructionIdCheckSwitchProngs:
22772278 zig_unreachable();
22782279 case IrInstructionIdReturn:
22792280 return ir_render_return(g, executable, (IrInstructionReturn *)instruction);
src/ir.cpp+119
......@@ -483,6 +483,10 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionIntToEnum *) {
483483 return IrInstructionIdIntToEnum;
484484}
485485
486static constexpr IrInstructionId ir_instruction_id(IrInstructionCheckSwitchProngs *) {
487 return IrInstructionIdCheckSwitchProngs;
488}
489
486490template<typename T>
487491static T *ir_create_instruction(IrBuilder *irb, Scope *scope, AstNode *source_node) {
488492 T *special_instruction = allocate<T>(1);
......@@ -1981,6 +1985,24 @@ static IrInstruction *ir_build_int_to_enum(IrBuilder *irb, Scope *scope, AstNode
19811985 return &instruction->base;
19821986}
19831987
1988static IrInstruction *ir_build_check_switch_prongs(IrBuilder *irb, Scope *scope, AstNode *source_node,
1989 IrInstruction *target_value, IrInstructionCheckSwitchProngsRange *ranges, size_t range_count)
1990{
1991 IrInstructionCheckSwitchProngs *instruction = ir_build_instruction<IrInstructionCheckSwitchProngs>(
1992 irb, scope, source_node);
1993 instruction->target_value = target_value;
1994 instruction->ranges = ranges;
1995 instruction->range_count = range_count;
1996
1997 ir_ref_instruction(target_value, irb->current_basic_block);
1998 for (size_t i = 0; i < range_count; i += 1) {
1999 ir_ref_instruction(ranges[i].start, irb->current_basic_block);
2000 ir_ref_instruction(ranges[i].end, irb->current_basic_block);
2001 }
2002
2003 return &instruction->base;
2004}
2005
19842006static IrInstruction *ir_instruction_br_get_dep(IrInstructionBr *instruction, size_t index) {
19852007 return nullptr;
19862008}
......@@ -2580,6 +2602,18 @@ static IrInstruction *ir_instruction_inttoenum_get_dep(IrInstructionIntToEnum *i
25802602 }
25812603}
25822604
2605static IrInstruction *ir_instruction_checkswitchprongs_get_dep(IrInstructionCheckSwitchProngs *instruction,
2606 size_t index)
2607{
2608 if (index == 0) return instruction->target_value;
2609 size_t range_index = index - 1;
2610 if (range_index < instruction->range_count * 2) {
2611 IrInstructionCheckSwitchProngsRange *range = &instruction->ranges[range_index / 2];
2612 return (range_index % 2 == 0) ? range->start : range->end;
2613 }
2614 return nullptr;
2615}
2616
25832617static IrInstruction *ir_instruction_get_dep(IrInstruction *instruction, size_t index) {
25842618 switch (instruction->id) {
25852619 case IrInstructionIdInvalid:
......@@ -2752,6 +2786,8 @@ static IrInstruction *ir_instruction_get_dep(IrInstruction *instruction, size_t
27522786 return ir_instruction_ptrtoint_get_dep((IrInstructionPtrToInt *) instruction, index);
27532787 case IrInstructionIdIntToEnum:
27542788 return ir_instruction_inttoenum_get_dep((IrInstructionIntToEnum *) instruction, index);
2789 case IrInstructionIdCheckSwitchProngs:
2790 return ir_instruction_checkswitchprongs_get_dep((IrInstructionCheckSwitchProngs *) instruction, index);
27552791 }
27562792 zig_unreachable();
27572793}
......@@ -4677,6 +4713,7 @@ static IrInstruction *ir_gen_switch_expr(IrBuilder *irb, Scope *scope, AstNode *
46774713
46784714 ZigList<IrInstruction *> incoming_values = {0};
46794715 ZigList<IrBasicBlock *> incoming_blocks = {0};
4716 ZigList<IrInstructionCheckSwitchProngsRange> check_ranges = {0};
46804717
46814718 AstNode *else_prong = nullptr;
46824719 for (size_t prong_i = 0; prong_i < prong_count; prong_i += 1) {
......@@ -4719,6 +4756,10 @@ static IrInstruction *ir_gen_switch_expr(IrBuilder *irb, Scope *scope, AstNode *
47194756 if (end_value == irb->codegen->invalid_instruction)
47204757 return irb->codegen->invalid_instruction;
47214758
4759 IrInstructionCheckSwitchProngsRange *check_range = check_ranges.add_one();
4760 check_range->start = start_value;
4761 check_range->end = end_value;
4762
47224763 IrInstruction *start_value_const = ir_build_static_eval(irb, scope, start_node, start_value);
47234764 IrInstruction *end_value_const = ir_build_static_eval(irb, scope, start_node, end_value);
47244765
......@@ -4738,6 +4779,10 @@ static IrInstruction *ir_gen_switch_expr(IrBuilder *irb, Scope *scope, AstNode *
47384779 if (item_value == irb->codegen->invalid_instruction)
47394780 return irb->codegen->invalid_instruction;
47404781
4782 IrInstructionCheckSwitchProngsRange *check_range = check_ranges.add_one();
4783 check_range->start = item_value;
4784 check_range->end = item_value;
4785
47414786 IrInstruction *cmp_ok = ir_build_bin_op(irb, scope, item_node, IrBinOpCmpEq,
47424787 item_value, target_value, false);
47434788 if (ok_bit) {
......@@ -4776,6 +4821,10 @@ static IrInstruction *ir_gen_switch_expr(IrBuilder *irb, Scope *scope, AstNode *
47764821 if (item_value == irb->codegen->invalid_instruction)
47774822 return irb->codegen->invalid_instruction;
47784823
4824 IrInstructionCheckSwitchProngsRange *check_range = check_ranges.add_one();
4825 check_range->start = item_value;
4826 check_range->end = item_value;
4827
47794828 IrInstructionSwitchBrCase *this_case = cases.add_one();
47804829 this_case->value = item_value;
47814830 this_case->block = prong_block;
......@@ -4798,6 +4847,10 @@ static IrInstruction *ir_gen_switch_expr(IrBuilder *irb, Scope *scope, AstNode *
47984847 }
47994848 }
48004849
4850 if (!else_prong) {
4851 ir_build_check_switch_prongs(irb, scope, node, target_value, check_ranges.items, check_ranges.length);
4852 }
4853
48014854 if (cases.length == 0) {
48024855 ir_build_br(irb, scope, node, else_block, is_comptime);
48034856 } else {
......@@ -11091,6 +11144,69 @@ static TypeTableEntry *ir_analyze_instruction_test_comptime(IrAnalyze *ira, IrIn
1109111144 return ira->codegen->builtin_types.entry_bool;
1109211145}
1109311146
11147static TypeTableEntry *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
11148 IrInstructionCheckSwitchProngs *instruction)
11149{
11150 IrInstruction *target_value = instruction->target_value->other;
11151 TypeTableEntry *switch_type = target_value->value.type;
11152 if (switch_type->id == TypeTableEntryIdInvalid)
11153 return ira->codegen->builtin_types.entry_invalid;
11154
11155 if (switch_type->id == TypeTableEntryIdEnumTag) {
11156 TypeTableEntry *enum_type = switch_type->data.enum_tag.enum_type;
11157 size_t *field_use_counts = allocate<size_t>(enum_type->data.enumeration.src_field_count);
11158 for (size_t range_i = 0; range_i < instruction->range_count; range_i += 1) {
11159 IrInstructionCheckSwitchProngsRange *range = &instruction->ranges[range_i];
11160
11161 IrInstruction *start_value = range->start->other;
11162 if (start_value->value.type->id == TypeTableEntryIdInvalid)
11163 return ira->codegen->builtin_types.entry_invalid;
11164
11165 IrInstruction *end_value = range->end->other;
11166 if (end_value->value.type->id == TypeTableEntryIdInvalid)
11167 return ira->codegen->builtin_types.entry_invalid;
11168
11169 size_t start_index;
11170 size_t end_index;
11171 if (start_value->value.type->id == TypeTableEntryIdEnumTag) {
11172 start_index = start_value->value.data.x_bignum.data.x_uint;
11173 } else if (start_value->value.type->id == TypeTableEntryIdEnum) {
11174 start_index = start_value->value.data.x_enum.tag;
11175 } else {
11176 zig_unreachable();
11177 }
11178 if (end_value->value.type->id == TypeTableEntryIdEnumTag) {
11179 end_index = end_value->value.data.x_bignum.data.x_uint;
11180 } else if (end_value->value.type->id == TypeTableEntryIdEnum) {
11181 end_index = end_value->value.data.x_enum.tag;
11182 } else {
11183 zig_unreachable();
11184 }
11185
11186 for (size_t field_index = start_index; field_index <= end_index; field_index += 1) {
11187 field_use_counts[field_index] += 1;
11188 if (field_use_counts[field_index] > 1) {
11189 TypeEnumField *type_enum_field = &enum_type->data.enumeration.fields[field_index];
11190 ir_add_error(ira, start_value,
11191 buf_sprintf("duplicate switch value: '%s.%s'", buf_ptr(&enum_type->name),
11192 buf_ptr(type_enum_field->name)));
11193 }
11194 }
11195 }
11196 for (uint32_t i = 0; i < enum_type->data.enumeration.src_field_count; i += 1) {
11197 if (field_use_counts[i] == 0) {
11198 ir_add_error(ira, &instruction->base,
11199 buf_sprintf("enumeration value '%s.%s' not handled in switch", buf_ptr(&enum_type->name),
11200 buf_ptr(enum_type->data.enumeration.fields[i].name)));
11201 }
11202 }
11203 } else {
11204 // TODO check prongs of types other than enumtag
11205 }
11206 ir_build_const_from(ira, &instruction->base, false);
11207 return ira->codegen->builtin_types.entry_void;
11208}
11209
1109411210static TypeTableEntry *ir_analyze_instruction_nocast(IrAnalyze *ira, IrInstruction *instruction) {
1109511211 switch (instruction->id) {
1109611212 case IrInstructionIdInvalid:
......@@ -11246,6 +11362,8 @@ static TypeTableEntry *ir_analyze_instruction_nocast(IrAnalyze *ira, IrInstructi
1124611362 return ir_analyze_instruction_fn_proto(ira, (IrInstructionFnProto *)instruction);
1124711363 case IrInstructionIdTestComptime:
1124811364 return ir_analyze_instruction_test_comptime(ira, (IrInstructionTestComptime *)instruction);
11365 case IrInstructionIdCheckSwitchProngs:
11366 return ir_analyze_instruction_check_switch_prongs(ira, (IrInstructionCheckSwitchProngs *)instruction);
1124911367 case IrInstructionIdMaybeWrap:
1125011368 case IrInstructionIdErrWrapCode:
1125111369 case IrInstructionIdErrWrapPayload:
......@@ -11351,6 +11469,7 @@ bool ir_has_side_effects(IrInstruction *instruction) {
1135111469 case IrInstructionIdMemcpy:
1135211470 case IrInstructionIdBreakpoint:
1135311471 case IrInstructionIdOverflowOp: // TODO when we support multiple returns this can be side effect free
11472 case IrInstructionIdCheckSwitchProngs:
1135411473 return true;
1135511474 case IrInstructionIdPhi:
1135611475 case IrInstructionIdUnOp:
src/ir_print.cpp+17
......@@ -799,6 +799,20 @@ static void ir_print_int_to_enum(IrPrint *irp, IrInstructionIntToEnum *instructi
799799 fprintf(irp->f, ")");
800800}
801801
802static void ir_print_check_switch_prongs(IrPrint *irp, IrInstructionCheckSwitchProngs *instruction) {
803 fprintf(irp->f, "@checkSwitchProngs(");
804 ir_print_other_instruction(irp, instruction->target_value);
805 fprintf(irp->f, ",");
806 for (size_t i = 0; i < instruction->range_count; i += 1) {
807 if (i != 0)
808 fprintf(irp->f, ",");
809 ir_print_other_instruction(irp, instruction->ranges[i].start);
810 fprintf(irp->f, "...");
811 ir_print_other_instruction(irp, instruction->ranges[i].end);
812 }
813 fprintf(irp->f, ")");
814}
815
802816static void ir_print_instruction(IrPrint *irp, IrInstruction *instruction) {
803817 ir_print_prefix(irp, instruction);
804818 switch (instruction->id) {
......@@ -1056,6 +1070,9 @@ static void ir_print_instruction(IrPrint *irp, IrInstruction *instruction) {
10561070 case IrInstructionIdIntToEnum:
10571071 ir_print_int_to_enum(irp, (IrInstructionIntToEnum *)instruction);
10581072 break;
1073 case IrInstructionIdCheckSwitchProngs:
1074 ir_print_check_switch_prongs(irp, (IrInstructionCheckSwitchProngs *)instruction);
1075 break;
10591076 }
10601077 fprintf(irp->f, "\n");
10611078}
test/run_tests.cpp+4-12
......@@ -1167,12 +1167,12 @@ const Number = enum {
11671167};
11681168fn f(n: Number) -> i32 {
11691169 switch (n) {
1170 One => 1,
1171 Two => 2,
1172 Three => 3,
1170 Number.One => 1,
1171 Number.Two => 2,
1172 Number.Three => i32(3),
11731173 }
11741174}
1175 )SOURCE", 1, ".tmp_source.zig:9:5: error: enumeration value 'Four' not handled in switch");
1175 )SOURCE", 1, ".tmp_source.zig:9:5: error: enumeration value 'Number.Four' not handled in switch");
11761176
11771177 add_compile_fail_case("import inside function body", R"SOURCE(
11781178fn f() {
......@@ -1430,14 +1430,6 @@ fn f() -> i32 {
14301430}
14311431 )SOURCE", 1, ".tmp_source.zig:2:15: error: inline parameter not allowed in extern function");
14321432
1433 /* TODO
1434 add_compile_fail_case("inline export function", R"SOURCE(
1435export inline fn foo(x: i32, y: i32) -> i32{
1436 x + y
1437}
1438 )SOURCE", 1, ".tmp_source.zig:2:1: error: extern functions cannot be inline");
1439 */
1440
14411433 add_compile_fail_case("convert fixed size array to slice with invalid size", R"SOURCE(
14421434fn f() {
14431435 var array: [5]u8 = undefined;