Index: src/AST/Pass.impl.hpp
===================================================================
--- src/AST/Pass.impl.hpp	(revision 01510fefafb44ae9c0d334505d88759ca0fd9d42)
+++ src/AST/Pass.impl.hpp	(revision c1e66d966aadf6846330871033458d4a398bd576)
@@ -1860,4 +1860,5 @@
 		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 01510fefafb44ae9c0d334505d88759ca0fd9d42)
+++ src/AST/Type.hpp	(revision c1e66d966aadf6846330871033458d4a398bd576)
@@ -216,4 +216,6 @@
 	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 01510fefafb44ae9c0d334505d88759ca0fd9d42)
+++ src/Parser/DeclarationNode.cc	(revision c1e66d966aadf6846330871033458d4a398bd576)
@@ -394,4 +394,19 @@
 	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 01510fefafb44ae9c0d334505d88759ca0fd9d42)
+++ src/Parser/DeclarationNode.h	(revision c1e66d966aadf6846330871033458d4a398bd576)
@@ -66,4 +66,5 @@
 	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 01510fefafb44ae9c0d334505d88759ca0fd9d42)
+++ src/Parser/TypeData.cc	(revision c1e66d966aadf6846330871033458d4a398bd576)
@@ -1021,4 +1021,7 @@
 		);
 	} // 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 01510fefafb44ae9c0d334505d88759ca0fd9d42)
+++ src/Parser/TypeData.h	(revision c1e66d966aadf6846330871033458d4a398bd576)
@@ -85,4 +85,5 @@
 	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 01510fefafb44ae9c0d334505d88759ca0fd9d42)
+++ src/Parser/parser.yy	(revision c1e66d966aadf6846330871033458d4a398bd576)
@@ -3855,4 +3855,8 @@
 	| '[' 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 01510fefafb44ae9c0d334505d88759ca0fd9d42)
+++ src/ResolvExpr/ResolveTypeof.cc	(revision c1e66d966aadf6846330871033458d4a398bd576)
@@ -24,7 +24,8 @@
 #include "AST/Type.hpp"
 #include "AST/TypeEnvironment.hpp"
-#include "Common/PassVisitor.h"   // for PassVisitor
-#include "Common/utility.h"       // for copy
-#include "InitTweak/InitTweak.h"  // for isConstExpr
+#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 "RenameVars.h"
 #include "Resolver.h"  // for resolveInVoidContext
@@ -50,11 +51,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:
@@ -62,14 +63,12 @@
 };
 
-	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: ";
@@ -78,5 +77,5 @@
 #endif
     // pass on null expression
-		if ( ! typeofType->expr ) return typeofType;
+    if (!typeofType->expr) return typeofType;
 
     bool isBasetypeof = typeofType->is_basetypeof;
@@ -84,5 +83,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;
@@ -91,6 +90,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;
@@ -100,16 +99,17 @@
 
     // 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,17 +120,16 @@
 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;
@@ -138,22 +137,23 @@
             // 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,38 +161,79 @@
     }
 };
-} // 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;
+    }
 };
 
-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 ) {
+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) {
     if (decl->isTypeFixed) {
         return decl;
@@ -219,59 +260,56 @@
 const ast::ObjectDecl *fixObjectInit(const ast::ObjectDecl *decl,
                                      const ResolveContext &context) {
-    if (decl->isTypeFixed) {
+    if ( decl->isTypeFixed ) {
         return decl;
     }
 
-    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;
-                        }
-                    }
+    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
+                    }  
                 } else {
-                    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);
-            }
-        }
-    }
+                    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
     return mutDecl;
 }
Index: src/ResolvExpr/ResolveTypeof.h
===================================================================
--- src/ResolvExpr/ResolveTypeof.h	(revision 01510fefafb44ae9c0d334505d88759ca0fd9d42)
+++ src/ResolvExpr/ResolveTypeof.h	(revision c1e66d966aadf6846330871033458d4a398bd576)
@@ -17,4 +17,5 @@
 
 class Type;
+class ListInit;
 namespace SymTab {
 class Indexer;
@@ -22,4 +23,5 @@
 namespace ast {
 	class Type;
+	class ListInit;
 	class ObjectDecl;
 }
@@ -28,9 +30,10 @@
 	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::Type * fixArrayType( const ast::Type *, const ResolveContext &, const ast::ListInit * );
+	const ast::Type * fixEnumeratedArray( 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: src/Validate/FixEnumeratedArray.cpp
===================================================================
--- src/Validate/FixEnumeratedArray.cpp	(revision c1e66d966aadf6846330871033458d4a398bd576)
+++ src/Validate/FixEnumeratedArray.cpp	(revision c1e66d966aadf6846330871033458d4a398bd576)
@@ -0,0 +1,59 @@
+#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: src/Validate/FixEnumeratedArray.hpp
===================================================================
--- src/Validate/FixEnumeratedArray.hpp	(revision c1e66d966aadf6846330871033458d4a398bd576)
+++ src/Validate/FixEnumeratedArray.hpp	(revision c1e66d966aadf6846330871033458d4a398bd576)
@@ -0,0 +1,14 @@
+#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 01510fefafb44ae9c0d334505d88759ca0fd9d42)
+++ src/Validate/module.mk	(revision c1e66d966aadf6846330871033458d4a398bd576)
@@ -29,4 +29,6 @@
 	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 01510fefafb44ae9c0d334505d88759ca0fd9d42)
+++ src/main.cc	(revision c1e66d966aadf6846330871033458d4a398bd576)
@@ -73,4 +73,5 @@
 #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...
@@ -333,4 +334,5 @@
 
 		PASS( "Link Reference To Types", Validate::linkReferenceToTypes, transUnit );
+		PASS( "Fix Enumerated Array", Validate::fixEnumeratedArray, transUnit );
 
 		PASS( "Forall Pointer Decay", Validate::decayForallPointers, transUnit );