Commit 4e37fb2fa244e350b4e248332848d40594eee820 | zig

author	Andrew Kelley <andrew@ziglang.org> 2016-04-19 17:15:36-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2016-04-19 17:15:55-07:00
log	4e37fb2fa244e350b4e248332848d40594eee820
tree	02de8b32d21a4b673484d69a1f7e223b48bdd523
parent	9658c05fd406a13cade56b9c6e26d96764b965cc

implement constant initialization of enum values

see #5

3 files changed, 83 insertions(+), 9 deletions(-)

src
- analyze.cpp
- codegen.cpp
test
- self_hosted.zig

src/analyze.cpp+26-8

 @@ -2110,7 +2110,8 @@ static TypeEnumField *get_enum_field(TypeTableEntry *enum_type, Buf *name) {
 }
 static TypeTableEntry *analyze_enum_value_expr(CodeGen *g, ImportTableEntry *import, BlockContext *context,
-        AstNode *field_access_node, AstNode *value_node, TypeTableEntry *enum_type, Buf *field_name)
+        AstNode *field_access_node, AstNode *value_node, TypeTableEntry *enum_type, Buf *field_name,
+        AstNode *out_node)
 {
     assert(field_access_node->type == NodeTypeFieldAccessExpr);
 @@ -2119,15 +2120,32 @@ static TypeTableEntry *analyze_enum_value_expr(CodeGen *g, ImportTableEntry *imp
     if (type_enum_field) {
         if (value_node) {
-            analyze_expression(g, import, context, type_enum_field->type_entry, value_node);
+            AstNode **value_node_ptr = value_node->parent_field;
+            TypeTableEntry *value_type = analyze_expression(g, import, context,
+                    type_enum_field->type_entry, value_node);
+            if (value_type->id == TypeTableEntryIdInvalid) {
+                return g->builtin_types.entry_invalid;
+            }
             StructValExprCodeGen *codegen = &field_access_node->data.field_access_expr.resolved_struct_val_expr;
             codegen->type_entry = enum_type;
             codegen->source_node = field_access_node;
-            context->fn_entry->struct_val_expr_alloca_list.append(codegen);
-            Expr *expr = get_resolved_expr(field_access_node);
+            ConstExprValue *value_const_val = &get_resolved_expr(*value_node_ptr)->const_val;
-            expr->const_val.ok = false;
+            if (value_const_val->ok) {
+                ConstExprValue *const_val = &get_resolved_expr(out_node)->const_val;
+                const_val->ok = true;
+                const_val->data.x_enum.tag = type_enum_field->value;
+                const_val->data.x_enum.payload = value_const_val;
+            } else {
+                if (context->fn_entry) {
+                    context->fn_entry->struct_val_expr_alloca_list.append(codegen);
+                } else {
+                    add_node_error(g, *value_node_ptr, buf_sprintf("unable to evaluate constant expression"));
+                    return g->builtin_types.entry_invalid;
+                }
+            }
         } else if (type_enum_field->type_entry->id != TypeTableEntryIdVoid) {
             add_node_error(g, field_access_node,
                 buf_sprintf("enum value '%s.%s' requires parameter of type '%s'",
 @@ -2135,7 +2153,7 @@ static TypeTableEntry *analyze_enum_value_expr(CodeGen *g, ImportTableEntry *imp
                     buf_ptr(field_name),
                     buf_ptr(&type_enum_field->type_entry->name)));
         } else {
-            Expr *expr = get_resolved_expr(field_access_node);
+            Expr *expr = get_resolved_expr(out_node);
             expr->const_val.ok = true;
             expr->const_val.data.x_enum.tag = type_enum_field->value;
             expr->const_val.data.x_enum.payload = nullptr;
 @@ -2396,7 +2414,7 @@ static TypeTableEntry *analyze_field_access_expr(CodeGen *g, ImportTableEntry *i
         } else if (wrapped_in_fn_call) {
             return resolve_expr_const_val_as_type(g, node, child_type);
         } else if (child_type->id == TypeTableEntryIdEnum) {
-            return analyze_enum_value_expr(g, import, context, node, nullptr, child_type, field_name);
+            return analyze_enum_value_expr(g, import, context, node, nullptr, child_type, field_name, node);
         } else if (child_type->id == TypeTableEntryIdStruct) {
             BlockContext *container_block_context = get_container_block_context(child_type);
             auto entry = container_block_context->decl_table.maybe_get(field_name);
 @@ -4725,7 +4743,7 @@ static TypeTableEntry *analyze_fn_call_expr(CodeGen *g, ImportTableEntry *import
                         node->data.fn_call_expr.enum_type = child_type;
                         return analyze_enum_value_expr(g, import, context, fn_ref_expr, value_node,
-                                child_type, field_name);
+                                child_type, field_name, node);
                     }
                 } else if (child_type->id == TypeTableEntryIdStruct) {
                     Buf *field_name = &fn_ref_expr->data.field_access_expr.field_name;

src/codegen.cpp+17-1

...	@@ -2937,7 +2937,23 @@ static LLVMValueRef gen_const_val(CodeGen g, TypeTableEntry type_entry, ConstE	...	@@ -2937,7 +2937,23 @@ static LLVMValueRef gen_const_val(CodeGen g, TypeTableEntry type_entry, ConstE
2937	assert(enum_field->value == const_val->data.x_enum.tag);	2937	assert(enum_field->value == const_val->data.x_enum.tag);
2938	LLVMValueRef union_value;	2938	LLVMValueRef union_value;
2939	if (type_has_bits(enum_field->type_entry)) {	2939	if (type_has_bits(enum_field->type_entry)) {
2940	union_value = gen_const_val(g, union_type, const_val->data.x_enum.payload);	2940	uint64_t union_type_bytes = LLVMStoreSizeOfType(g->target_data_ref,
		2941	union_type->type_ref);
		2942	uint64_t field_type_bytes = LLVMStoreSizeOfType(g->target_data_ref,
		2943	enum_field->type_entry->type_ref);
		2944	uint64_t pad_bytes = union_type_bytes - field_type_bytes;
		2945
		2946	LLVMValueRef correctly_typed_value = gen_const_val(g, enum_field->type_entry,
		2947	const_val->data.x_enum.payload);
		2948	if (pad_bytes == 0) {
		2949	union_value = correctly_typed_value;
		2950	} else {
		2951	LLVMValueRef fields[] = {
		2952	correctly_typed_value,
		2953	LLVMGetUndef(LLVMArrayType(LLVMInt8Type(), pad_bytes)),
		2954	};
		2955	union_value = LLVMConstStruct(fields, 2, false);
		2956	}
2941	} else {	2957	} else {
2942	union_value = LLVMGetUndef(union_type->type_ref);	2958	union_value = LLVMGetUndef(union_type->type_ref);
2943	}	2959	}

test/self_hosted.zig+40

...	@@ -1204,3 +1204,43 @@ fn const_expression_eval_handling_of_variables() {	...	@@ -1204,3 +1204,43 @@ fn const_expression_eval_handling_of_variables() {
1204	x = false;	1204	x = false;
1205	}	1205	}
1206	}	1206	}
		1207
		1208
		1209
		1210	#attribute("test")
		1211	fn constant_enum_initialization_with_differing_sizes() {
		1212	test3_1(test3_foo);
		1213	test3_2(test3_bar);
		1214	}
		1215	enum Test3Foo {
		1216	One,
		1217	Two: f32,
		1218	Three: Test3Point,
		1219	}
		1220	struct Test3Point {
		1221	x: i32,
		1222	y: i32,
		1223	}
		1224	const test3_foo = Test3Foo.Three(Test3Point {.x = 3, .y = 4});
		1225	const test3_bar = Test3Foo.Two(13);
		1226	#static_eval_enable(false)
		1227	fn test3_1(f: Test3Foo) {
		1228	switch (f) {
		1229	Three => \|pt\| {
		1230	assert(pt.x == 3);
		1231	assert(pt.y == 4);
		1232	},
		1233	else => unreachable{},
		1234	}
		1235	}
		1236	#static_eval_enable(false)
		1237	fn test3_2(f: Test3Foo) {
		1238	switch (f) {
		1239	Two => \|x\| {
		1240	assert(x == 13);
		1241	},
		1242	else => unreachable{},
		1243	}
		1244	}
		1245
		1246