Commit 37ab960492885c24a6b135f7955188d5f81d9a5a | zig

author	Andrew Kelley <andrew@ziglang.org> 2020-01-27 18:59:46-05:00
committer	Andrew Kelley <andrew@ziglang.org> 2020-01-27 18:59:46-05:00
log	37ab960492885c24a6b135f7955188d5f81d9a5a
tree	beaebb1abf528171a3ca244c18e9bc6ee65b6463
parent	b38b96784406c1d9e5f4246442f9414dba6812d2
signature	Commit is signed but in an unrecognized format.

fix not handling undefined u0 correctly

2 files changed, 36 insertions(+), 5 deletions(-)

src
- ir.cpp
test
- stage1
  - behavior
    eval.zig

src/ir.cpp+23-5

 @@ -15644,9 +15644,27 @@ static IrInstGen *ir_evaluate_bin_op_cmp(IrAnalyze *ira, ZigType *resolved_type,
 }
 // Returns ErrorNotLazy when the value cannot be determined
-static Error lazy_cmp_zero(AstNode *source_node, ZigValue *val, Cmp *result) {
+static Error lazy_cmp_zero(CodeGen *codegen, AstNode *source_node, ZigValue *val, Cmp *result) {
     Error err;
+    switch (type_has_one_possible_value(codegen, val->type)) {
+        case OnePossibleValueInvalid:
+            return ErrorSemanticAnalyzeFail;
+        case OnePossibleValueNo:
+            break;
+        case OnePossibleValueYes:
+            switch (val->type->id) {
+                case ZigTypeIdInt:
+                    src_assert(val->type->data.integral.bit_count == 0, source_node);
+                    *result = CmpEQ;
+                    return ErrorNone;
+                case ZigTypeIdUndefined:
+                    return ErrorNotLazy;
+                default:
+                    zig_unreachable();
+            }
+    }
     switch (val->special) {
         case ConstValSpecialRuntime:
         case ConstValSpecialUndef:
 @@ -15700,12 +15718,12 @@ static ErrorMsg *ir_eval_bin_op_cmp_scalar(IrAnalyze *ira, IrInst* source_instr,
         // Before resolving the values, we special case comparisons against zero. These can often
         // be done without resolving lazy values, preventing potential dependency loops.
         Cmp op1_cmp_zero;
-        if ((err = lazy_cmp_zero(source_instr->source_node, op1_val, &op1_cmp_zero))) {
+        if ((err = lazy_cmp_zero(ira->codegen, source_instr->source_node, op1_val, &op1_cmp_zero))) {
             if (err == ErrorNotLazy) goto never_mind_just_calculate_it_normally;
             return ira->codegen->trace_err;
         }
         Cmp op2_cmp_zero;
-        if ((err = lazy_cmp_zero(source_instr->source_node, op2_val, &op2_cmp_zero))) {
+        if ((err = lazy_cmp_zero(ira->codegen, source_instr->source_node, op2_val, &op2_cmp_zero))) {
             if (err == ErrorNotLazy) goto never_mind_just_calculate_it_normally;
             return ira->codegen->trace_err;
         }
 @@ -15869,14 +15887,14 @@ static IrInstGen *ir_analyze_bin_op_cmp_numeric(IrAnalyze *ira, IrInst *source_i
     }
     Cmp op1_cmp_zero;
     bool have_op1_cmp_zero = false;
-    if ((err = lazy_cmp_zero(source_instr->source_node, op1->value, &op1_cmp_zero))) {
+    if ((err = lazy_cmp_zero(ira->codegen, source_instr->source_node, op1->value, &op1_cmp_zero))) {
         if (err != ErrorNotLazy) return ira->codegen->invalid_inst_gen;
     } else {
         have_op1_cmp_zero = true;
     }
     Cmp op2_cmp_zero;
     bool have_op2_cmp_zero = false;
-    if ((err = lazy_cmp_zero(source_instr->source_node, op2->value, &op2_cmp_zero))) {
+    if ((err = lazy_cmp_zero(ira->codegen, source_instr->source_node, op2->value, &op2_cmp_zero))) {
         if (err != ErrorNotLazy) return ira->codegen->invalid_inst_gen;
     } else {
         have_op2_cmp_zero = true;

test/stage1/behavior/eval.zig+13

...	@@ -804,3 +804,16 @@ test "comptime assign int to optional int" {	...	@@ -804,3 +804,16 @@ test "comptime assign int to optional int" {
804	expectEqual(20, x.?);	804	expectEqual(20, x.?);
805	}	805	}
806	}	806	}
		807
		808	test "return 0 from function that has u0 return type" {
		809	const S = struct {
		810	fn foo_zero() u0 {
		811	return 0;
		812	}
		813	};
		814	comptime {
		815	if (S.foo_zero() != 0) {
		816	@compileError("test failed");
		817	}
		818	}
		819	}