Commit 36c6acfc76eeeed1498b5cc9ecb3137214e69bbf | zig

src/all_types.hpp+2-1

...	@@ -392,7 +392,6 @@ struct AstNodeFnCallExpr {	...	@@ -392,7 +392,6 @@ struct AstNodeFnCallExpr {
392	Expr resolved_expr;	392	Expr resolved_expr;
393	FnTableEntry *fn_entry;	393	FnTableEntry *fn_entry;
394	CastOp cast_op;	394	CastOp cast_op;
395	TypeTableEntry *enum_type;
396	// if cast_op is CastOpArrayToString, this will be a pointer to	395	// if cast_op is CastOpArrayToString, this will be a pointer to
397	// the string struct on the stack	396	// the string struct on the stack
398	LLVMValueRef tmp_ptr;	397	LLVMValueRef tmp_ptr;
...	@@ -429,6 +428,7 @@ struct AstNodeFieldAccessExpr {	...	@@ -429,6 +428,7 @@ struct AstNodeFieldAccessExpr {
429	bool is_fn_call;	428	bool is_fn_call;
430	TypeTableEntry *bare_struct_type;	429	TypeTableEntry *bare_struct_type;
431	bool is_member_fn;	430	bool is_member_fn;
		431	AstNode *container_init_expr_node;
432	};	432	};
433		433
434	struct AstNodeDirective {	434	struct AstNodeDirective {
...	@@ -665,6 +665,7 @@ struct AstNodeContainerInitExpr {	...	@@ -665,6 +665,7 @@ struct AstNodeContainerInitExpr {
665	// populated by semantic analyzer	665	// populated by semantic analyzer
666	StructValExprCodeGen resolved_struct_val_expr;	666	StructValExprCodeGen resolved_struct_val_expr;
667	Expr resolved_expr;	667	Expr resolved_expr;
		668	TypeTableEntry *enum_type;
668	};	669	};
669		670
670	struct AstNodeNullLiteral {	671	struct AstNodeNullLiteral {

src/analyze.cpp+39-25

 @@ -2197,7 +2197,23 @@ static TypeTableEntry *analyze_container_init_expr(CodeGen *g, ImportTableEntry
     ContainerInitKind kind = container_init_expr->kind;
-    TypeTableEntry *container_type = analyze_type_expr(g, import, context, container_init_expr->type);
+    if (container_init_expr->type->type == NodeTypeFieldAccessExpr) {
+        container_init_expr->type->data.field_access_expr.container_init_expr_node = node;
+    }
+    TypeTableEntry *container_meta_type = analyze_expression(g, import, context, nullptr,
+            container_init_expr->type);
+    if (container_meta_type->id == TypeTableEntryIdInvalid) {
+        return g->builtin_types.entry_invalid;
+    }
+    if (node->data.container_init_expr.enum_type) {
+        get_resolved_expr(node)->const_val = get_resolved_expr(container_init_expr->type)->const_val;
+        return node->data.container_init_expr.enum_type;
+    }
+    TypeTableEntry *container_type = resolve_type(g, container_init_expr->type);
     if (container_type->id == TypeTableEntryIdInvalid) {
         return container_type;
 @@ -2322,9 +2338,6 @@ static TypeTableEntry *analyze_container_init_expr(CodeGen *g, ImportTableEntry
     } else if (container_type->id == TypeTableEntryIdArray) {
         zig_panic("TODO array container init");
         return container_type;
-    } else if (container_type->id == TypeTableEntryIdEnum) {
-        zig_panic("TODO enum container init");
-        return container_type;
     } else if (container_type->id == TypeTableEntryIdVoid) {
         if (container_init_expr->entries.length != 0) {
             add_node_error(g, node, buf_sprintf("void expression expects no arguments"));
 @@ -2414,7 +2427,28 @@ 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, node);
+            AstNode *container_init_node = node->data.field_access_expr.container_init_expr_node;
+            AstNode *value_node;
+            if (container_init_node) {
+                assert(container_init_node->type == NodeTypeContainerInitExpr);
+                int param_count = container_init_node->data.container_init_expr.entries.length;
+                if (param_count > 1) {
+                    AstNode *first_invalid_node = container_init_node->data.container_init_expr.entries.at(1);
+                    add_node_error(g, first_executing_node(first_invalid_node),
+                            buf_sprintf("enum values accept only one parameter"));
+                    return child_type;
+                } else {
+                    if (param_count == 1) {
+                        value_node = container_init_node->data.container_init_expr.entries.at(0);
+                    } else {
+                        value_node = nullptr;
+                    }
+                    container_init_node->data.container_init_expr.enum_type = child_type;
+                }
+            } else {
+                value_node = nullptr;
+            }
+            return analyze_enum_value_expr(g, import, context, node, value_node, 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,26 +4759,6 @@ static TypeTableEntry *analyze_fn_call_expr(CodeGen *g, ImportTableEntry *import
                 if (child_type->id == TypeTableEntryIdInvalid) {
                     return g->builtin_types.entry_invalid;
-                } else if (child_type->id == TypeTableEntryIdEnum) {
-                    Buf *field_name = &fn_ref_expr->data.field_access_expr.field_name;
-                    int param_count = node->data.fn_call_expr.params.length;
-                    if (param_count > 1) {
-                        add_node_error(g, first_executing_node(node->data.fn_call_expr.params.at(1)),
-                                buf_sprintf("enum values accept only one parameter"));
-                        return child_type;
-                    } else {
-                        AstNode *value_node;
-                        if (param_count == 1) {
-                            value_node = node->data.fn_call_expr.params.at(0);
-                        } else {
-                            value_node = nullptr;
-                        }
-                        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, node);
-                    }
                 } else if (child_type->id == TypeTableEntryIdStruct) {
                     Buf *field_name = &fn_ref_expr->data.field_access_expr.field_name;
                     BlockContext *container_block_context = get_container_block_context(child_type);

src/codegen.cpp+16-13

 @@ -764,23 +764,11 @@ static LLVMValueRef gen_fn_call_expr(CodeGen *g, AstNode *node) {
         return gen_cast_expr(g, node);
     }
-    AstNode *fn_ref_expr = node->data.fn_call_expr.fn_ref_expr;
-    if (node->data.fn_call_expr.enum_type) {
-        int param_count = node->data.fn_call_expr.params.length;
-        AstNode *arg1_node;
-        if (param_count == 1) {
-            arg1_node = node->data.fn_call_expr.params.at(0);
-        } else {
-            assert(param_count == 0);
-            arg1_node = nullptr;
-        }
-        return gen_enum_value_expr(g, fn_ref_expr, node->data.fn_call_expr.enum_type, arg1_node);
-    }
     FnTableEntry *fn_table_entry = node->data.fn_call_expr.fn_entry;
     TypeTableEntry *struct_type = nullptr;
     AstNode *first_param_expr = nullptr;
+    AstNode *fn_ref_expr = node->data.fn_call_expr.fn_ref_expr;
     if (fn_ref_expr->type == NodeTypeFieldAccessExpr &&
         fn_ref_expr->data.field_access_expr.is_member_fn)
     {
 @@ -2207,6 +2195,21 @@ static LLVMValueRef gen_container_init_expr(CodeGen *g, AstNode *node) {
     TypeTableEntry *type_entry = get_expr_type(node);
+    if (node->data.container_init_expr.enum_type) {
+        int param_count = node->data.container_init_expr.entries.length;
+        AstNode *arg1_node;
+        if (param_count == 1) {
+            arg1_node = node->data.container_init_expr.entries.at(0);
+        } else {
+            assert(param_count == 0);
+            arg1_node = nullptr;
+        }
+        return gen_enum_value_expr(g, node->data.container_init_expr.type,
+                node->data.container_init_expr.enum_type, arg1_node);
+    }
     if (type_entry->id == TypeTableEntryIdStruct) {
         assert(node->data.container_init_expr.kind == ContainerInitKindStruct);

src/eval.cpp+5-4

 @@ -320,6 +320,11 @@ static bool eval_container_init_expr(EvalFn *ef, AstNode *node, ConstExprValue *
     AstNodeContainerInitExpr *container_init_expr = &node->data.container_init_expr;
     ContainerInitKind kind = container_init_expr->kind;
+    if (container_init_expr->enum_type) {
+        zig_panic("TODO");
+    }
     TypeTableEntry *container_type = resolve_expr_type(container_init_expr->type);
     out_val->ok = true;
 @@ -723,10 +728,6 @@ static bool eval_fn_call_expr(EvalFn *ef, AstNode *node, ConstExprValue *out_val
         return false;
     }
-    if (node->data.fn_call_expr.enum_type) {
-        zig_panic("TODO");
-    }
     FnTableEntry *fn_table_entry = node->data.fn_call_expr.fn_entry;
     if (fn_ref_expr->type == NodeTypeFieldAccessExpr &&

test/self_hosted.zig+7-7

...	@@ -353,8 +353,8 @@ fn maybe_type() {	...	@@ -353,8 +353,8 @@ fn maybe_type() {
353		353
354	#attribute("test")	354	#attribute("test")
355	fn enum_type() {	355	fn enum_type() {
356	const foo1 = EnumTypeFoo.One(13);	356	const foo1 = EnumTypeFoo.One {13};
357	const foo2 = EnumTypeFoo.Two(EnumType { .x = 1234, .y = 5678, });	357	const foo2 = EnumTypeFoo.Two {EnumType { .x = 1234, .y = 5678, }};
358	const bar = EnumTypeBar.B;	358	const bar = EnumTypeBar.B;
359		359
360	assert(bar == EnumTypeBar.B);	360	assert(bar == EnumTypeBar.B);
...	@@ -449,7 +449,7 @@ fn should_be_not_equal(a: error, b: error) {	...	@@ -449,7 +449,7 @@ fn should_be_not_equal(a: error, b: error) {
449	#attribute("test")	449	#attribute("test")
450	fn constant_enum_with_payload() {	450	fn constant_enum_with_payload() {
451	var empty = AnEnumWithPayload.Empty;	451	var empty = AnEnumWithPayload.Empty;
452	var full = AnEnumWithPayload.Full(13);	452	var full = AnEnumWithPayload.Full {13};
453	should_be_empty(empty);	453	should_be_empty(empty);
454	should_be_not_empty(full);	454	should_be_not_empty(full);
455	}	455	}
...	@@ -547,8 +547,8 @@ enum SwitchStatmentFoo {	...	@@ -547,8 +547,8 @@ enum SwitchStatmentFoo {
547		547
548	#attribute("test")	548	#attribute("test")
549	fn switch_prong_with_var() {	549	fn switch_prong_with_var() {
550	switch_prong_with_var_fn(SwitchProngWithVarEnum.One(13));	550	switch_prong_with_var_fn(SwitchProngWithVarEnum.One {13});
551	switch_prong_with_var_fn(SwitchProngWithVarEnum.Two(13.0));	551	switch_prong_with_var_fn(SwitchProngWithVarEnum.Two {13.0});
552	switch_prong_with_var_fn(SwitchProngWithVarEnum.Meh);	552	switch_prong_with_var_fn(SwitchProngWithVarEnum.Meh);
553	}	553	}
554	enum SwitchProngWithVarEnum {	554	enum SwitchProngWithVarEnum {
...	@@ -1221,8 +1221,8 @@ struct Test3Point {	...	@@ -1221,8 +1221,8 @@ struct Test3Point {
1221	x: i32,	1221	x: i32,
1222	y: i32,	1222	y: i32,
1223	}	1223	}
1224	const test3_foo = Test3Foo.Three(Test3Point {.x = 3, .y = 4});	1224	const test3_foo = Test3Foo.Three{Test3Point {.x = 3, .y = 4}};
1225	const test3_bar = Test3Foo.Two(13);	1225	const test3_bar = Test3Foo.Two{13};
1226	#static_eval_enable(false)	1226	#static_eval_enable(false)
1227	fn test3_1(f: Test3Foo) {	1227	fn test3_1(f: Test3Foo) {
1228	switch (f) {	1228	switch (f) {

author	Andrew Kelley <andrew@ziglang.org> 2016-04-19 18:52:09-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2016-04-19 18:52:09-07:00
log	36c6acfc76eeeed1498b5cc9ecb3137214e69bbf
tree	40e2ffa30130a2ed1dd8f5674843237b108176f6
parent	7a7f83033c3fee3e92046b76dd33b9f8ded4f0fd

enum init uses container init syntax instead of fn call