Index: src/AST/Convert.cpp
===================================================================
--- src/AST/Convert.cpp	(revision 22a0e87773a1349ca1fc9e5424761686202011e2)
+++ src/AST/Convert.cpp	(revision 93d2219a70113e973cd8ff2d973d1fdec40ac805)
@@ -234,4 +234,11 @@
 		}
 		return declWithTypePostamble( decl, node );
+	}
+
+	// InlineValueDecl vanish after EnumAndPointerDecay pass so no necessary to implement NewToOld
+	const ast::DeclWithType * visit( const ast::InlineValueDecl * node ) override final {	
+		assert( false );
+		(void) node;
+		return nullptr;
 	}
 
@@ -1863,4 +1870,32 @@
 	}
 
+	virtual void visit( const InlineValueDecl * old ) override final {
+		if ( inCache( old ) ) {
+			return;
+		}
+		auto&& type = GET_ACCEPT_1(type, Type);
+		auto&& attr = GET_ACCEPT_V(attributes, Attribute);
+ 
+		auto decl = new ast::InlineValueDecl(
+			old->location,
+			old->name,
+			type,
+			{ old->get_storageClasses().val },
+			{ old->linkage.val },
+			std::move(attr),
+			{ old->get_funcSpec().val }
+		);
+		cache.emplace(old, decl);
+		assert(cache.find( old ) != cache.end());
+		decl->scopeLevel = old->scopeLevel;
+		decl->mangleName = old->mangleName;
+		decl->isDeleted  = old->isDeleted;
+		decl->asmName    = GET_ACCEPT_1(asmName, Expr);
+		decl->uniqueId   = old->uniqueId;
+		decl->extension  = old->extension;
+
+		this->node = decl;
+	}
+
 	virtual void visit( const CompoundStmt * old ) override final {
 		if ( inCache( old ) ) return;
Index: src/AST/Decl.hpp
===================================================================
--- src/AST/Decl.hpp	(revision 22a0e87773a1349ca1fc9e5424761686202011e2)
+++ src/AST/Decl.hpp	(revision 93d2219a70113e973cd8ff2d973d1fdec40ac805)
@@ -414,4 +414,21 @@
 };
 
+class InlineValueDecl final : public DeclWithType {
+public:
+	ptr<Type> type;
+
+	InlineValueDecl( const CodeLocation & loc, const std::string & name, const Type * type,
+		Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::Cforall,
+		std::vector< ptr<Attribute> > && attrs = {}, Function::Specs fs = {} )
+	: DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), type( type ) {}
+
+	const Type * get_type() const override { return type; }
+	void set_type( const Type * ty ) override { type = ty; }
+
+	const DeclWithType * accept( Visitor& v ) const override { return v.visit( this ); }
+private:
+	InlineValueDecl * clone() const override { return new InlineValueDecl{ *this }; }
+	MUTATE_FRIEND
+};
 }
 
Index: src/AST/Fwd.hpp
===================================================================
--- src/AST/Fwd.hpp	(revision 22a0e87773a1349ca1fc9e5424761686202011e2)
+++ src/AST/Fwd.hpp	(revision 93d2219a70113e973cd8ff2d973d1fdec40ac805)
@@ -37,4 +37,5 @@
 class DirectiveDecl;
 class StaticAssertDecl;
+class InlineValueDecl;
 
 class Stmt;
Index: src/AST/Pass.hpp
===================================================================
--- src/AST/Pass.hpp	(revision 22a0e87773a1349ca1fc9e5424761686202011e2)
+++ src/AST/Pass.hpp	(revision 93d2219a70113e973cd8ff2d973d1fdec40ac805)
@@ -141,4 +141,5 @@
 	const ast::DirectiveDecl *    visit( const ast::DirectiveDecl        * ) override final;
 	const ast::StaticAssertDecl * visit( const ast::StaticAssertDecl     * ) override final;
+	const ast::DeclWithType	*     visit( const ast::InlineValueDecl      * ) override final;
 	const ast::CompoundStmt *     visit( const ast::CompoundStmt         * ) override final;
 	const ast::Stmt *             visit( const ast::ExprStmt             * ) override final;
Index: src/AST/Pass.impl.hpp
===================================================================
--- src/AST/Pass.impl.hpp	(revision 22a0e87773a1349ca1fc9e5424761686202011e2)
+++ src/AST/Pass.impl.hpp	(revision 93d2219a70113e973cd8ff2d973d1fdec40ac805)
@@ -803,4 +803,20 @@
 
 //--------------------------------------------------------------------------
+// DeclWithType
+template< typename core_t >
+const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::InlineValueDecl * node ) {
+	VISIT_START( node );
+
+	if ( __visit_children() ) {
+		{
+			guard_symtab guard { *this };
+			maybe_accept( node, &InlineValueDecl::type );
+		}
+	}
+
+	VISIT_END( DeclWithType, node );
+}
+
+//--------------------------------------------------------------------------
 // CompoundStmt
 template< typename core_t >
Index: src/AST/Print.cpp
===================================================================
--- src/AST/Print.cpp	(revision 22a0e87773a1349ca1fc9e5424761686202011e2)
+++ src/AST/Print.cpp	(revision 93d2219a70113e973cd8ff2d973d1fdec40ac805)
@@ -398,4 +398,11 @@
 	virtual const ast::Decl * visit( const ast::StructDecl * node ) override final {
 		print(node);
+		return node;
+	}
+
+	virtual const ast::DeclWithType * visit( const ast::InlineValueDecl * node ) override final {
+		os << "inline ";
+		if ( ! node->name.empty() ) os << node->name;
+
 		return node;
 	}
Index: src/AST/Visitor.hpp
===================================================================
--- src/AST/Visitor.hpp	(revision 22a0e87773a1349ca1fc9e5424761686202011e2)
+++ src/AST/Visitor.hpp	(revision 93d2219a70113e973cd8ff2d973d1fdec40ac805)
@@ -33,4 +33,5 @@
     virtual const ast::DirectiveDecl *    visit( const ast::DirectiveDecl        * ) = 0;
     virtual const ast::StaticAssertDecl * visit( const ast::StaticAssertDecl     * ) = 0;
+    virtual const ast::DeclWithType *     visit( const ast::InlineValueDecl      * ) = 0;
     virtual const ast::CompoundStmt *     visit( const ast::CompoundStmt         * ) = 0;
     virtual const ast::Stmt *             visit( const ast::ExprStmt             * ) = 0;
Index: src/Common/CodeLocationTools.cpp
===================================================================
--- src/Common/CodeLocationTools.cpp	(revision 22a0e87773a1349ca1fc9e5424761686202011e2)
+++ src/Common/CodeLocationTools.cpp	(revision 93d2219a70113e973cd8ff2d973d1fdec40ac805)
@@ -111,4 +111,5 @@
     macro(DirectiveDecl, DirectiveDecl) \
     macro(StaticAssertDecl, StaticAssertDecl) \
+    macro(InlineValueDecl, DeclWithType) \
     macro(CompoundStmt, CompoundStmt) \
     macro(ExprStmt, Stmt) \
Index: src/Common/PassVisitor.h
===================================================================
--- src/Common/PassVisitor.h	(revision 22a0e87773a1349ca1fc9e5424761686202011e2)
+++ src/Common/PassVisitor.h	(revision 93d2219a70113e973cd8ff2d973d1fdec40ac805)
@@ -81,4 +81,6 @@
 	virtual void visit( StaticAssertDecl * assertDecl ) override final;
 	virtual void visit( const StaticAssertDecl * assertDecl ) override final;
+	virtual void visit( InlineValueDecl * valueDecl ) override final;
+	virtual void visit( const InlineValueDecl * valueDecl ) override final;
 
 	virtual void visit( CompoundStmt * compoundStmt ) override final;
@@ -273,4 +275,5 @@
 	virtual DirectiveDecl * mutate( DirectiveDecl * directiveDecl ) override final;
 	virtual StaticAssertDecl * mutate( StaticAssertDecl * assertDecl ) override final;
+	virtual DeclarationWithType * mutate( InlineValueDecl * valueDecl ) override final;
 
 	virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ) override final;
Index: src/Common/PassVisitor.impl.h
===================================================================
--- src/Common/PassVisitor.impl.h	(revision 22a0e87773a1349ca1fc9e5424761686202011e2)
+++ src/Common/PassVisitor.impl.h	(revision 93d2219a70113e973cd8ff2d973d1fdec40ac805)
@@ -1047,4 +1047,33 @@
 
 //--------------------------------------------------------------------------
+// InlineValueDecl
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( InlineValueDecl * node ) {
+	VISIT_START( node );
+
+	maybeAccept_impl( node->type, *this );
+
+	VISIT_END( node );
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( const InlineValueDecl * node ) {
+	VISIT_START( node );
+
+	maybeAccept_impl( node->type, *this );
+
+	VISIT_END( node );
+}
+
+template< typename pass_type >
+DeclarationWithType * PassVisitor< pass_type >::mutate( InlineValueDecl * node ) {
+	MUTATE_START( node );
+
+	maybeMutate_impl( node->type, *this );
+
+	MUTATE_END( DeclarationWithType, node );
+}
+
+//--------------------------------------------------------------------------
 // CompoundStmt
 template< typename pass_type >
Index: src/Parser/DeclarationNode.cc
===================================================================
--- src/Parser/DeclarationNode.cc	(revision 22a0e87773a1349ca1fc9e5424761686202011e2)
+++ src/Parser/DeclarationNode.cc	(revision 93d2219a70113e973cd8ff2d973d1fdec40ac805)
@@ -27,5 +27,5 @@
 #include "SynTree/LinkageSpec.h"   // for Spec, linkageName, Cforall
 #include "SynTree/Attribute.h"     // for Attribute
-#include "SynTree/Declaration.h"   // for TypeDecl, ObjectDecl, Declaration
+#include "SynTree/Declaration.h"   // for TypeDecl, ObjectDecl, InlineValueDecl, Declaration
 #include "SynTree/Expression.h"    // for Expression, ConstantExpr
 #include "SynTree/Statement.h"     // for AsmStmt
@@ -1165,4 +1165,7 @@
 		SemanticError( this, "invalid function specifier for " );
 	} // if
+	if ( enumInLine ) {
+		return new InlineValueDecl( *name, storageClasses, linkage, nullptr );
+	} // if
 	assertf( name, "ObjectDecl must a have name\n" );
 	return (new ObjectDecl( *name, storageClasses, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_asmName( asmName )->set_extension( extension );
Index: src/Parser/ExpressionNode.cc
===================================================================
--- src/Parser/ExpressionNode.cc	(revision 22a0e87773a1349ca1fc9e5424761686202011e2)
+++ src/Parser/ExpressionNode.cc	(revision 93d2219a70113e973cd8ff2d973d1fdec40ac805)
@@ -519,10 +519,5 @@
 		}
 	}
-	auto ret =  new QualifiedNameExpr( newDecl, name->name );
-	if ( auto e = dynamic_cast<EnumDecl*>(newDecl) ) {
-		auto enumInst = new EnumInstType( Type::Qualifiers(), e );
-		auto obj = new ObjectDecl( name->name, Type::StorageClasses(), LinkageSpec::Cforall, nullptr, enumInst, nullptr );
-	}
-	return ret;
+	return new QualifiedNameExpr( newDecl, name->name );
 }
 
Index: src/Parser/TypeData.cc
===================================================================
--- src/Parser/TypeData.cc	(revision 22a0e87773a1349ca1fc9e5424761686202011e2)
+++ src/Parser/TypeData.cc	(revision 93d2219a70113e973cd8ff2d973d1fdec40ac805)
@@ -925,9 +925,6 @@
 	for ( const DeclarationNode * cur = td->enumeration.constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) {
 		if ( cur->enumInLine ) {
-			// Tell the compiler this is a inline value placeholder
-			ObjectDecl * member = dynamic_cast< ObjectDecl* >(* members);
-			member->enumInLine = true;
-		}
-		if ( ret->isTyped && !ret->base && cur->has_enumeratorValue() ) {
+			// Do Nothing
+		} else if ( ret->isTyped && !ret->base && cur->has_enumeratorValue() ) {
 			SemanticError( td->location, "Enumerator of enum(void) cannot have an explicit initializer value." );
 		} else if ( cur->has_enumeratorValue() ) {
Index: src/ResolvExpr/CommonType.cc
===================================================================
--- src/ResolvExpr/CommonType.cc	(revision 22a0e87773a1349ca1fc9e5424761686202011e2)
+++ src/ResolvExpr/CommonType.cc	(revision 93d2219a70113e973cd8ff2d973d1fdec40ac805)
@@ -991,5 +991,4 @@
 				add_qualifiers( result, type2->qualifiers );
 			} else {
-				// xxx - does unifying a ref with typed enumInst makes sense?
 				if (!dynamic_cast<const ast::EnumInstType *>(type2))
 					result = commonType( type2, ref, tenv, need, have, open, widen, symtab );
@@ -1010,6 +1009,4 @@
 
 		void postvisit( const ast::EnumInstType * enumInst ) {
-			// reuse BasicType/EnumInstType common type by swapping
-			// xxx - is this already handled by unify?
 			if (!dynamic_cast<const ast::EnumInstType *>(type2))
 				result = commonType( type2, enumInst, tenv, need, have, open, widen, symtab);
Index: src/ResolvExpr/ConversionCost.cc
===================================================================
--- src/ResolvExpr/ConversionCost.cc	(revision 22a0e87773a1349ca1fc9e5424761686202011e2)
+++ src/ResolvExpr/ConversionCost.cc	(revision 93d2219a70113e973cd8ff2d973d1fdec40ac805)
@@ -720,5 +720,4 @@
 		costCalc( baseType, dst, srcIsLvalue, symtab, env );
 	} else {
-		(void)enumInstType;
 		static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
 		cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
Index: src/SynTree/Declaration.h
===================================================================
--- src/SynTree/Declaration.h	(revision 22a0e87773a1349ca1fc9e5424761686202011e2)
+++ src/SynTree/Declaration.h	(revision 93d2219a70113e973cd8ff2d973d1fdec40ac805)
@@ -449,4 +449,29 @@
 };
 
+
+class InlineValueDecl : public DeclarationWithType {
+	typedef DeclarationWithType Parent;
+  public:
+	Type * type;
+
+	InlineValueDecl( const std::string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage, Type * type,
+				const std::list< Attribute * > attributes = std::list< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
+	InlineValueDecl( const InlineValueDecl & other );
+	virtual ~InlineValueDecl();
+
+	virtual Type * get_type() const override { return type; }
+	virtual void set_type(Type * newType) override { type = newType; }
+
+	static InlineValueDecl * newInlineValueDecl( const std::string & name, Type * type );
+
+	virtual InlineValueDecl * clone() const override { return new InlineValueDecl( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual void accept( Visitor & v ) const override { v.visit( this ); }
+	virtual DeclarationWithType * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+	virtual void printShort( std::ostream & os, Indenter indent = {} ) const override;
+
+};
+
 std::ostream & operator<<( std::ostream & os, const TypeDecl::Data & data );
 
Index: src/SynTree/Mutator.h
===================================================================
--- src/SynTree/Mutator.h	(revision 22a0e87773a1349ca1fc9e5424761686202011e2)
+++ src/SynTree/Mutator.h	(revision 93d2219a70113e973cd8ff2d973d1fdec40ac805)
@@ -36,4 +36,5 @@
 	virtual DirectiveDecl * mutate( DirectiveDecl * directiveDecl ) = 0;
 	virtual StaticAssertDecl * mutate( StaticAssertDecl * assertDecl ) = 0;
+	virtual DeclarationWithType * mutate( InlineValueDecl * inlineValueDecl ) = 0;
 
 	virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ) = 0;
Index: src/SynTree/SynTree.h
===================================================================
--- src/SynTree/SynTree.h	(revision 22a0e87773a1349ca1fc9e5424761686202011e2)
+++ src/SynTree/SynTree.h	(revision 93d2219a70113e973cd8ff2d973d1fdec40ac805)
@@ -38,4 +38,5 @@
 class DirectiveDecl;
 class StaticAssertDecl;
+class InlineValueDecl;
 
 class Statement;
Index: src/SynTree/Visitor.h
===================================================================
--- src/SynTree/Visitor.h	(revision 22a0e87773a1349ca1fc9e5424761686202011e2)
+++ src/SynTree/Visitor.h	(revision 93d2219a70113e973cd8ff2d973d1fdec40ac805)
@@ -49,4 +49,6 @@
 	virtual void visit( StaticAssertDecl * node ) { visit( const_cast<const StaticAssertDecl *>(node) ); }
 	virtual void visit( const StaticAssertDecl * assertDecl ) = 0;
+	virtual void visit( InlineValueDecl * node ) { visit( const_cast<const InlineValueDecl *>(node) ); }
+	virtual void visit( const InlineValueDecl * valueDecl ) = 0;
 
 	virtual void visit( CompoundStmt * node ) { visit( const_cast<const CompoundStmt *>(node) ); }
Index: src/SynTree/module.mk
===================================================================
--- src/SynTree/module.mk	(revision 22a0e87773a1349ca1fc9e5424761686202011e2)
+++ src/SynTree/module.mk	(revision 93d2219a70113e973cd8ff2d973d1fdec40ac805)
@@ -42,4 +42,5 @@
       SynTree/Initializer.cc \
       SynTree/Initializer.h \
+      SynTree/InlineValueDecl.cc \
       SynTree/Label.h \
       SynTree/LinkageSpec.cc \
Index: src/Validate/EnumAndPointerDecay.cpp
===================================================================
--- src/Validate/EnumAndPointerDecay.cpp	(revision 22a0e87773a1349ca1fc9e5424761686202011e2)
+++ src/Validate/EnumAndPointerDecay.cpp	(revision 93d2219a70113e973cd8ff2d973d1fdec40ac805)
@@ -21,4 +21,5 @@
 #include "AST/Type.hpp"
 #include "SymTab/FixFunction.h"
+#include "Validate/NoIdSymbolTable.hpp"
 
 namespace Validate {
@@ -26,5 +27,5 @@
 namespace {
 
-struct EnumAndPointerDecayCore final : public ast::WithCodeLocation {
+struct EnumAndPointerDecayCore final : public WithNoIdSymbolTable, public ast::WithCodeLocation {
 	ast::EnumDecl const * previsit( ast::EnumDecl const * decl );
 	ast::FunctionDecl const * previsit( ast::FunctionDecl const * decl );
@@ -39,9 +40,29 @@
 	// Set the type of each member of the enumeration to be EnumContant.
 	auto mut = ast::mutate( decl );
-	for ( ast::ptr<ast::Decl> & member : mut->members ) {
-		ast::ObjectDecl const * object = member.strict_as<ast::ObjectDecl>();
-		member = ast::mutate_field( object, &ast::ObjectDecl::type,
-			new ast::EnumInstType( decl, ast::CV::Const ) );
+	std::vector<ast::ptr<ast::Decl>> buffer;
+	for ( auto it = decl->members.begin(); it != decl->members.end(); ++it ) {
+		if ( ast::ObjectDecl const * object = (*it).as<ast::ObjectDecl>() ) {
+			buffer.push_back( ast::mutate_field( object, &ast::ObjectDecl::type, new ast::EnumInstType( decl, ast::CV::Const ) ) );
+		} else if ( ast::InlineValueDecl const * value = (*it).as<ast::InlineValueDecl>() ) {
+			if ( auto targetEnum = symtab.lookupEnum( value->name ) ) {
+				for ( auto singleMember : targetEnum->members ) {
+					auto copyingMember = singleMember.as<ast::ObjectDecl>();
+					buffer.push_back( new ast::ObjectDecl(
+						value->location, // use the "inline" location
+						copyingMember->name,
+						new ast::EnumInstType( decl, ast::CV::Const ),
+						// Construct a new EnumInstType as the type
+						copyingMember->init,
+						copyingMember->storage,
+						copyingMember->linkage,
+						copyingMember->bitfieldWidth,
+						{},
+						copyingMember->funcSpec
+					) );
+				}
+			}
+		}
 	}
+	mut->members = buffer;
 	return mut;
 }
Index: src/Validate/LinkReferenceToTypes.cpp
===================================================================
--- src/Validate/LinkReferenceToTypes.cpp	(revision 22a0e87773a1349ca1fc9e5424761686202011e2)
+++ src/Validate/LinkReferenceToTypes.cpp	(revision 93d2219a70113e973cd8ff2d973d1fdec40ac805)
@@ -185,4 +185,5 @@
 				decl = mut;
 			}
+			// visit the base
 		} else if ( auto ptr = decl->base.as<ast::PointerType>() ) {
 			if ( auto base = ptr->base.as<ast::TypeInstType>() ) {
@@ -203,43 +204,4 @@
 
 	// The following section 
-	auto mut = ast::mutate( decl );
-	std::vector<ast::ptr<ast::Decl>> buffer;
-	for ( auto it = decl->members.begin(); it != decl->members.end(); ++it) {
-		auto member = (*it).as<ast::ObjectDecl>();
-		if ( member->enumInLine ) {
-			auto targetEnum = symtab.lookupEnum( member->name );
-			if ( targetEnum ) {			
-				for ( auto singleMamber : targetEnum->members ) {
-					auto tm = singleMamber.as<ast::ObjectDecl>();
-					auto t = new ast::ObjectDecl(
-						member->location, // use the "inline" location
-						tm->name,
-						new ast::EnumInstType( decl, ast::CV::Const ),
-						// Construct a new EnumInstType as the type
-						tm->init,
-						tm->storage,
-						tm->linkage,
-						tm->bitfieldWidth,
-						{}, // enum member doesn't have attribute
-						tm->funcSpec
-					);
-					t->importValue = true;
-					buffer.push_back(t);
-				}
-			}
-		} else {
-			auto search_it = std::find_if( buffer.begin(), buffer.end(), [member](ast::ptr<ast::Decl> cur) {
-				auto curAsObjDecl = cur.as<ast::ObjectDecl>();
-				return (curAsObjDecl->importValue) && (curAsObjDecl->name == member->name);
-			});
-			if ( search_it != buffer.end() ) {
-				buffer.erase( search_it ); // Found an import enum value that has the same name
-				// override the imported value
-			}
-			buffer.push_back( *it );
-		}
-	}
-	mut->members = buffer;
-	decl = mut;
 
 	ForwardEnumsType::iterator fwds = forwardEnums.find( decl->name );
Index: tests/enum_tests/.expect/enumInlineValue.txt
===================================================================
--- tests/enum_tests/.expect/enumInlineValue.txt	(revision 22a0e87773a1349ca1fc9e5424761686202011e2)
+++ tests/enum_tests/.expect/enumInlineValue.txt	(revision 93d2219a70113e973cd8ff2d973d1fdec40ac805)
@@ -1,4 +1,4 @@
 enumB.A is 5
-enumB.B is 10
+enumB.B is 6
 enumB.D is 11
 enumB.E is 12
Index: tests/enum_tests/.expect/qualifiedEnum.cfa
===================================================================
--- tests/enum_tests/.expect/qualifiedEnum.cfa	(revision 22a0e87773a1349ca1fc9e5424761686202011e2)
+++ tests/enum_tests/.expect/qualifiedEnum.cfa	(revision 93d2219a70113e973cd8ff2d973d1fdec40ac805)
@@ -1,1 +1,1 @@
-l :0
+l :1
Index: tests/enum_tests/enumInlineValue.cfa
===================================================================
--- tests/enum_tests/enumInlineValue.cfa	(revision 22a0e87773a1349ca1fc9e5424761686202011e2)
+++ tests/enum_tests/enumInlineValue.cfa	(revision 93d2219a70113e973cd8ff2d973d1fdec40ac805)
@@ -6,5 +6,5 @@
 enum enumB {
     inline enumA,
-    E, B=10
+    E
 };
 
Index: tests/enum_tests/qualifiedEnum.cfa
===================================================================
--- tests/enum_tests/qualifiedEnum.cfa	(revision 22a0e87773a1349ca1fc9e5424761686202011e2)
+++ tests/enum_tests/qualifiedEnum.cfa	(revision 93d2219a70113e973cd8ff2d973d1fdec40ac805)
@@ -8,5 +8,5 @@
 
 int main() {
-    enum Level l = Level.LOW;
+    enum Level l = Level.MEDIUM;
     sout | "l :" | l;
     return 0;
