Index: src/Parser/DeclarationNode.cc
===================================================================
--- src/Parser/DeclarationNode.cc	(revision 92538ab6b62a97cccbb9045dcd6004887dec9529)
+++ src/Parser/DeclarationNode.cc	(revision f6e6a55d53cd8b3b09c6daaeee01773aff551e6f)
@@ -253,5 +253,5 @@
 } // DeclarationNode::newAggregate
 
-DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body, bool typed) {
+DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body) {
 	DeclarationNode * newnode = new DeclarationNode;
 	newnode->type = new TypeData( TypeData::Enum );
@@ -272,9 +272,23 @@
 } // DeclarationNode::newName
 
-DeclarationNode * DeclarationNode::newEnumConstant( const string * name, ExpressionNode * constant ) { // Marker
+DeclarationNode * DeclarationNode::newEnumConstant( const string * name, ExpressionNode * constant ) {
 	DeclarationNode * newnode = newName( name );
 	newnode->enumeratorValue.reset( constant );
 	return newnode;
 } // DeclarationNode::newEnumConstant
+
+DeclarationNode * DeclarationNode::newEnumValueGeneric( const string * name, InitializerNode * init ) {
+	if ( init ) { // list init {} or a singleInit
+		if ( init->get_expression() ) { // singleInit
+			return newEnumConstant( name, init->get_expression() );
+		} else { // TODO: listInit
+			DeclarationNode * newnode = newName( name );
+			newnode->initializer = init;
+			return newnode;
+		} // if
+	} else {
+		return newName( name ); // Not explicitly inited enum value;
+	} // if
+} // DeclarationNode::newEnumGeneric
 
 DeclarationNode * DeclarationNode::newFromTypedef( const string * name ) {
Index: src/Parser/InitializerNode.cc
===================================================================
--- src/Parser/InitializerNode.cc	(revision 92538ab6b62a97cccbb9045dcd6004887dec9529)
+++ src/Parser/InitializerNode.cc	(revision f6e6a55d53cd8b3b09c6daaeee01773aff551e6f)
@@ -101,4 +101,5 @@
 	} else {
 		if ( get_expression() ) {
+			assertf( get_expression()->expr, "The expression of initializer must have value" );
 			return new SingleInit( maybeBuild< Expression >( get_expression() ), maybeConstructed );
 		} // if
Index: src/Parser/ParseNode.h
===================================================================
--- src/Parser/ParseNode.h	(revision 92538ab6b62a97cccbb9045dcd6004887dec9529)
+++ src/Parser/ParseNode.h	(revision f6e6a55d53cd8b3b09c6daaeee01773aff551e6f)
@@ -235,6 +235,7 @@
 	static DeclarationNode * newFunction( const std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body );
 	static DeclarationNode * newAggregate( AggregateDecl::Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
-	static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, bool typed );
+	static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body );
 	static DeclarationNode * newEnumConstant( const std::string * name, ExpressionNode * constant );
+	static DeclarationNode * newEnumValueGeneric( const std::string * name, InitializerNode * init );
 	static DeclarationNode * newName( const std::string * );
 	static DeclarationNode * newFromTypeGen( const std::string *, ExpressionNode * params );
Index: src/Parser/parser.yy
===================================================================
--- src/Parser/parser.yy	(revision 92538ab6b62a97cccbb9045dcd6004887dec9529)
+++ src/Parser/parser.yy	(revision f6e6a55d53cd8b3b09c6daaeee01773aff551e6f)
@@ -380,5 +380,5 @@
 
 %type<decl> enumerator_list enum_type enum_type_nobody
-%type<en> enumerator_value_opt
+%type<in> enumerator_value_opt
 
 %type<decl> external_definition external_definition_list external_definition_list_opt
@@ -2305,20 +2305,18 @@
 enum_type: // static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, bool typed );												// enum
 	ENUM attribute_list_opt '{' enumerator_list comma_opt '}'
-		{ $$ = DeclarationNode::newEnum( nullptr, $4, true, false )->addQualifiers( $2 ); }
+		{ $$ = DeclarationNode::newEnum( nullptr, $4, true )->addQualifiers( $2 ); }
 	| ENUM attribute_list_opt identifier
 		{ typedefTable.makeTypedef( *$3 ); }
 	  '{' enumerator_list comma_opt '}'
-		{ $$ = DeclarationNode::newEnum( $3, $6, true, false )->addQualifiers( $2 ); }
+		{ $$ = DeclarationNode::newEnum( $3, $6, true )->addQualifiers( $2 ); }
 	| ENUM attribute_list_opt typedef_name				// unqualified type name
 	  '{' enumerator_list comma_opt '}'
-		{ $$ = DeclarationNode::newEnum( $3->name, $5, true, false )->addQualifiers( $2 ); }
+		{ $$ = DeclarationNode::newEnum( $3->name, $5, true )->addQualifiers( $2 ); }
 	| ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt '{' enumerator_list comma_opt '}'
 	 	{
 			if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) 
 			{ SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
-			// SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr;
-
-			$$ = DeclarationNode::newEnum( nullptr, $7, true, true ) ->addQualifiers( $5 )  -> addEnumBase( $3 );
-			// $$ = DeclarationNode::newEnum( nullptr, $7, true, true ) ->addQualifiers( $5 );
+
+			$$ = DeclarationNode::newEnum( nullptr, $7, true ) ->addQualifiers( $5 )  -> addEnumBase( $3 );
 		}
 	| ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt // Question: why attributes/qualifier after identifier
@@ -2329,6 +2327,5 @@
 	  '{' enumerator_list comma_opt '}'
 		{
-			$$ = DeclarationNode::newEnum( $6, $10, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 ) -> addEnumBase( $3 );
-			// $$ = DeclarationNode::newEnum( $6, $10, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 );
+			$$ = DeclarationNode::newEnum( $6, $10, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 ) -> addEnumBase( $3 );
 		}
 	| ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt typedef_name attribute_list_opt '{' enumerator_list comma_opt '}'
@@ -2336,6 +2333,5 @@
 			if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
 			typedefTable.makeTypedef( *$6->name );
-			$$ = DeclarationNode::newEnum( $6->name, $9, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 ) -> addEnumBase( $3 );
-			// $$ = DeclarationNode::newEnum( $6->name, $9, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 );
+			$$ = DeclarationNode::newEnum( $6->name, $9, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 ) -> addEnumBase( $3 );
 		}
 	| enum_type_nobody
@@ -2344,18 +2340,18 @@
 enum_type_nobody:										// enum - {...}
 	ENUM attribute_list_opt identifier
-		{ typedefTable.makeTypedef( *$3 ); $$ = DeclarationNode::newEnum( $3, 0, false, false )->addQualifiers( $2 ); }
+		{ typedefTable.makeTypedef( *$3 ); $$ = DeclarationNode::newEnum( $3, 0, false )->addQualifiers( $2 ); }
 	| ENUM attribute_list_opt type_name					// qualified type name
-		{ typedefTable.makeTypedef( *$3->type->symbolic.name );	$$ = DeclarationNode::newEnum( $3->type->symbolic.name, 0, false, false )->addQualifiers( $2 ); }
+		{ typedefTable.makeTypedef( *$3->type->symbolic.name );	$$ = DeclarationNode::newEnum( $3->type->symbolic.name, 0, false )->addQualifiers( $2 ); }
 	;
 
 enumerator_list:
 	identifier_or_type_name enumerator_value_opt
-		{ $$ = DeclarationNode::newEnumConstant( $1, $2 ); }
+		{ $$ = DeclarationNode::newEnumValueGeneric( $1, $2 ); }
 	| INLINE type_name
-		{ $$ = DeclarationNode::newEnumConstant( new string("inline"), nullptr ); }
+		{ $$ = DeclarationNode::newEnumValueGeneric( new string("inline"), nullptr ); }
 	| enumerator_list ',' identifier_or_type_name enumerator_value_opt
-		{ $$ = $1->appendList( DeclarationNode::newEnumConstant( $3, $4 ) ); }
+		{ $$ = $1->appendList( DeclarationNode::newEnumValueGeneric( $3, $4 ) ); }
 	| enumerator_list ',' INLINE type_name enumerator_value_opt
-		{ $$ = $1->appendList( DeclarationNode::newEnumConstant( new string("inline"), nullptr ) ); }
+		{ $$ = $1->appendList( DeclarationNode::newEnumValueGeneric( new string("inline"), nullptr ) ); }
 	;
 
@@ -2366,5 +2362,5 @@
 	// 	{ $$ = $2; }
 	| simple_assignment_operator initializer
-		{ $$ = $2->get_expression(); }					// FIX ME: enum only deals with constant_expression
+		{ $$ = $1 == OperKinds::Assign ? $2 : $2->set_maybeConstructed( false ); }
 	;