Index: src/AST/Pass.impl.hpp
===================================================================
--- src/AST/Pass.impl.hpp	(revision deda7e6002cc711be5c0af09984cec24300d5990)
+++ src/AST/Pass.impl.hpp	(revision 5a1ae14d260cbaf6348528c6b1ae616bd9df9b31)
@@ -1860,5 +1860,4 @@
 		maybe_accept( node, &ArrayType::dimension );
 		maybe_accept( node, &ArrayType::base );
-		maybe_accept( node, &ArrayType::declaredType );
 	}
 
Index: src/AST/Type.hpp
===================================================================
--- src/AST/Type.hpp	(revision deda7e6002cc711be5c0af09984cec24300d5990)
+++ src/AST/Type.hpp	(revision 5a1ae14d260cbaf6348528c6b1ae616bd9df9b31)
@@ -216,6 +216,4 @@
 	DimensionFlag isStatic;
 
-	ptr<Decl> declaredType;
-
 	ArrayType( const Type * b, const Expr * d, LengthFlag vl, DimensionFlag s,
 		CV::Qualifiers q = {} ) : Type(q), base(b), dimension(d), isVarLen(vl), isStatic(s) {}
Index: src/Parser/DeclarationNode.cc
===================================================================
--- src/Parser/DeclarationNode.cc	(revision deda7e6002cc711be5c0af09984cec24300d5990)
+++ src/Parser/DeclarationNode.cc	(revision 5a1ae14d260cbaf6348528c6b1ae616bd9df9b31)
@@ -394,19 +394,4 @@
 	return newnode->addQualifiers( qualifiers );
 } // DeclarationNode::newArray
-
-DeclarationNode * DeclarationNode::newInlineEnumeratedArray( DeclarationNode * enumDecl, DeclarationNode * qualifiers ) {
-	DeclarationNode * newnode = new DeclarationNode;
-	newnode->type = new TypeData( TypeData::Array );
-	newnode->type->array.isStatic = false;
-	newnode->type->array.isVarLen = false;
-
-	if ( enumDecl ) {
-		newnode->type->declType = enumDecl->type;
-		enumDecl->type = nullptr;
-		delete enumDecl;
-	} // if
-	
-	return newnode->addQualifiers( qualifiers );
-}
 
 DeclarationNode * DeclarationNode::newVarArray( DeclarationNode * qualifiers ) {
Index: src/Parser/DeclarationNode.h
===================================================================
--- src/Parser/DeclarationNode.h	(revision deda7e6002cc711be5c0af09984cec24300d5990)
+++ src/Parser/DeclarationNode.h	(revision 5a1ae14d260cbaf6348528c6b1ae616bd9df9b31)
@@ -66,5 +66,4 @@
 	static DeclarationNode * newPointer( DeclarationNode * qualifiers, OperKinds kind );
 	static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic );
-	static DeclarationNode * newInlineEnumeratedArray( DeclarationNode * enumDecl, DeclarationNode * qualifiers );
 	static DeclarationNode * newVarArray( DeclarationNode * qualifiers );
 	static DeclarationNode * newBitfield( ExpressionNode * size );
Index: src/Parser/TypeData.cc
===================================================================
--- src/Parser/TypeData.cc	(revision deda7e6002cc711be5c0af09984cec24300d5990)
+++ src/Parser/TypeData.cc	(revision 5a1ae14d260cbaf6348528c6b1ae616bd9df9b31)
@@ -1021,7 +1021,4 @@
 		);
 	} // if
-	if ( td->declType) {
-		at->declaredType = buildEnum( td->declType, std::vector<ast::ptr<ast::Attribute>>(), ast::Linkage::Cforall );
-	}
 	return at;
 } // buildArray
Index: src/Parser/TypeData.h
===================================================================
--- src/Parser/TypeData.h	(revision deda7e6002cc711be5c0af09984cec24300d5990)
+++ src/Parser/TypeData.h	(revision 5a1ae14d260cbaf6348528c6b1ae616bd9df9b31)
@@ -85,5 +85,4 @@
 	Kind kind;
 	TypeData * base;
-	TypeData * declType;
 	DeclarationNode::BasicType basictype = DeclarationNode::NoBasicType;
 	DeclarationNode::ComplexType complextype = DeclarationNode::NoComplexType;
Index: src/Parser/parser.yy
===================================================================
--- src/Parser/parser.yy	(revision deda7e6002cc711be5c0af09984cec24300d5990)
+++ src/Parser/parser.yy	(revision 5a1ae14d260cbaf6348528c6b1ae616bd9df9b31)
@@ -3855,8 +3855,4 @@
 	| '[' push array_type_list pop ']'					// CFA
 		{ $$ = DeclarationNode::newArray( $3, nullptr, false ); }
-	| '[' push INLINE enum_type_nobody pop']'
-		{	
-			$$ = DeclarationNode::newInlineEnumeratedArray( $4, nullptr ); 
-		}
 	| multi_array_dimension
 	;
Index: src/ResolvExpr/ResolveTypeof.cc
===================================================================
--- src/ResolvExpr/ResolveTypeof.cc	(revision deda7e6002cc711be5c0af09984cec24300d5990)
+++ src/ResolvExpr/ResolveTypeof.cc	(revision 5a1ae14d260cbaf6348528c6b1ae616bd9df9b31)
@@ -24,8 +24,7 @@
 #include "AST/Type.hpp"
 #include "AST/TypeEnvironment.hpp"
-#include "Common/PassVisitor.h"    // for PassVisitor
-#include "Common/SemanticError.h"  // for SemanticError
-#include "Common/utility.h"        // for copy
-#include "InitTweak/InitTweak.h"   // for isConstExpr
+#include "Common/PassVisitor.h"   // for PassVisitor
+#include "Common/utility.h"       // for copy
+#include "InitTweak/InitTweak.h"  // for isConstExpr
 #include "RenameVars.h"
 #include "Resolver.h"  // for resolveInVoidContext
@@ -51,11 +50,11 @@
 		}
 #endif
-}  // namespace
+	}
 
 class ResolveTypeof_old : public WithShortCircuiting {
    public:
-    ResolveTypeof_old(const SymTab::Indexer &indexer) : indexer(indexer) {}
-    void premutate(TypeofType *typeofType);
-    Type *postmutate(TypeofType *typeofType);
+		ResolveTypeof_old( const SymTab::Indexer &indexer ) : indexer( indexer ) {}
+		void premutate( TypeofType *typeofType );
+		Type * postmutate( TypeofType *typeofType );
 
    private:
@@ -63,12 +62,14 @@
 };
 
-Type *resolveTypeof(Type *type, const SymTab::Indexer &indexer) {
-    PassVisitor<ResolveTypeof_old> mutator(indexer);
-    return type->acceptMutator(mutator);
-}
-
-void ResolveTypeof_old::premutate(TypeofType *) { visit_children = false; }
-
-Type *ResolveTypeof_old::postmutate(TypeofType *typeofType) {
+	Type * resolveTypeof( Type *type, const SymTab::Indexer &indexer ) {
+		PassVisitor<ResolveTypeof_old> mutator( indexer );
+		return type->acceptMutator( mutator );
+	}
+
+	void ResolveTypeof_old::premutate( TypeofType * ) {
+		visit_children = false;
+	}
+
+    Type * ResolveTypeof_old::postmutate( TypeofType *typeofType ) {
 #if 0
 		std::cerr << "resolving typeof: ";
@@ -77,5 +78,5 @@
 #endif
     // pass on null expression
-    if (!typeofType->expr) return typeofType;
+		if ( ! typeofType->expr ) return typeofType;
 
     bool isBasetypeof = typeofType->is_basetypeof;
@@ -83,5 +84,5 @@
 
     Type* newType;
-    if ( TypeExpr* tyExpr = dynamic_cast<TypeExpr*>( typeofType->expr ) ) {
+		if ( TypeExpr* tyExpr = dynamic_cast<TypeExpr*>(typeofType->expr) ) {
         // typeof wrapping type
         newType = tyExpr->type;
@@ -90,6 +91,6 @@
     } else {
         // typeof wrapping expression
-        Expression *newExpr = resolveInVoidContext(typeofType->expr, indexer);
-        assert(newExpr->result && !newExpr->result->isVoid());
+			Expression * newExpr = resolveInVoidContext( typeofType->expr, indexer );
+			assert( newExpr->result && ! newExpr->result->isVoid() );
         newType = newExpr->result;
         newExpr->result = nullptr;
@@ -99,17 +100,16 @@
 
     // clear qualifiers for base, combine with typeoftype quals in any case
-    if (isBasetypeof) {
-        // replace basetypeof(<enum>) by int
-        if (dynamic_cast<EnumInstType *>(newType)) {
-            Type *newerType =
-                new BasicType{newType->get_qualifiers(), BasicType::SignedInt,
-                              newType->attributes};
-            delete newType;
-            newType = newerType;
-        }
-        newType->get_qualifiers().val =
-            (newType->get_qualifiers().val & ~Type::Qualifiers::Mask) |
-            oldQuals;
-    } else {
+    if ( isBasetypeof ) {
+			// replace basetypeof(<enum>) by int
+			if ( dynamic_cast<EnumInstType*>(newType) ) {
+				Type* newerType =
+					new BasicType{ newType->get_qualifiers(), BasicType::SignedInt,
+					newType->attributes };
+				delete newType;
+				newType = newerType;
+			}
+			newType->get_qualifiers().val
+				= ( newType->get_qualifiers().val & ~Type::Qualifiers::Mask ) | oldQuals;
+		} else {
         newType->get_qualifiers().val |= oldQuals;
     }
@@ -120,16 +120,17 @@
 namespace {
 struct ResolveTypeof_new : public ast::WithShortCircuiting {
-    const ResolveContext &context;
-
-    ResolveTypeof_new(const ResolveContext &context) : context(context) {}
-
-    void previsit(const ast::TypeofType *) { visit_children = false; }
-
-    const ast::Type *postvisit(const ast::TypeofType *typeofType) {
+    const ResolveContext & context;
+
+		ResolveTypeof_new( const ResolveContext & context ) :
+			context( context ) {}
+
+		void previsit( const ast::TypeofType * ) { visit_children = false; }
+
+        const ast::Type * postvisit( const ast::TypeofType * typeofType ) {
         // pass on null expression
-        if (!typeofType->expr) return typeofType;
-
-        ast::ptr<ast::Type> newType;
-        if (auto tyExpr = typeofType->expr.as<ast::TypeExpr>()) {
+            if ( ! typeofType->expr ) return typeofType;
+
+            ast::ptr< ast::Type > newType;
+            if ( auto tyExpr = typeofType->expr.as< ast::TypeExpr >() ) {
             // typeof wrapping type
             newType = tyExpr->type;
@@ -137,23 +138,22 @@
             // typeof wrapping expression
             ast::TypeEnvironment dummy;
-            ast::ptr<ast::Expr> newExpr =
-                resolveInVoidContext(typeofType->expr, context, dummy);
-            assert(newExpr->result && !newExpr->result->isVoid());
+            ast::ptr< ast::Expr > newExpr =
+                resolveInVoidContext( typeofType->expr, context, dummy );
+            assert( newExpr->result && ! newExpr->result->isVoid() );
             newType = newExpr->result;
         }
 
         // clear qualifiers for base, combine with typeoftype quals regardless
-        if (typeofType->kind == ast::TypeofType::Basetypeof) {
+        if ( typeofType->kind == ast::TypeofType::Basetypeof ) {
             // replace basetypeof(<enum>) by int
-            if (newType.as<ast::EnumInstType>()) {
-                newType = new ast::BasicType{ast::BasicType::SignedInt,
-                                             newType->qualifiers,
-                                             copy(newType->attributes)};
+				if ( newType.as< ast::EnumInstType >() ) {
+					newType = new ast::BasicType{
+						ast::BasicType::SignedInt, newType->qualifiers, copy(newType->attributes) };
             }
-            reset_qualifiers(newType,
-                             (newType->qualifiers & ~ast::CV::EquivQualifiers) |
-                                 typeofType->qualifiers);
+				reset_qualifiers(
+					newType,
+					( newType->qualifiers & ~ast::CV::EquivQualifiers ) | typeofType->qualifiers );
         } else {
-            add_qualifiers(newType, typeofType->qualifiers);
+				add_qualifiers( newType, typeofType->qualifiers );
         }
 
@@ -161,79 +161,38 @@
     }
 };
-}  // anonymous namespace
-
-const ast::Type *resolveTypeof(const ast::Type *type,
-                               const ResolveContext &context) {
-    ast::Pass<ResolveTypeof_new> mutator(context);
-    return type->accept(mutator);
+} // anonymous namespace
+
+const ast::Type * resolveTypeof( const ast::Type * type , const ResolveContext & context ) {
+	ast::Pass< ResolveTypeof_new > mutator( context );
+	return type->accept( mutator );
 }
 
 struct FixArrayDimension {
-    const ResolveContext &context;
-    FixArrayDimension(const ResolveContext &context) : context(context) {}
-
-    const ast::ArrayType *previsit(const ast::ArrayType *arrayType) {
-        if (!arrayType->dimension) return arrayType;
-        auto mutType = mutate(arrayType);
-        auto globalSizeType = context.global.sizeType;
-        ast::ptr<ast::Type> sizetype =
-            globalSizeType
-                ? globalSizeType
-                : new ast::BasicType(ast::BasicType::LongUnsignedInt);
-        mutType->dimension =
-            findSingleExpression(arrayType->dimension, sizetype, context);
-
-        if (InitTweak::isConstExpr(mutType->dimension)) {
-            mutType->isVarLen = ast::LengthFlag::FixedLen;
-        } else {
-            mutType->isVarLen = ast::LengthFlag::VariableLen;
-        }
-        return mutType;
-    }
+	const ResolveContext & context;
+	FixArrayDimension(const ResolveContext & context) : context( context ) {}
+
+	const ast::ArrayType * previsit (const ast::ArrayType * arrayType) {
+		if (!arrayType->dimension) return arrayType;
+		auto mutType = mutate(arrayType);
+		auto globalSizeType = context.global.sizeType;
+		ast::ptr<ast::Type> sizetype = globalSizeType ? globalSizeType : new ast::BasicType(ast::BasicType::LongUnsignedInt);
+		mutType->dimension = findSingleExpression(arrayType->dimension, sizetype, context );
+
+		if (InitTweak::isConstExpr(mutType->dimension)) {
+			mutType->isVarLen = ast::LengthFlag::FixedLen;
+		}
+		else {
+			mutType->isVarLen = ast::LengthFlag::VariableLen;
+		}
+		return mutType;
+	}
 };
 
-struct FixEnumeratedArray {
-    const ResolveContext &context;
-    const ast::ListInit *init;
-    FixEnumeratedArray(const ResolveContext &context, const ast::ListInit *init)
-        : context(context), init(init) {}
-
-    const ast::ArrayType *previsit(const ast::ArrayType *arrayType) {
-        return arrayType;
-    }
-
-    // Enum Defined as inline field of array needs initalizer to define its
-    // members
-    const ast::EnumDecl *previsit(const ast::EnumDecl *enumDecl) {
-        auto mutType = mutate(enumDecl);
-        for (auto designation : init->designations) {
-            std::deque<ast::ptr<ast::Expr>> designatorList =
-                designation->designators;
-            if (designatorList.size() != 1) {
-                SemanticError(mutType,
-                              "Multiple Initialization in enumerated array is "
-                              "not supported.");
-            }
-            ast::ptr<ast::Expr> designator = designatorList.at(0);
-            ast::ptr<ast::NameExpr> designatorAsName =
-                designator.as<ast::NameExpr>();
-            ast::ObjectDecl *memberDecl =
-                new ast::ObjectDecl(enumDecl->location, designatorAsName->name,
-                                    new ast::EnumInstType("", ast::CV::Const));
-            mutType->members.push_back(memberDecl);
-            // mutType->members.push_back( )
-        }
-        return mutType;
-    }
-};
-
-const ast::Type *fixArrayType(const ast::Type *type,
-                              const ResolveContext &context) {
-    ast::Pass<FixArrayDimension> visitor(context);
-    return type->accept(visitor);
-}
-
-const ast::ObjectDecl *fixObjectType(const ast::ObjectDecl *decl,
-                                     const ResolveContext &context) {
+const ast::Type * fixArrayType( const ast::Type * type, const ResolveContext & context ) {
+	ast::Pass<FixArrayDimension> visitor(context);
+	return type->accept(visitor);
+}
+
+const ast::ObjectDecl * fixObjectType( const ast::ObjectDecl * decl , const ResolveContext & context ) {
     if (decl->isTypeFixed) {
         return decl;
@@ -260,56 +219,59 @@
 const ast::ObjectDecl *fixObjectInit(const ast::ObjectDecl *decl,
                                      const ResolveContext &context) {
-    if ( decl->isTypeFixed ) {
+    if (decl->isTypeFixed) {
         return decl;
     }
 
-    auto mutDecl = mutate( decl );
-
-    if ( const ast::ListInit * listInit = mutDecl->init.as<ast::ListInit>() ) {
-        ast::ListInit * mutListInit = mutate( listInit );
-        // ListInit::designations is std::vector<ptr<Designation>>
-        // ((ast::ListInit)mutDecl->init).designations = newDesignations
-        std::vector<ast::ptr<ast::Designation>> newDesignations;
-        
-        // The loop iterates over ListInit::designations and push member to newDesignations
-        for ( ast::ptr<ast::Designation> des : listInit->designations ) {
-            ast::Designation * newDesignation = mutate( des.get() );
-            
-            std::deque<ast::ptr<ast::Expr>> newDesignators;
-            for ( const ast::Expr *designator : des->designators ) {
-                if ( const ast::NameExpr *designatorName = dynamic_cast<const ast::NameExpr *>(designator) ) {
-                    auto candidates = context.symtab.lookupId(designatorName->name);
-                    if ( candidates.size() == 0 ) {
-                        newDesignators.push_back(designator);
-                    } else {
-                        auto candidate = candidates.at(0);
-                        if ( const ast::EnumInstType *enumInst = dynamic_cast<const ast::EnumInstType *>(candidate.id->get_type()) ) {
-                            const ast::EnumDecl * baseEnum = enumInst->base;
-                            // // Need to iterate over all enum value to find the
-                            // // initializer to swap
-                            for (size_t m = 0; m < baseEnum->members.size(); ++m) {
-                                const ast::ObjectDecl *mem = baseEnum->members.at(m).as<const ast::ObjectDecl>();
-                                if (baseEnum->members.at(m)->name == designatorName->name) {
-                                    assert(mem);
-                                    newDesignators.push_back( ast::ConstantExpr::from_int(des->location,  m ));
-                                }
-                            } // for
-                            assert(newDesignators.size() > 0);
-                        } else {
-                            newDesignators.push_back(designator);
-                        } //if
-                    }  
+    auto mutDecl = mutate(decl);
+
+    if ( auto mutListInit = mutDecl->init.as<ast::ListInit>() ) {
+        // std::list<ast::Designation *> newDesignations;        
+
+        for ( size_t k = 0; k < mutListInit->designations.size(); k++ ) {
+            const ast::Designation *des = mutListInit->designations[k].get();
+            // Desination here
+            ast::Designation * newDesination = new ast::Designation(des->location);
+
+            if (des->designators.size() == 0) continue;
+
+            // The designator I want to replace
+            const ast::Expr * designator = des->designators.at(0);
+            // Stupid flag variable for development, to be removed
+            bool mutated = false;
+            if ( const ast::NameExpr * designatorName = dynamic_cast<const ast::NameExpr *>(designator) ) {
+                auto candidates = context.symtab.lookupId(designatorName->name);
+                // Does not work for the overloading case currently
+                // assert( candidates.size() == 1 );
+                if ( candidates.size() != 1 ) return mutDecl;
+                auto candidate = candidates.at(0);
+                if ( const ast::EnumInstType * enumInst = dynamic_cast<const ast::EnumInstType *>(candidate.id->get_type())) {
+                    // determine that is an enumInst, swap it with its const value
+                    assert( candidates.size() == 1 );
+                    const ast::EnumDecl * baseEnum = enumInst->base;
+                    // Need to iterate over all enum value to find the initializer to swap
+                    for ( size_t m = 0; m < baseEnum->members.size(); ++m ) {
+                        const ast::ObjectDecl * mem = baseEnum->members.at(m).as<const ast::ObjectDecl>();
+                        if ( baseEnum->members.at(m)->name == designatorName->name ) {
+                            assert(mem);
+                            if ( mem->init ) {
+                                const ast::SingleInit * memInit = mem->init.as<const ast::SingleInit>();
+                                ast::Expr * initValue = shallowCopy( memInit->value.get() );
+                                newDesination->designators.push_back( initValue );
+                                mutated = true;
+                            }
+                            break;
+                        }
+                    }
                 } else {
-                    newDesignators.push_back(designator);
-                } // if
-            } // for
-            
-            newDesignation->designators = newDesignators;
-            newDesignations.push_back( newDesignation );
-        } // for
-        // mutListInit->designations = newDesignations;
-        ast::mutate_field( mutListInit, &ast::ListInit::designations, newDesignations );
-        ast::mutate_field( mutDecl, &ast::ObjectDecl::init, mutListInit );
-    } // if
+                    newDesination->designators.push_back( des->designators.at(0) );
+                }
+            } else {
+                newDesination->designators.push_back( des->designators.at(0) );
+            }
+            if ( mutated ) {
+                mutListInit = ast::mutate_field_index(mutListInit, &ast::ListInit::designations, k, newDesination);
+            }
+        }
+    }
     return mutDecl;
 }
Index: src/ResolvExpr/ResolveTypeof.h
===================================================================
--- src/ResolvExpr/ResolveTypeof.h	(revision deda7e6002cc711be5c0af09984cec24300d5990)
+++ src/ResolvExpr/ResolveTypeof.h	(revision 5a1ae14d260cbaf6348528c6b1ae616bd9df9b31)
@@ -17,5 +17,4 @@
 
 class Type;
-class ListInit;
 namespace SymTab {
 class Indexer;
@@ -23,5 +22,4 @@
 namespace ast {
 	class Type;
-	class ListInit;
 	class ObjectDecl;
 }
@@ -30,10 +28,9 @@
 	struct ResolveContext;
 
-	Type *resolveTypeof( Type *, const SymTab::Indexer &indexer );
+	Type *resolveTypeof( Type*, const SymTab::Indexer &indexer );
 	const ast::Type * resolveTypeof( const ast::Type *, const ResolveContext & );
-	const ast::Type * fixArrayType( const ast::Type *, const ResolveContext &, const ast::ListInit * );
-	const ast::Type * fixEnumeratedArray( const ast::Type *, const ResolveContext & );
+	const ast::Type * fixArrayType( const ast::Type *, const ResolveContext & );
 	const ast::ObjectDecl * fixObjectType( const ast::ObjectDecl * decl , const ResolveContext & );
-	const ast::ObjectDecl * fixObjectInit( const ast::ObjectDecl * decl , const ResolveContext & );
+	const ast::ObjectDecl * fixObjectInit( const ast::ObjectDecl * decl , const ResolveContext &);
 } // namespace ResolvExpr
 
Index: c/Validate/FixEnumeratedArray.cpp
===================================================================
--- src/Validate/FixEnumeratedArray.cpp	(revision deda7e6002cc711be5c0af09984cec24300d5990)
+++ 	(revision )
@@ -1,59 +1,0 @@
-#include "Validate/FixEnumeratedArray.hpp"
-
-#include "AST/Pass.hpp"                  // WithCodeLocation
-#include "Validate/NoIdSymbolTable.hpp"  // NoIdSymbolTable
-
-namespace Validate {
-namespace {
-struct FixEnumeratedArray : public NoIdSymbolTable,
-                            
-                            public ast::WithCodeLocation,
-                            public ast::WithShortCircuiting,
-                            public ast::WithDeclsToAdd<> {
-
-    ast::ObjectDecl const * previsit( ast::ObjectDecl const * decl ) {
-        if (decl->isTypeFixed) return decl;
-        if (auto arrayDecl = decl->type.as<ast::ArrayType>()) {
-            auto declaredType = arrayDecl->declaredType;
-            if (!declaredType) return decl;
-            auto initializers = decl->init.strict_as<ast::ListInit>();
-            if (auto declaredEnum = declaredType.as<ast::EnumDecl>()) {
-                auto forwardingEnum = mutate(declaredEnum);
-                for (auto designation : initializers->designations) {
-                    std::deque<ast::ptr<ast::Expr>> designatorList =
-                        designation->designators;
-                    if (designatorList.size() != 1) {
-                        SemanticError(forwardingEnum,
-                                      "Multiple Initialization in enumerated "
-                                      "array is not supported.");
-                    }
-                    ast::ptr<ast::Expr> designator = designatorList.at(0);
-
-                    ast::ptr<ast::NameExpr> designatorAsName =
-                        designator.as<ast::NameExpr>();
-                    if (!designatorAsName) {
-                        SemanticError(
-                            forwardingEnum,
-                            "Enumerated Array with inlined enum declaration "
-                            "can only use string as its initializer");
-                    }
-                    ast::ObjectDecl* memberDecl = new ast::ObjectDecl(
-                        declaredEnum->location, designatorAsName->name,
-                        new ast::EnumInstType(declaredEnum, ast::CV::Const));
-                    forwardingEnum->members.push_back(memberDecl);
-                }
-                // addEnum(forwardingEnum);
-                declsToAddBefore.push_back( forwardingEnum );
-            }
-        }
-        return decl;
-    }
-
-};  // namespace
-
-}  // namespace
-void fixEnumeratedArray(ast::TranslationUnit& translationUnit) {
-    ast::Pass<FixEnumeratedArray>::run(translationUnit);
-}
-
-};  // namespace Validate
Index: c/Validate/FixEnumeratedArray.hpp
===================================================================
--- src/Validate/FixEnumeratedArray.hpp	(revision deda7e6002cc711be5c0af09984cec24300d5990)
+++ 	(revision )
@@ -1,14 +1,0 @@
-#pragma once
-
-namespace ast {
-    class TranslationUnit;
-}
-
-namespace Validate {
-
-/// Fills in the base value of various instance types, and some related
-/// adjustments, such as setting the sized flag.
-/// Because of the sized flag, it must happen before auto-gen.
-void fixEnumeratedArray( ast::TranslationUnit & translationUnit );
-
-}
Index: src/Validate/module.mk
===================================================================
--- src/Validate/module.mk	(revision deda7e6002cc711be5c0af09984cec24300d5990)
+++ src/Validate/module.mk	(revision 5a1ae14d260cbaf6348528c6b1ae616bd9df9b31)
@@ -29,6 +29,4 @@
 	Validate/EnumAndPointerDecay.hpp \
 	Validate/FindSpecialDeclsNew.cpp \
-	Validate/FixEnumeratedArray.hpp \
-	Validate/FixEnumeratedArray.cpp \
 	Validate/FixQualifiedTypes.cpp \
 	Validate/FixQualifiedTypes.hpp \
Index: src/main.cc
===================================================================
--- src/main.cc	(revision deda7e6002cc711be5c0af09984cec24300d5990)
+++ src/main.cc	(revision 5a1ae14d260cbaf6348528c6b1ae616bd9df9b31)
@@ -73,5 +73,4 @@
 #include "Validate/FixQualifiedTypes.hpp"   // for fixQualifiedTypes
 #include "Validate/FixReturnTypes.hpp"      // for fixReturnTypes
-#include "Validate/FixEnumeratedArray.hpp"  // for fixEnumeratedArray
 #include "Validate/ForallPointerDecay.hpp"  // for decayForallPointers
 #include "Validate/GenericParameter.hpp"    // for fillGenericParameters, tr...
@@ -334,5 +333,4 @@
 
 		PASS( "Link Reference To Types", Validate::linkReferenceToTypes, transUnit );
-		PASS( "Fix Enumerated Array", Validate::fixEnumeratedArray, transUnit );
 
 		PASS( "Forall Pointer Decay", Validate::decayForallPointers, transUnit );
