Index: src/Validate/FixQualifiedTypes.cpp
===================================================================
--- src/Validate/FixQualifiedTypes.cpp	(revision 020fa100c9bc0916e08b181151ef5bacc4b91f0f)
+++ src/Validate/FixQualifiedTypes.cpp	(revision e7b04a34fd9dfbee4abfe98b8245fe7a576939e9)
@@ -89,27 +89,4 @@
 	}
 
-	ast::Expr const * postvisit( ast::QualifiedNameExpr const * t ) {
-		assert( location );
-		if ( !t->type_decl ) return t;
-
-		auto enumName = t->type_decl->name;
-		const ast::EnumDecl * enumDecl = symtab.lookupEnum( enumName );
-		for ( ast::ptr<ast::Decl> const & member : enumDecl->members ) {
-			if ( auto memberAsObj = member.as<ast::ObjectDecl>() ) {
-				if ( memberAsObj->name == t->name ) {
-					return new ast::VariableExpr( t->location, memberAsObj );
-				}
-			} else {
-				assertf( false, "unhandled qualified child type" );
-			}
-		}
-
-		auto var = new ast::ObjectDecl( t->location, t->name,
-			new ast::EnumInstType( enumDecl, ast::CV::Const ),
-			nullptr, {}, ast::Linkage::Cforall );
-		var->mangleName = Mangle::mangle( var );
-		return new ast::VariableExpr( t->location, var );
-	}
-
 };
 
Index: src/Validate/ReplacePseudoFunc.cpp
===================================================================
--- src/Validate/ReplacePseudoFunc.cpp	(revision 020fa100c9bc0916e08b181151ef5bacc4b91f0f)
+++ src/Validate/ReplacePseudoFunc.cpp	(revision e7b04a34fd9dfbee4abfe98b8245fe7a576939e9)
@@ -9,5 +9,10 @@
 #include "Common/utility.h"
 #include "ResolvExpr/Resolver.h"
-#include "SymTab/Mangler.h"  // for Mangler
+#include "SymTab/Mangler.h"
+
+#include "AST/Print.hpp"
+
+#include "ResolvExpr/CandidateFinder.hpp"
+
 namespace Validate {
 
@@ -16,4 +21,8 @@
 std::set<std::string> queryLabels;
 std::set<std::string> queryValues;
+
+// struct AutoInit {
+//     ast::EnumDecl const* postvisit( const ast::EnumDecl* expr );
+// };
 
 struct WrapEnumValueExpr final : public ast::WithShortCircuiting,
@@ -23,4 +32,5 @@
     void previsit(const ast::ApplicationExpr* expr);
     void previsit(const ast::CastExpr* expr);
+    void previsit(const ast::VariableExpr* ) { visit_children = false; }
 
     ast::Expr const* postvisit(const ast::VariableExpr* expr);
@@ -33,5 +43,6 @@
 struct PseudoFuncGenerateRoutine final : public ast::WithDeclsToAdd<>,
                                          public ast::WithSymbolTable,
-                                         public ast::WithShortCircuiting {
+                                         public ast::WithShortCircuiting,
+                                         public ast::WithConstTranslationUnit {
     void previsit(const ast::EnumDecl* enumDecl);
 };
@@ -43,6 +54,14 @@
 };
 
+// ast::EnumDecl const * AutoInit::postvisit( const ast::EnumDecl * expr ) {
+//     for ( size_t i = 0; i < expr->members.size(); i++ ) {
+//         auto mem = expr->members[i].as<ast::ObjectDecl>();
+//         assert( mem );
+//         if ( mem->init )
+//     }
+//     return expr;
+// }
+
 void WrapEnumValueExpr::previsit(const ast::ApplicationExpr* expr) {
-
     auto varExpr = expr->func.as<ast::VariableExpr>();
     auto fname = ast::getFunctionName(expr);
@@ -52,6 +71,7 @@
 	}
 
-    if (fname == "labelE" || fname == "valueE" || fname == "posE")
+    if (fname == "labelE" || fname == "valueE" || fname == "posE") {
         visit_children = false;
+    }
 }
 
@@ -67,5 +87,4 @@
 
 ast::Expr const* WrapEnumValueExpr::postvisit(const ast::VariableExpr* expr) {
-    visit_children = false;
     if (!expr->result) {
         return expr;
@@ -75,12 +94,10 @@
             auto untyped = new ast::UntypedExpr(
                 expr->location, new ast::NameExpr(expr->location, "valueE"),
-                {new ast::VariableExpr(*expr)});
+                { std::move( expr ) });
             ResolvExpr::ResolveContext context{symtab, transUnit().global};
             auto result = ResolvExpr::findVoidExpression(untyped, context);
-            if (result.get()) {
-                ast::ptr<ast::ApplicationExpr> ret =
+            ast::ptr<ast::ApplicationExpr> ret =
                     result.strict_as<ast::ApplicationExpr>();
-                return new ast::ApplicationExpr(*ret);
-            }
+            return ast::deepCopy( ret );
         }
     }
@@ -115,4 +132,30 @@
 }
 
+const ast::Init * getAutoInit( const CodeLocation & location,
+    const ast::Type * type, ResolvExpr::ResolveContext context, const ast::Init * prev ) {
+    if ( auto prevInit = dynamic_cast< const ast::SingleInit * >( prev ) ) {
+        auto prevInitExpr = prevInit->value;
+        if ( auto constInit = prevInitExpr.as< ast::ConstantExpr >() ) {
+            // Assume no string literal for now
+            return new ast::SingleInit(
+                location,
+                ast::ConstantExpr::from_int(
+                    location, constInit->intValue() + 1 )
+            );
+        } else {
+            auto untypedThisInit = new ast::UntypedExpr(
+                    location,
+                    new ast::NameExpr( location, "?++" ),
+                    { prevInitExpr }
+                );
+            auto typedInit = ResolvExpr::findSingleExpression(untypedThisInit, type,
+                context );
+            return new ast::SingleInit( location, typedInit );
+        }
+    }
+    SemanticError( prev, "Auto Init a List is not implemented" );
+    return prev;
+}
+
 void PseudoFuncGenerateRoutine::previsit(const ast::EnumDecl* enumDecl) {
     visit_children = false;
@@ -122,10 +165,28 @@
     std::vector<ast::ptr<ast::Init>> inits;
     std::vector<ast::ptr<ast::Init>> labels;
-    for (const ast::Decl* mem : enumDecl->members) {
-        auto memAsObjectDecl = dynamic_cast<const ast::ObjectDecl*>(mem);
-        inits.emplace_back(memAsObjectDecl->init);
+    auto type = enumDecl->base;
+
+    for ( size_t i = 0; i < enumDecl->members.size(); i++ ) {
+        ast::ptr<ast::Decl> mem = enumDecl->members.at( i );
+        auto memAsObjectDecl = mem.as< ast::ObjectDecl >();
+        assert( memAsObjectDecl );
+        if ( memAsObjectDecl->init ) {
+            inits.emplace_back( memAsObjectDecl->init );
+        } else {
+            const CodeLocation & location = mem->location;
+            if ( i == 0 ) {
+                inits.emplace_back( new ast::SingleInit( 
+                    location, 
+                    ast::ConstantExpr::from_int( mem->location, 0 )
+                ) );
+            } else {
+                inits.emplace_back( getAutoInit( location, enumDecl->base, 
+                    ResolvExpr::ResolveContext{symtab, transUnit().global}, 
+                    inits.at( i - 1 ).as<ast::SingleInit>()) );
+            }
+        }
         labels.emplace_back(new ast::SingleInit(
-            location, ast::ConstantExpr::from_string(location, mem->name)));
-    }
+        location, ast::ConstantExpr::from_string(location, mem->name)));
+    } 
     if (queryValues.count(enumDecl->name)) {
         auto init = new ast::ListInit(location, std::move(inits));
@@ -206,7 +267,9 @@
                     return ast::ConstantExpr::from_string(expr->location,
                                                           referredName);
-                else
+                else {
                     return getPseudoFuncApplication(location, context, arg.get(),
-                                               base, "values_");
+                                               base, "values_");                    
+                }
+
             }
         }