Index: src/Parser/DeclarationNode.cc
===================================================================
--- src/Parser/DeclarationNode.cc	(revision 79ae13d5c771bea08f4655712505e7fa1a8fc73a)
+++ src/Parser/DeclarationNode.cc	(revision dc56b9d88cf82f868f003d67991e756cbbd93bf1)
@@ -254,5 +254,5 @@
 } // DeclarationNode::newAggregate
 
-DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body, DeclarationNode * base) {
+DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body, bool typed, DeclarationNode * base) {
 	DeclarationNode * newnode = new DeclarationNode;
 	newnode->type = new TypeData( TypeData::Enum );
@@ -261,9 +261,9 @@
 	newnode->type->enumeration.body = body;
 	newnode->type->enumeration.anon = name == nullptr;
+	newnode->type->enumeration.typed = typed;
 	if ( base && base->type)  {
 		newnode->type->base = base->type;
 	} // if
 
-	// Check: if base has TypeData
 	return newnode;
 } // DeclarationNode::newEnum
@@ -285,8 +285,8 @@
 
 DeclarationNode * DeclarationNode::newEnumValueGeneric( const string * name, InitializerNode * init ) {
-	if ( init ) { // list init {} or a singleInit
-		if ( init->get_expression() ) { // singleInit
+	if ( init ) {
+		if ( init->get_expression() ) {
 			return newEnumConstant( name, init->get_expression() );
-		} else { // TODO: listInit
+		} else {
 			DeclarationNode * newnode = newName( name );
 			newnode->initializer = init;
@@ -294,5 +294,5 @@
 		} // if
 	} else {
-		return newName( name ); // Not explicitly inited enum value;
+		return newName( name );
 	} // if
 } // DeclarationNode::newEnumValueGeneric
Index: src/Parser/ExpressionNode.cc
===================================================================
--- src/Parser/ExpressionNode.cc	(revision 79ae13d5c771bea08f4655712505e7fa1a8fc73a)
+++ src/Parser/ExpressionNode.cc	(revision dc56b9d88cf82f868f003d67991e756cbbd93bf1)
@@ -509,4 +509,28 @@
 } // build_varref
 
+QualifiedNameExpr * build_qualified_expr( const DeclarationNode * decl_node, const NameExpr * name ) {
+	Declaration * newDecl = maybeBuild< Declaration >(decl_node);
+	if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) {
+		const Type * t = newDeclWithType->get_type();
+		if ( t ) {
+			if ( const TypeInstType * typeInst = dynamic_cast<const TypeInstType *>( t ) ) {
+				newDecl= new EnumDecl( typeInst->name );
+			}
+		}
+	}
+	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 );
+		ret->set_var( obj );
+	}
+	return ret;
+}
+
+QualifiedNameExpr * build_qualified_expr( const EnumDecl * decl_node, const NameExpr * name ) {
+	EnumDecl * newDecl = const_cast< EnumDecl * >( decl_node );
+	return new QualifiedNameExpr( newDecl, name->name );
+}
+
 DimensionExpr * build_dimensionref( const string * name ) {
 	DimensionExpr * expr = new DimensionExpr( *name );
Index: src/Parser/ParseNode.h
===================================================================
--- src/Parser/ParseNode.h	(revision 79ae13d5c771bea08f4655712505e7fa1a8fc73a)
+++ src/Parser/ParseNode.h	(revision dc56b9d88cf82f868f003d67991e756cbbd93bf1)
@@ -183,4 +183,6 @@
 
 NameExpr * build_varref( const std::string * name );
+QualifiedNameExpr * build_qualified_expr( const DeclarationNode * decl_node, const NameExpr * name );
+QualifiedNameExpr * build_qualified_expr( const EnumDecl * decl, const NameExpr * name );
 DimensionExpr * build_dimensionref( const std::string * name );
 
@@ -235,5 +237,5 @@
 	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, DeclarationNode * base = nullptr );
+	static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, bool typed, DeclarationNode * base = nullptr );
 	static DeclarationNode * newEnumConstant( const std::string * name, ExpressionNode * constant );
 	static DeclarationNode * newEnumValueGeneric( const std::string * name, InitializerNode * init );
Index: src/Parser/TypeData.cc
===================================================================
--- src/Parser/TypeData.cc	(revision 79ae13d5c771bea08f4655712505e7fa1a8fc73a)
+++ src/Parser/TypeData.cc	(revision dc56b9d88cf82f868f003d67991e756cbbd93bf1)
@@ -546,5 +546,4 @@
 		return buildAggInst( td );
 	  case TypeData::EnumConstant:
-		// the name gets filled in later -- by SymTab::Validate
 		return new EnumInstType( buildQualifiers( td ), "" );
 	  case TypeData::SymbolicInst:
@@ -921,14 +920,16 @@
 	assert( td->kind == TypeData::Enum );
 	Type * baseType = td->base ? typebuild(td->base) : nullptr;
-	EnumDecl * ret = new EnumDecl( *td->enumeration.name, attributes, linkage, baseType );
+	EnumDecl * ret = new EnumDecl( *td->enumeration.name, attributes, td->enumeration.typed, linkage, baseType );
 	buildList( td->enumeration.constants, ret->get_members() );
 	list< Declaration * >::iterator members = ret->get_members().begin();
 	for ( const DeclarationNode * cur = td->enumeration.constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) {
-		if ( cur->has_enumeratorValue() ) {
+		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() ) {
 			ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members);
 			member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ) ) );
 		} else if ( !cur->initializer ) {
 			if ( baseType && (!dynamic_cast<BasicType *>(baseType) || !dynamic_cast<BasicType *>(baseType)->isWholeNumber())) {
-				SemanticError( td->location, "A non whole number enum value decl must be explicitly initialized." );
+				SemanticError( td->location, "Enumerators of an non-integer typed enum must be explicitly initialized." );
 			}
 		}
Index: src/Parser/TypeData.h
===================================================================
--- src/Parser/TypeData.h	(revision 79ae13d5c771bea08f4655712505e7fa1a8fc73a)
+++ src/Parser/TypeData.h	(revision dc56b9d88cf82f868f003d67991e756cbbd93bf1)
@@ -59,4 +59,5 @@
 		bool body;
 		bool anon;
+		bool typed;
 	};
 
Index: src/Parser/parser.yy
===================================================================
--- src/Parser/parser.yy	(revision 79ae13d5c771bea08f4655712505e7fa1a8fc73a)
+++ src/Parser/parser.yy	(revision dc56b9d88cf82f868f003d67991e756cbbd93bf1)
@@ -637,5 +637,5 @@
 		{ $$ = new ExpressionNode( new StmtExpr( dynamic_cast<CompoundStmt *>(maybeMoveBuild<Statement>($2) ) ) ); }
 	| type_name '.' identifier							// CFA, nested type
-		{ SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
+		{ $$ = new ExpressionNode( build_qualified_expr( $1, build_varref( $3 ) ) ); }
 	| type_name '.' '[' field_name_list ']'				// CFA, nested type / tuple field selector
 		{ SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
@@ -2538,14 +2538,12 @@
 enum_type:
 	ENUM attribute_list_opt '{' enumerator_list comma_opt '}'
-		{ $$ = DeclarationNode::newEnum( nullptr, $4, true )->addQualifiers( $2 ); }
+		{ $$ = DeclarationNode::newEnum( nullptr, $4, true, false )->addQualifiers( $2 ); }
 	| ENUM attribute_list_opt identifier
 		{ typedefTable.makeTypedef( *$3 ); }
 	  '{' enumerator_list comma_opt '}'
-		{ $$ = DeclarationNode::newEnum( $3, $6, true )->addQualifiers( $2 ); }
+		{ $$ = DeclarationNode::newEnum( $3, $6, true, false )->addQualifiers( $2 ); }
 	| ENUM attribute_list_opt typedef_name				// unqualified type name
 	  '{' enumerator_list comma_opt '}'
-		{ $$ = DeclarationNode::newEnum( $3->name, $5, true )->addQualifiers( $2 ); }
-	| ENUM '(' ')' attribute_list_opt '{' enumerator_list comma_opt '}'
-		{ SemanticError( yylloc, "Unvalued enumerated type is currently unimplemented." ); $$ = nullptr; }
+		{ $$ = DeclarationNode::newEnum( $3->name, $5, true, false )->addQualifiers( $2 ); }
 	| ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt '{' enumerator_list comma_opt '}'
 	 	{
@@ -2553,5 +2551,9 @@
 			{ SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
 
-			$$ = DeclarationNode::newEnum( nullptr, $7, true, $3 )->addQualifiers( $5 );
+			$$ = DeclarationNode::newEnum( nullptr, $7, true, true, $3 )->addQualifiers( $5 );
+		}
+	| ENUM '(' ')' attribute_list_opt '{' enumerator_list comma_opt '}'
+		{
+			$$ = DeclarationNode::newEnum( nullptr, $6, true, true )->addQualifiers( $4 );
 		}
 	| ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt
@@ -2562,11 +2564,18 @@
 	  '{' enumerator_list comma_opt '}'
 		{
-			$$ = DeclarationNode::newEnum( $6, $10, true, $3 )->addQualifiers( $5 )->addQualifiers( $7 );
-		}
+			$$ = DeclarationNode::newEnum( $6, $10, true, true, $3 )->addQualifiers( $5 )->addQualifiers( $7 );
+		}
+	| ENUM '(' ')' attribute_list_opt identifier attribute_list_opt
+	  '{' enumerator_list comma_opt '}'
+		{
+			$$ = DeclarationNode::newEnum( $5, $8, true, true, nullptr )->addQualifiers( $4 )->addQualifiers( $6 );
+		}	
 	| ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt typedef_name 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." ); }
-			typedefTable.makeTypedef( *$6->name );
-			$$ = DeclarationNode::newEnum( $6->name, $9, true, $3 )->addQualifiers( $5 )->addQualifiers( $7 );
+			$$ = DeclarationNode::newEnum( $6->name, $9, true, true, $3 )->addQualifiers( $5 )->addQualifiers( $7 );
+		}
+	| ENUM '(' ')' attribute_list_opt typedef_name attribute_list_opt '{' enumerator_list comma_opt '}'
+		{
+			$$ = DeclarationNode::newEnum( $5->name, $8, true, true, nullptr )->addQualifiers( $4 )->addQualifiers( $6 );
 		}
 	| enum_type_nobody
@@ -2575,7 +2584,7 @@
 enum_type_nobody:										// enum - {...}
 	ENUM attribute_list_opt identifier
-		{ 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 )->addQualifiers( $2 ); }
+		{ typedefTable.makeTypedef( *$3 ); $$ = DeclarationNode::newEnum( $3, 0, false, false )->addQualifiers( $2 ); }
+	| ENUM attribute_list_opt type_name	
+		{ typedefTable.makeTypedef( *$3->type->symbolic.name );	$$ = DeclarationNode::newEnum( $3->type->symbolic.name, 0, false, false )->addQualifiers( $2 ); }
 	;