Changes in / [221c542e:bad9c8f]

Files:

• doc/proposals/enum.tex (modified) (3 diffs)
• src/AST/Decl.hpp (modified) (1 diff)
• src/CodeGen/CodeGenerator.cpp (modified) (1 diff)
• src/InitTweak/FixInit.cpp (modified) (24 diffs)
• src/Parser/ExpressionNode.cc (modified) (2 diffs)
• src/Parser/parserutility.cc (modified) (1 diff)
• src/Parser/parserutility.h (modified) (1 diff)
• src/ResolvExpr/CandidateFinder.cpp (modified) (3 diffs)
• src/Validate/Autogen.cpp (modified) (1 diff)
• src/Validate/ReplacePseudoFunc.cpp (modified) (2 diffs)
• src/main.cc (modified) (1 diff)

doc/proposals/enum.tex

@@ -245 +245 @@
 
 
-\
+\subsection{Aggressive Inline}
+To avoid allocating memory for enumeration data structures, \CFA inline the result of enumeration attribute pseudo-function whenever it is possible. 
+\begin{lstlisting}[label=lst:enumeration_inline]
+enum(int) OddNumber { A=1, B=3 };
+sout | "A: " | OddNumber.A | "B: " | OddNumber.B | "A+B: " | OddNumber.A + OddNumber.B
+\end{lstlisting}
+Instead of calling pseudo-function @value@ on expression $OddNumber.A$ and $OddNumber.B$, because the result is known statistically, \CFA will inline the constant expression 1 and 3, respectively. Because no runtime lookup for enumeration value is necessary, \CFA will not generate data structure for enumeration OddNumber.
+
+\subsection{Weak Reference}
+\begin{lstlisting}[label=lst:week_ref]
+enum(int) OddNumber { A=1, B=3 };
+enum OddNumber i = ...;
+...
+sout | OddNumber;
+\end{lstlisting}
+In this example, \CFA cannot determine the static value of the enum variable i, and Runtime lookup is necessary. The OddNumber can be referenced in multiple compilations, and allocating the arrays in all compilation units is not desirable. \CFA addresses this by declaring the value array as a weak reference. All compilation units reference OddNumber have weak references to the same enumeration data structure. No extra memory is allocated if more compilation units reference OddNumber, and the OddNumber is initialized once.
+
 \section{Unification}
 
@@ -622 +638 @@
 \section{Implementation}
 
-\subsection{Static Attribute Expression}
-\begin{lstlisting}[label=lst:static_attr]
-enum( char * ) Colour {
-    Red = "red", Blue = "blue", Green = "green"  
-};
-\end{lstlisting}
-An enumerator expression returns its enumerator value as a constant expression with no runtime cost. For example, @Colour.Red@ is equivalent to the constant expression "red", and \CFA finishes the expression evaluation before generating the corresponding C code. Applying a pseudo-function to a constant enumerator expression results in a constant expression as well. @value( Colour.Red )@, @position( Colour. Red )@, and @label( Colour.Red )@ are equivalent to constant expression with char * value "red", int value 0, and char * value "Red", respectively. 
-
-\subsection{Runtime Attribute Expression and Weak Referenced Data}
-\begin{lstlisting}[label=lst:dynamic_attr]
-Colour c;
-...
-value( c ); // or c
-\end{lstlisting}
-An enumeration variable c is equivalent to an integer variable with the value of @position( c )@ In Example~\ref{lst:dynamic_attr}, the value of enumeration variable c is unknown at compile time. In this case, the pseudo-function calls are reduced to expression that returns the enumerator values at runtime.
-
-\CFA stores the variables and labels in const arrays to provide runtime lookup for enumeration information. 
-
-\begin{lstlisting}[label=lst:attr_array]
-const char * Colour_labels [3] = { "Red", "Blue", "Green" };
-const char * Colour_values [3] = { "red", "blue", "green" };
-\end{lstlisting}
-The \CFA compiles transforms the attribute expressions into array access.
-\begin{lstlisting}[label=lst:attr_array_access]
-position( c ) // c; an integer
-value( c ); // Colour_values[c]
-label( c ); // Colour_labels[c]
-\end{lstlisting}
-
-To avoid unnecessary memory usage, the labels and values array are only generated as needed, and only generate once across all compilation units. By default, \CFA defers the declaration of the label and value arrays until an call to attribute function with a dynamic value. If an attribute function is never called on a dynamic value of an enumerator, the array will never be allocated. Once the arrays are created, all compilation units share a weak reference to the allocation array. 
-
-\subsection{Enum Prelude}
-
-\begin{lstlisting}[label=lst:enum_func_dec]
-forall( T ) {
-    unsigned position( unsigned );
-    T value( unsigned );
-    char * label( unsigned );
-}
-\end{lstlisting}
-\CFA loads the declaration of enumeration function from the enum.hfa.
-
-\subsection{Internal Representation}
-
+\subsection{Compiler Representation (Reworking)}
 The definition of an enumeration is represented by an internal type called @EnumDecl@. At the minimum, it stores all the information needed to construct the companion object. Therefore, an @EnumDecl@ can be represented as the following:
 \begin{lstlisting}[label=lst:EnumDecl]
@@ -694 +667 @@
 
 
-% \subsection{(Rework) Companion Object and Companion Function}
-
-% \begin{lstlisting}[caption={Enum Type Functions}, label=lst:cforall_enum_functions]
-% forall( T )
-% struct Companion {
-%       const T * const values;
-%         const char * label;
-%       int length;
-% };
-% \end{lstlisting}
-% \CFA generates companion objects, an instance of structure that encloses @necessary@ data to represent an enumeration. The size of the companion is unknown at the compilation time, and it "grows" in size to compensate for the @usage@.
-
-% The companion object is singleton across the compilation (investigation).  
-
-% \CFA generates the definition of companion functions.
-% Because \CFA implicitly stores an enumeration instance as its position, the companion function @position@ does nothing but return the position it is passed.
-% Companions function @value@ and @label@ return the array item at the given position of @values@ and @labels@, respectively.
-% \begin{lstlisting}[label=lst:companion_definition]
-% int position( Companion o, int pos ) { return pos; }
-% T value( Companion o, int pos ) { return o.values[ pos ]; }
-% char * label( Companion o, int pos ) { return o.labels[ pos ]; }
-% \end{lstlisting}
-% Notably, the @Companion@ structure definition, and all companion objects, are visible to users.
-% A user can retrieve values and labels defined in an enumeration by accessing the values and labels directly, or indirectly by calling @Companion@ functions @values@ and @labels@
-% \begin{lstlisting}[label=lst:companion_definition_values_labels]
-% Colour.values; // read the Companion's values
-% values( Colour ); // same as Colour.values
-% \end{lstlisting}
+\subsection{(Rework) Companion Object and Companion Function}
+
+\begin{lstlisting}[caption={Enum Type Functions}, label=lst:cforall_enum_functions]
+forall( T )
+struct Companion {
+        const T * const values;
+        const char * label;
+        int length;
+};
+\end{lstlisting}
+\CFA generates companion objects, an instance of structure that encloses @necessary@ data to represent an enumeration. The size of the companion is unknown at the compilation time, and it "grows" in size to compensate for the @usage@.
+
+The companion object is singleton across the compilation (investigation).  
+
+\CFA generates the definition of companion functions.
+Because \CFA implicitly stores an enumeration instance as its position, the companion function @position@ does nothing but return the position it is passed.
+Companions function @value@ and @label@ return the array item at the given position of @values@ and @labels@, respectively.
+\begin{lstlisting}[label=lst:companion_definition]
+int position( Companion o, int pos ) { return pos; }
+T value( Companion o, int pos ) { return o.values[ pos ]; }
+char * label( Companion o, int pos ) { return o.labels[ pos ]; }
+\end{lstlisting}
+Notably, the @Companion@ structure definition, and all companion objects, are visible to users.
+A user can retrieve values and labels defined in an enumeration by accessing the values and labels directly, or indirectly by calling @Companion@ functions @values@ and @labels@
+\begin{lstlisting}[label=lst:companion_definition_values_labels]
+Colour.values; // read the Companion's values
+values( Colour ); // same as Colour.values
+\end{lstlisting}
 
 \subsection{Companion Traits (experimental)}

src/AST/Decl.hpp

@@ -312 +312 @@
         ptr<Type> base;
         enum class EnumHiding { Visible, Hide } hide;
+
         EnumDecl( const CodeLocation& loc, const std::string& name, bool isTyped = false,
                 std::vector<ptr<Attribute>>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall,

src/CodeGen/CodeGenerator.cpp

@@ -1135 +1135 @@
                 if ( clause->when_cond ) {
                         output << "when(";
-                        clause->when_cond->accept( *visitor );
+                        stmt->timeout_cond->accept( *visitor );
                         output << ") ";
                 }

src/InitTweak/FixInit.cpp

@@ -49 +49 @@
         if ( auto inst = dynamic_cast<const ast::StructInstType *>( t ) ) {
                 return inst->base->params;
-        } else if ( auto inst = dynamic_cast<const ast::UnionInstType *>( t ) ) {
+        }
+        if ( auto inst = dynamic_cast<const ast::UnionInstType *>( t ) ) {
                 return inst->base->params;
         }
@@ -244 +245 @@
 const ast::DeclWithType * getDtorFunc( const ast::ObjectDecl * objDecl, const ast::Stmt * input, std::list< ast::ptr<ast::Stmt> > & stmtsToAdd ) {
         const CodeLocation loc = input->location;
+        // unwrap implicit statement wrapper
+        // Statement * dtor = input;
         assert( input );
+        // std::list< const ast::Expr * > matches;
         auto matches = collectCtorDtorCalls( input );
 
-        // The simple case requires a direct call and only one destructor call.
-        if ( dynamic_cast< const ast::ExprStmt * >( input ) && matches.size() == 1 ) {
-                auto func = getFunction( matches.front() );
-                assertf( func, "getFunction failed to find function in %s", toString( matches.front() ).c_str() );
-
-                // cleanup argument must be a function, not an object (including function pointer)
-                if ( auto dtorFunc = dynamic_cast< const ast::FunctionDecl * > ( func ) ) {
-                        if ( dtorFunc->type->forall.empty() ) {
-                                // simple case where the destructor is a monomorphic function call - can simply
-                                // use that function as the cleanup function.
-                                return func;
+        if ( dynamic_cast< const ast::ExprStmt * >( input ) ) {
+                // only one destructor call in the expression
+                if ( matches.size() == 1 ) {
+                        auto func = getFunction( matches.front() );
+                        assertf( func, "getFunction failed to find function in %s", toString( matches.front() ).c_str() );
+
+                        // cleanup argument must be a function, not an object (including function pointer)
+                        if ( auto dtorFunc = dynamic_cast< const ast::FunctionDecl * > ( func ) ) {
+                                if ( dtorFunc->type->forall.empty() ) {
+                                        // simple case where the destructor is a monomorphic function call - can simply
+                                        // use that function as the cleanup function.
+                                        return func;
+                                }
                         }
                 }
@@ -295 +301 @@
         for ( auto i = translationUnit.decls.begin(); i != translationUnit.decls.end(); ++i ) {
                 try {
+                        // maybeAccept( *i, fixer ); translationUnit should never contain null
                         *i = (*i)->accept(fixer);
                         translationUnit.decls.splice( i, fixer.core.staticDtorDecls );
@@ -307 +314 @@
 
 const ast::StmtExpr * StmtExprResult::previsit( const ast::StmtExpr * stmtExpr ) {
+        // we might loose the result expression here so add a pointer to trace back
         assert( stmtExpr->result );
-        if ( stmtExpr->result->isVoid() ) return stmtExpr;
-
-        auto mutExpr = mutate( stmtExpr );
-        const ast::CompoundStmt * body = mutExpr->stmts;
-        assert( !body->kids.empty() );
-        mutExpr->resultExpr = body->kids.back().strict_as<ast::ExprStmt>();
-        return mutExpr;
+        const ast::Type * result = stmtExpr->result;
+        if ( ! result->isVoid() ) {
+                auto mutExpr = mutate(stmtExpr);
+                const ast::CompoundStmt * body = mutExpr->stmts;
+                assert( ! body->kids.empty() );
+                mutExpr->resultExpr = body->kids.back().strict_as<ast::ExprStmt>();
+                return mutExpr;
+        }
+        return stmtExpr;
 }
 
@@ -320 +330 @@
         // wrap each top-level ExprStmt in a block so that destructors for argument and return temporaries are destroyed
         // in the correct places
-        return new ast::CompoundStmt( stmt->location, { stmt } );
+        ast::CompoundStmt * ret = new ast::CompoundStmt( stmt->location, { stmt } );
+        return ret;
 }
 
@@ -545 +556 @@
         arg = cpCtor;
         return destructRet( tmp, arg );
+
+        // impCpCtorExpr->dtors.push_front( makeCtorDtor( "^?{}", tmp ) );
 }
 
@@ -595 +608 @@
         }
         return nullptr;
+        // impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", ret ) );
 }
 
@@ -611 +625 @@
         for ( auto & arg : appExpr->args ) {
                 const ast::Type * formal = nullptr;
-                // Do not copy construct C-style variadic arguments.
-                if ( iter != params.end() ) {
+                if ( iter != params.end() ) { // does not copy construct C-style variadic arguments
+                        // DeclarationWithType * param = *iter++;
                         formal = *iter++;
                 }
@@ -645 +659 @@
         // deletion of wrapper should be handled by pass template now
 
+        // impCpCtorExpr->callExpr = nullptr;
         assert (appExpr->env == nullptr);
         appExpr->env = impCpCtorExpr->env;
+        // std::swap( impCpCtorExpr->env, appExpr->env );
+        // assert( impCpCtorExpr->env == nullptr );
+        // delete impCpCtorExpr;
 
         if ( returnDecl ) {
@@ -658 +676 @@
                 }
                 // move env from appExpr to retExpr
+                // std::swap( assign->env, appExpr->env );
                 assign->env = appExpr->env;
                 // actual env is handled by common routine that replaces WithTypeSubstitution
@@ -697 +716 @@
 
         assert( stmtExpr->result );
-        if ( stmtExpr->result->isVoid() ) {
-                assert( stmtExpr->returnDecls.empty() );
-                assert( stmtExpr->dtors.empty() );
-
-                return stmtExpr;
-        }
-
-        static UniqueName retNamer("_tmp_stmtexpr_ret");
-
-        auto result = env->apply( stmtExpr->result.get() ).node;
-        if ( ! InitTweak::isConstructable( result ) ) {
-                return stmtExpr;
-        }
-        auto mutResult = result.get_and_mutate();
-        mutResult->set_const(false);
-
-        // create variable that will hold the result of the stmt expr
-        auto ret = new ast::ObjectDecl(loc, retNamer.newName(), mutResult, nullptr );
-        stmtsToAddBefore.push_back( new ast::DeclStmt(loc, ret ) );
-
-        assertf(
-                stmtExpr->resultExpr,
-                "Statement-Expression should have a resulting expression at %s:%d",
-                stmtExpr->location.filename.c_str(),
-                stmtExpr->location.first_line
-        );
-
-        const ast::ExprStmt * last = stmtExpr->resultExpr;
-        // xxx - if this is non-unique, need to copy while making resultExpr ref
-        assertf(last->unique(), "attempt to modify weakly shared statement");
-        auto mutLast = mutate(last);
-        // above assertion means in-place mutation is OK
-        try {
-                mutLast->expr = makeCtorDtor( "?{}", ret, mutLast->expr );
-        } catch(...) {
-                std::cerr << "*CFA internal error: ";
-                std::cerr << "can't resolve implicit constructor";
-                std::cerr << " at " << stmtExpr->location.filename;
-                std::cerr << ":" << stmtExpr->location.first_line << std::endl;
-
-                abort();
-        }
-
-        // add destructors after current statement
-        stmtsToAddAfter.push_back( new ast::ExprStmt(loc, makeCtorDtor( "^?{}", ret ) ) );
-
-        // must have a non-empty body, otherwise it wouldn't have a result
-        assert( ! stmts.empty() );
-
-        // if there is a return decl, add a use as the last statement; will not have return decl on non-constructable returns
-        stmts.push_back( new ast::ExprStmt(loc, new ast::VariableExpr(loc, ret ) ) );
+        // const ast::Type * result = stmtExpr->result;
+        if ( ! stmtExpr->result->isVoid() ) {
+                static UniqueName retNamer("_tmp_stmtexpr_ret");
+
+                // result = result->clone();
+                auto result = env->apply( stmtExpr->result.get() ).node;
+                if ( ! InitTweak::isConstructable( result ) ) {
+                        // delete result;
+                        return stmtExpr;
+                }
+                auto mutResult = result.get_and_mutate();
+                mutResult->set_const(false);
+
+                // create variable that will hold the result of the stmt expr
+                auto ret = new ast::ObjectDecl(loc, retNamer.newName(), mutResult, nullptr );
+                stmtsToAddBefore.push_back( new ast::DeclStmt(loc, ret ) );
+
+                assertf(
+                        stmtExpr->resultExpr,
+                        "Statement-Expression should have a resulting expression at %s:%d",
+                        stmtExpr->location.filename.c_str(),
+                        stmtExpr->location.first_line
+                );
+
+                const ast::ExprStmt * last = stmtExpr->resultExpr;
+                // xxx - if this is non-unique, need to copy while making resultExpr ref
+                assertf(last->unique(), "attempt to modify weakly shared statement");
+                auto mutLast = mutate(last);
+                // above assertion means in-place mutation is OK
+                try {
+                        mutLast->expr = makeCtorDtor( "?{}", ret, mutLast->expr );
+                } catch(...) {
+                        std::cerr << "*CFA internal error: ";
+                        std::cerr << "can't resolve implicit constructor";
+                        std::cerr << " at " << stmtExpr->location.filename;
+                        std::cerr << ":" << stmtExpr->location.first_line << std::endl;
+
+                        abort();
+                }
+
+                // add destructors after current statement
+                stmtsToAddAfter.push_back( new ast::ExprStmt(loc, makeCtorDtor( "^?{}", ret ) ) );
+
+                // must have a non-empty body, otherwise it wouldn't have a result
+                assert( ! stmts.empty() );
+
+                // if there is a return decl, add a use as the last statement; will not have return decl on non-constructable returns
+                stmts.push_back( new ast::ExprStmt(loc, new ast::VariableExpr(loc, ret ) ) );
+        } // if
 
         assert( stmtExpr->returnDecls.empty() );
@@ -781 +798 @@
         auto mutExpr = mutate(unqExpr);
         if ( ! unqMap.count( unqExpr->id ) ) {
+                // resolve expr and find its
+
                 auto impCpCtorExpr = mutExpr->expr.as<ast::ImplicitCopyCtorExpr>();
+                // PassVisitor<ResolveCopyCtors> fixer;
+
                 mutExpr->expr = mutExpr->expr->accept( *visitor );
                 // it should never be necessary to wrap a void-returning expression in a UniqueExpr - if this assumption changes, this needs to be rethought
@@ -799 +820 @@
         } else {
                 // take data from other UniqueExpr to ensure consistency
+                // delete unqExpr->get_expr();
                 mutExpr->expr = unqMap[mutExpr->id]->expr;
+                // delete unqExpr->result;
                 mutExpr->result = mutExpr->expr->result;
         }
@@ -809 +832 @@
 
         // since this removes the init field from objDecl, it must occur after children are mutated (i.e. postvisit)
-        ast::ptr<ast::ConstructorInit> ctorInit = _objDecl->init.as<ast::ConstructorInit>();
-
-        if ( nullptr == ctorInit ) return _objDecl;
-
-        auto objDecl = mutate(_objDecl);
-
-        // could this be non-unique?
-        if (objDecl != _objDecl) {
-                std::cerr << "FixInit: non-unique object decl " << objDecl->location << objDecl->name << std::endl;
-        }
-        // a decision should have been made by the resolver, so ctor and init are not both non-NULL
-        assert( ! ctorInit->ctor || ! ctorInit->init );
-        if ( const ast::Stmt * ctor = ctorInit->ctor ) {
-                if ( objDecl->storage.is_static ) {
-                        addDataSectionAttribute(objDecl);
-                        // originally wanted to take advantage of gcc nested functions, but
-                        // we get memory errors with this approach. To remedy this, the static
-                        // variable is hoisted when the destructor needs to be called.
-                        //
-                        // generate:
-                        // static T __objName_static_varN;
-                        // void __objName_dtor_atexitN() {
-                        //   __dtor__...;
-                        // }
-                        // int f(...) {
-                        //   ...
-                        //   static bool __objName_uninitialized = true;
-                        //   if (__objName_uninitialized) {
-                        //     __ctor(__objName);
-                        //     __objName_uninitialized = false;
-                        //     atexit(__objName_dtor_atexitN);
-                        //   }
-                        //   ...
-                        // }
-
-                        static UniqueName dtorCallerNamer( "_dtor_atexit" );
-
-                        // static bool __objName_uninitialized = true
-                        auto boolType = new ast::BasicType( ast::BasicType::Kind::Bool );
-                        auto boolInitExpr = new ast::SingleInit(loc, ast::ConstantExpr::from_int(loc, 1 ) );
-                        auto isUninitializedVar = new ast::ObjectDecl(loc, objDecl->mangleName + "_uninitialized", boolType, boolInitExpr, ast::Storage::Static, ast::Linkage::Cforall);
-                        isUninitializedVar->fixUniqueId();
-
-                        // __objName_uninitialized = false;
-                        auto setTrue = new ast::UntypedExpr(loc, new ast::NameExpr(loc, "?=?" ) );
-                        setTrue->args.push_back( new ast::VariableExpr(loc, isUninitializedVar ) );
-                        setTrue->args.push_back( ast::ConstantExpr::from_int(loc, 0 ) );
-
-                        // generate body of if
-                        auto initStmts = new ast::CompoundStmt(loc);
-                        auto & body = initStmts->kids;
-                        body.push_back( ctor );
-                        body.push_back( new ast::ExprStmt(loc, setTrue ) );
-
-                        // put it all together
-                        auto ifStmt = new ast::IfStmt(loc, new ast::VariableExpr(loc, isUninitializedVar ), initStmts, 0 );
-                        stmtsToAddAfter.push_back( new ast::DeclStmt(loc, isUninitializedVar ) );
-                        stmtsToAddAfter.push_back( ifStmt );
-
-                        const ast::Stmt * dtor = ctorInit->dtor;
-                        if ( dtor ) {
-                                // if the object has a non-trivial destructor, have to
-                                // hoist it and the object into the global space and
-                                // call the destructor function with atexit.
-
-                                // void __objName_dtor_atexitN(...) {...}
-                                ast::FunctionDecl * dtorCaller = new ast::FunctionDecl(loc, objDecl->mangleName + dtorCallerNamer.newName(), {}, {}, {}, {}, new ast::CompoundStmt(loc, {dtor}), ast::Storage::Static, ast::Linkage::C );
-                                dtorCaller->fixUniqueId();
-
-                                // atexit(dtor_atexit);
-                                auto callAtexit = new ast::UntypedExpr(loc, new ast::NameExpr(loc, "atexit" ) );
-                                callAtexit->args.push_back( new ast::VariableExpr(loc, dtorCaller ) );
-
-                                body.push_back( new ast::ExprStmt(loc, callAtexit ) );
-
-                                // hoist variable and dtor caller decls to list of decls that will be added into global scope
-                                staticDtorDecls.push_back( objDecl );
-                                staticDtorDecls.push_back( dtorCaller );
-
-                                // need to rename object uniquely since it now appears
-                                // at global scope and there could be multiple function-scoped
-                                // static variables with the same name in different functions.
-                                // Note: it isn't sufficient to modify only the mangleName, because
-                                // then subsequent SymbolTable passes can choke on seeing the object's name
-                                // if another object has the same name and type. An unfortunate side-effect
-                                // of renaming the object is that subsequent NameExprs may fail to resolve,
-                                // but there shouldn't be any remaining past this point.
-                                static UniqueName staticNamer( "_static_var" );
-                                objDecl->name = objDecl->name + staticNamer.newName();
-                                objDecl->mangleName = Mangle::mangle( objDecl );
-                                objDecl->init = nullptr;
-
-                                // xxx - temporary hack: need to return a declaration, but want to hoist the current object out of this scope
-                                // create a new object which is never used
-                                static UniqueName dummyNamer( "_dummy" );
-                                auto dummy = new ast::ObjectDecl(loc, dummyNamer.newName(), new ast::PointerType(new ast::VoidType()), nullptr, ast::Storage::Static, ast::Linkage::Cforall, 0, { new ast::Attribute("unused") } );
-                                return dummy;
+        if ( ast::ptr<ast::ConstructorInit> ctorInit = _objDecl->init.as<ast::ConstructorInit>() ) {
+                auto objDecl = mutate(_objDecl);
+
+                // could this be non-unique?
+                if (objDecl != _objDecl) {
+                        std::cerr << "FixInit: non-unique object decl " << objDecl->location << objDecl->name << std::endl;
+                }
+                // a decision should have been made by the resolver, so ctor and init are not both non-NULL
+                assert( ! ctorInit->ctor || ! ctorInit->init );
+                if ( const ast::Stmt * ctor = ctorInit->ctor ) {
+                        if ( objDecl->storage.is_static ) {
+                                addDataSectionAttribute(objDecl);
+                                // originally wanted to take advantage of gcc nested functions, but
+                                // we get memory errors with this approach. To remedy this, the static
+                                // variable is hoisted when the destructor needs to be called.
+                                //
+                                // generate:
+                                // static T __objName_static_varN;
+                                // void __objName_dtor_atexitN() {
+                                //   __dtor__...;
+                                // }
+                                // int f(...) {
+                                //   ...
+                                //   static bool __objName_uninitialized = true;
+                                //   if (__objName_uninitialized) {
+                                //     __ctor(__objName);
+                                //     __objName_uninitialized = false;
+                                //     atexit(__objName_dtor_atexitN);
+                                //   }
+                                //   ...
+                                // }
+
+                                static UniqueName dtorCallerNamer( "_dtor_atexit" );
+
+                                // static bool __objName_uninitialized = true
+                                auto boolType = new ast::BasicType( ast::BasicType::Kind::Bool );
+                                auto boolInitExpr = new ast::SingleInit(loc, ast::ConstantExpr::from_int(loc, 1 ) );
+                                auto isUninitializedVar = new ast::ObjectDecl(loc, objDecl->mangleName + "_uninitialized", boolType, boolInitExpr, ast::Storage::Static, ast::Linkage::Cforall);
+                                isUninitializedVar->fixUniqueId();
+
+                                // __objName_uninitialized = false;
+                                auto setTrue = new ast::UntypedExpr(loc, new ast::NameExpr(loc, "?=?" ) );
+                                setTrue->args.push_back( new ast::VariableExpr(loc, isUninitializedVar ) );
+                                setTrue->args.push_back( ast::ConstantExpr::from_int(loc, 0 ) );
+
+                                // generate body of if
+                                auto initStmts = new ast::CompoundStmt(loc);
+                                auto & body = initStmts->kids;
+                                body.push_back( ctor );
+                                body.push_back( new ast::ExprStmt(loc, setTrue ) );
+
+                                // put it all together
+                                auto ifStmt = new ast::IfStmt(loc, new ast::VariableExpr(loc, isUninitializedVar ), initStmts, 0 );
+                                stmtsToAddAfter.push_back( new ast::DeclStmt(loc, isUninitializedVar ) );
+                                stmtsToAddAfter.push_back( ifStmt );
+
+                                const ast::Stmt * dtor = ctorInit->dtor;
+
+                                // these should be automatically managed once reassigned
+                                // objDecl->set_init( nullptr );
+                                // ctorInit->set_ctor( nullptr );
+                                // ctorInit->set_dtor( nullptr );
+                                if ( dtor ) {
+                                        // if the object has a non-trivial destructor, have to
+                                        // hoist it and the object into the global space and
+                                        // call the destructor function with atexit.
+
+                                        // Statement * dtorStmt = dtor->clone();
+
+                                        // void __objName_dtor_atexitN(...) {...}
+                                        ast::FunctionDecl * dtorCaller = new ast::FunctionDecl(loc, objDecl->mangleName + dtorCallerNamer.newName(), {}, {}, {}, {}, new ast::CompoundStmt(loc, {dtor}), ast::Storage::Static, ast::Linkage::C );
+                                        dtorCaller->fixUniqueId();
+                                        // dtorCaller->stmts->push_back( dtor );
+
+                                        // atexit(dtor_atexit);
+                                        auto callAtexit = new ast::UntypedExpr(loc, new ast::NameExpr(loc, "atexit" ) );
+                                        callAtexit->args.push_back( new ast::VariableExpr(loc, dtorCaller ) );
+
+                                        body.push_back( new ast::ExprStmt(loc, callAtexit ) );
+
+                                        // hoist variable and dtor caller decls to list of decls that will be added into global scope
+                                        staticDtorDecls.push_back( objDecl );
+                                        staticDtorDecls.push_back( dtorCaller );
+
+                                        // need to rename object uniquely since it now appears
+                                        // at global scope and there could be multiple function-scoped
+                                        // static variables with the same name in different functions.
+                                        // Note: it isn't sufficient to modify only the mangleName, because
+                                        // then subsequent SymbolTable passes can choke on seeing the object's name
+                                        // if another object has the same name and type. An unfortunate side-effect
+                                        // of renaming the object is that subsequent NameExprs may fail to resolve,
+                                        // but there shouldn't be any remaining past this point.
+                                        static UniqueName staticNamer( "_static_var" );
+                                        objDecl->name = objDecl->name + staticNamer.newName();
+                                        objDecl->mangleName = Mangle::mangle( objDecl );
+                                        objDecl->init = nullptr;
+
+                                        // xxx - temporary hack: need to return a declaration, but want to hoist the current object out of this scope
+                                        // create a new object which is never used
+                                        static UniqueName dummyNamer( "_dummy" );
+                                        auto dummy = new ast::ObjectDecl(loc, dummyNamer.newName(), new ast::PointerType(new ast::VoidType()), nullptr, ast::Storage::Static, ast::Linkage::Cforall, 0, { new ast::Attribute("unused") } );
+                                        // delete ctorInit;
+                                        return dummy;
+                                } else {
+                                        objDecl->init = nullptr;
+                                        return objDecl;
+                                }
                         } else {
-                                objDecl->init = nullptr;
-                                return objDecl;
-                        }
+                                auto implicit = strict_dynamic_cast< const ast::ImplicitCtorDtorStmt * > ( ctor );
+                                auto ctorStmt = implicit->callStmt.as<ast::ExprStmt>();
+                                const ast::ApplicationExpr * ctorCall = nullptr;
+                                if ( ctorStmt && (ctorCall = isIntrinsicCallExpr( ctorStmt->expr )) && ctorCall->args.size() == 2 ) {
+                                        // clean up intrinsic copy constructor calls by making them into SingleInits
+                                        const ast::Expr * ctorArg = ctorCall->args.back();
+                                        // ctorCall should be gone afterwards
+                                        auto mutArg = mutate(ctorArg);
+                                        mutArg->env = ctorCall->env;
+                                        // std::swap( ctorArg->env, ctorCall->env );
+                                        objDecl->init = new ast::SingleInit(loc, mutArg );
+
+                                        // ctorCall->args.pop_back();
+                                } else {
+                                        stmtsToAddAfter.push_back( ctor );
+                                        objDecl->init = nullptr;
+                                        // ctorInit->ctor = nullptr;
+                                }
+
+                                const ast::Stmt * dtor = ctorInit->dtor;
+                                if ( dtor ) {
+                                        auto implicit = strict_dynamic_cast< const ast::ImplicitCtorDtorStmt * >( dtor );
+                                        const ast::Stmt * dtorStmt = implicit->callStmt;
+
+                                        // don't need to call intrinsic dtor, because it does nothing, but
+                                        // non-intrinsic dtors must be called
+                                        if ( ! isIntrinsicSingleArgCallStmt( dtorStmt ) ) {
+                                                // set dtor location to the object's location for error messages
+                                                auto dtorFunc = getDtorFunc( objDecl, dtorStmt, stmtsToAddBefore );
+                                                objDecl->attributes.push_back( new ast::Attribute( "cleanup", { new ast::VariableExpr(loc, dtorFunc ) } ) );
+                                                // ctorInit->dtor = nullptr;
+                                        } // if
+                                }
+                        } // if
+                } else if ( const ast::Init * init = ctorInit->init ) {
+                        objDecl->init = init;
+                        // ctorInit->init = nullptr;
                 } else {
-                        auto implicit = strict_dynamic_cast< const ast::ImplicitCtorDtorStmt * > ( ctor );
-                        auto ctorStmt = implicit->callStmt.as<ast::ExprStmt>();
-                        const ast::ApplicationExpr * ctorCall = nullptr;
-                        if ( ctorStmt && (ctorCall = isIntrinsicCallExpr( ctorStmt->expr )) && ctorCall->args.size() == 2 ) {
-                                // clean up intrinsic copy constructor calls by making them into SingleInits
-                                const ast::Expr * ctorArg = ctorCall->args.back();
-                                // ctorCall should be gone afterwards
-                                auto mutArg = mutate(ctorArg);
-                                mutArg->env = ctorCall->env;
-                                objDecl->init = new ast::SingleInit(loc, mutArg );
-                        } else {
-                                stmtsToAddAfter.push_back( ctor );
-                                objDecl->init = nullptr;
-                        }
-
-                        const ast::Stmt * dtor = ctorInit->dtor;
-                        if ( dtor ) {
-                                auto implicit = strict_dynamic_cast< const ast::ImplicitCtorDtorStmt * >( dtor );
-                                const ast::Stmt * dtorStmt = implicit->callStmt;
-
-                                // don't need to call intrinsic dtor, because it does nothing, but
-                                // non-intrinsic dtors must be called
-                                if ( ! isIntrinsicSingleArgCallStmt( dtorStmt ) ) {
-                                        // set dtor location to the object's location for error messages
-                                        auto dtorFunc = getDtorFunc( objDecl, dtorStmt, stmtsToAddBefore );
-                                        objDecl->attributes.push_back( new ast::Attribute( "cleanup", { new ast::VariableExpr(loc, dtorFunc ) } ) );
-                                } // if
-                        }
+                        // no constructor and no initializer, which is okay
+                        objDecl->init = nullptr;
                 } // if
-        } else if ( const ast::Init * init = ctorInit->init ) {
-                objDecl->init = init;
-        } else {
-                // no constructor and no initializer, which is okay
-                objDecl->init = nullptr;
+                // delete ctorInit;
+                return objDecl;
         } // if
-        return objDecl;
+        return _objDecl;
 }
 
@@ -968 +1006 @@
 
 void LabelFinder::previsit( const ast::CompoundStmt * stmt ) {
-        previsit( (const ast::Stmt *)stmt );
+        previsit( (const ast::Stmt *) stmt );
         Parent::previsit( stmt );
 }
@@ -984 +1022 @@
         // its children manually.
         if (funcDecl->type) funcDecl->type->accept(finder);
-        if (funcDecl->stmts) funcDecl->stmts->accept(finder);
+        // maybeAccept( funcDecl->type, finder );
+        if (funcDecl->stmts) funcDecl->stmts->accept(finder) ;
 
         // all labels for this function have been collected, insert destructors as appropriate via implicit recursion.
@@ -1039 +1078 @@
 }
 
-/// Should we check for warnings? (The function is user-defined constrctor or destructor.)
 bool checkWarnings( const ast::FunctionDecl * funcDecl ) {
+        // only check for warnings if the current function is a user-defined constructor or destructor
         if ( ! funcDecl ) return false;
         if ( ! funcDecl->stmts ) return false;
@@ -1066 +1105 @@
 
         isCtor = CodeGen::isConstructor( function->name );
-
-        // Remaining code is only for warnings.
-        if ( ! checkWarnings( function ) ) return;
-        thisParam = function->params.front().strict_as<ast::ObjectDecl>();
-        auto thisType = getPointerBase( thisParam->get_type() );
-        auto structType = dynamic_cast< const ast::StructInstType * >( thisType );
-        if ( structType ) {
-                structDecl = structType->base;
-                for ( auto & member : structDecl->members ) {
-                        if ( auto field = member.as<ast::ObjectDecl>() ) {
-                                // record all of the struct type's members that need to be constructed or
-                                // destructed by the end of the function
-                                unhandled.insert( field );
+        if ( checkWarnings( function ) ) {
+                // const ast::FunctionType * type = function->type;
+                // assert( ! type->params.empty() );
+                thisParam = function->params.front().strict_as<ast::ObjectDecl>();
+                auto thisType = getPointerBase( thisParam->get_type() );
+                auto structType = dynamic_cast< const ast::StructInstType * >( thisType );
+                if ( structType ) {
+                        structDecl = structType->base;
+                        for ( auto & member : structDecl->members ) {
+                                if ( auto field = member.as<ast::ObjectDecl>() ) {
+                                        // record all of the struct type's members that need to be constructed or
+                                        // destructed by the end of the function
+                                        unhandled.insert( field );
+                                }
                         }
                 }
@@ -1124 +1164 @@
 
                         // insert and resolve default/copy constructor call for each field that's unhandled
+                        // std::list< const ast::Stmt * > stmt;
                         ast::Expr * arg2 = nullptr;
                         if ( function->name == "?{}" && isCopyFunction( function ) ) {
                                 // if copy ctor, need to pass second-param-of-this-function.field
+                                // std::list< DeclarationWithType * > & params = function->get_functionType()->get_parameters();
                                 assert( function->params.size() == 2 );
                                 arg2 = new ast::MemberExpr(funcDecl->location, field, new ast::VariableExpr(funcDecl->location, function->params.back() ) );
@@ -1137 +1179 @@
 
                         if ( callStmt ) {
+                                // auto & callStmt = stmt.front();
+
                                 try {
                                         callStmt = callStmt->accept( *visitor );
@@ -1142 +1186 @@
                                                 mutStmts->push_front( callStmt );
                                         } else { // TODO: don't generate destructor function/object for intrinsic calls
+                                                // destructor statements should be added at the end
+                                                // function->get_statements()->push_back( callStmt );
 
                                                 // Optimization: do not need to call intrinsic destructors on members
@@ -1176 +1222 @@
                 throw errors;
         }
+        // return funcDecl;
         return function;
 }
@@ -1209 +1256 @@
 
         std::string fname = getFunctionName( appExpr );
-        if ( fname != function->name ) return;
-
-        // call to same kind of function
-        const ast::Expr * firstParam = appExpr->args.front();
-        if ( isThisExpression( firstParam, thisParam ) ) {
-                // if calling another constructor on thisParam, assume that function handles
-                // all members - if it doesn't a warning will appear in that function.
-                unhandled.clear();
-        } else if ( auto memberExpr = isThisMemberExpr( firstParam, thisParam ) ) {
-                // if first parameter is a member expression on the this parameter,
-                // then remove the member from unhandled set.
-                if ( isThisExpression( memberExpr->aggregate, thisParam ) ) {
-                        unhandled.erase( memberExpr->member );
+        if ( fname == function->name ) {
+                // call to same kind of function
+                const ast::Expr * firstParam = appExpr->args.front();
+
+                if ( isThisExpression( firstParam, thisParam ) ) {
+                        // if calling another constructor on thisParam, assume that function handles
+                        // all members - if it doesn't a warning will appear in that function.
+                        unhandled.clear();
+                } else if ( auto memberExpr = isThisMemberExpr( firstParam, thisParam ) ) {
+                        // if first parameter is a member expression on the this parameter,
+                        // then remove the member from unhandled set.
+                        if ( isThisExpression( memberExpr->aggregate, thisParam ) ) {
+                                unhandled.erase( memberExpr->member );
+                        }
                 }
         }
@@ -1267 +1315 @@
         ast::ptr<ast::ApplicationExpr> callExpr = ctorExpr->callExpr.strict_as<ast::ApplicationExpr>();
         ast::ptr<ast::TypeSubstitution> env = ctorExpr->env;
+        // ctorExpr->set_callExpr( nullptr );
+        // ctorExpr->set_env( nullptr );
 
         // xxx - ideally we would reuse the temporary generated from the copy constructor passes from within firstArg if it exists and not generate a temporary if it's unnecessary.

src/Parser/ExpressionNode.cc

@@ -673 +673 @@
                 ast::LogicalFlag flag ) {
         return new ast::LogicalExpr( location,
-                maybeMoveBuild( expr_node1 ),
-                maybeMoveBuild( expr_node2 ),
+                notZeroExpr( maybeMoveBuild( expr_node1 ) ),
+                notZeroExpr( maybeMoveBuild( expr_node2 ) ),
                 flag
         );
@@ -713 +713 @@
                 ExpressionNode * expr_node3 ) {
         return new ast::ConditionalExpr( location,
-                maybeMoveBuild( expr_node1 ),
+                notZeroExpr( maybeMoveBuild( expr_node1 ) ),
                 maybeMoveBuild( expr_node2 ),
                 maybeMoveBuild( expr_node3 )

src/Parser/parserutility.cc

@@ -27 +27 @@
 //    if ( (int)(x != 0) ) ...
 
-ast::Expr * notZeroExpr( const ast::Expr * orig ) {
+ast::Expr * notZeroExpr( ast::Expr * orig ) {
         return ( !orig ) ? nullptr : new ast::CastExpr( orig->location,
                 ast::UntypedExpr::createCall( orig->location,

src/Parser/parserutility.h

@@ -21 +21 @@
 }
 
-ast::Expr * notZeroExpr( const ast::Expr *orig );
+ast::Expr * notZeroExpr( ast::Expr *orig );
 
 template< typename T >

src/ResolvExpr/CandidateFinder.cpp

@@ -46 +46 @@
 #include "AST/Type.hpp"
 #include "Common/utility.h"       // for move, copy
-#include "Parser/parserutility.h" // for notZeroExpr
 #include "SymTab/Mangler.h"
 #include "Tuples/Tuples.h"        // for handleTupleAssignment
@@ -1503 +1502 @@
         void Finder::postvisit( const ast::LogicalExpr * logicalExpr ) {
                 CandidateFinder finder1( context, tenv );
-                ast::ptr<ast::Expr> arg1 = notZeroExpr( logicalExpr->arg1 );
-                finder1.find( arg1, ResolveMode::withAdjustment() );
+                finder1.find( logicalExpr->arg1, ResolveMode::withAdjustment() );
                 if ( finder1.candidates.empty() ) return;
 
                 CandidateFinder finder2( context, tenv );
-                ast::ptr<ast::Expr> arg2 = notZeroExpr( logicalExpr->arg2 );
-                finder2.find( arg2, ResolveMode::withAdjustment() );
+                finder2.find( logicalExpr->arg2, ResolveMode::withAdjustment() );
                 if ( finder2.candidates.empty() ) return;
 
@@ -1535 +1532 @@
                 // candidates for condition
                 CandidateFinder finder1( context, tenv );
-                ast::ptr<ast::Expr> arg1 = notZeroExpr( conditionalExpr->arg1 );
-                finder1.find( arg1, ResolveMode::withAdjustment() );
+                finder1.find( conditionalExpr->arg1, ResolveMode::withAdjustment() );
                 if ( finder1.candidates.empty() ) return;
 

src/Validate/Autogen.cpp

@@ -803 +803 @@
 }
 
+struct PseudoFuncGenerateRoutine final :
+                public ast::WithDeclsToAdd<>,
+                public ast::WithShortCircuiting {
+        void previsit( const ast::EnumDecl * enumDecl );
+};
+
+void PseudoFuncGenerateRoutine::previsit( const ast::EnumDecl * enumDecl ) {
+        const CodeLocation& location = enumDecl->location;
+        if ( enumDecl->members.size() == 0 || !enumDecl->base || enumDecl->name == "" ) return;
+
+        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 );
+                labels.emplace_back( new ast::SingleInit( 
+                        location, ast::ConstantExpr::from_string(location, mem->name) ) );
+        }
+        auto init = new ast::ListInit( location, std::move( inits ) );
+        auto label_strings = new ast::ListInit( location, std::move(labels) );
+        auto values = new ast::ObjectDecl( 
+                location,
+                "__enum_values_"+enumDecl->name,
+                new ast::ArrayType(
+                        // new ast::PointerType( new ast::BasicType{ ast::BasicType::Char} ),
+                        enumDecl->base,
+                        ast::ConstantExpr::from_int( location, enumDecl->members.size() ), 
+                        ast::LengthFlag::FixedLen, ast::DimensionFlag::DynamicDim
+                )
+                ,init
+                ,
+                ast::Storage::Static,
+                ast::Linkage::AutoGen
+        );
+        auto label_arr = new ast::ObjectDecl(
+                location,
+                "__enum_labels_"+enumDecl->name,
+                new ast::ArrayType(
+                        new ast::PointerType( new ast::BasicType{ ast::BasicType::Char} ),
+                        ast::ConstantExpr::from_int( location, enumDecl->members.size() ), 
+                        ast::LengthFlag::FixedLen, ast::DimensionFlag::DynamicDim
+                ),
+                label_strings,
+                ast::Storage::Static,
+                ast::Linkage::AutoGen
+        );
+
+        declsToAddAfter.push_back( values );
+        declsToAddAfter.push_back( label_arr );
+}
+
 } // namespace
 
 void autogenerateRoutines( ast::TranslationUnit & translationUnit ) {
         ast::Pass<AutogenerateRoutines>::run( translationUnit );
+        // ast::Pass<PseudoFuncGenerateRoutine>::run( translationUnit );
 }
 

src/Validate/ReplacePseudoFunc.cpp

@@ +1 @@
+#include "AST/Decl.hpp"
+#include "AST/Pass.hpp"
+#include "AST/Stmt.hpp"
+#include "AST/Inspect.hpp"
+#include "Common/utility.h"
 #include "ReplacePseudoFunc.hpp"
 
-#include <set>
-
-#include "AST/Decl.hpp"
-#include "AST/Inspect.hpp"
-#include "AST/Pass.hpp"
-#include "AST/Stmt.hpp"
-#include "Common/utility.h"
-#include "ResolvExpr/Resolver.h"
-#include "SymTab/Mangler.h"  // for Mangler
 namespace Validate {
 
 namespace {
 
-std::set<std::string> queryLabels;
-std::set<std::string> queryValues;
-
-struct FindGenEnumArray final : public ast::WithShortCircuiting {
-    void previsit(const ast::ApplicationExpr* enumDecl);
+struct ReplacePseudoFuncCore {
+    ast::Expr const * postvisit( ast::ApplicationExpr const * decl );
 };
-
-void FindGenEnumArray::previsit(const ast::ApplicationExpr* expr) {
-    auto fname = ast::getFunctionName(expr);
-    if (fname == "labelE" || fname == "valueE") {
-        if (expr->args.size() != 1) {
-            SemanticError(expr, "Position Expression only take one parameter");
-        }
-        const ast::VariableExpr* arg =
-            expr->args.front().as<const ast::VariableExpr>();
-        if (!arg) {
-            SemanticError(expr, "Unimplement Pseudo Function Cases");
-        }
-        const ast::ObjectDecl* argAsVar = arg->var.as<const ast::ObjectDecl>();
-        const std::string referredName = argAsVar->name;
-        const ast::EnumInstType* argType =
-            argAsVar->type.as<const ast::EnumInstType>();
-        if (!argType) {
-            SemanticError(
-                argAsVar,
-                "Position can only be used on an enumeration instance");
-        }
-        ast::ptr<ast::EnumDecl> base = argType->base;
-        assert(base);
-        if (fname == "labelE") queryLabels.insert(base->name);
-        if (fname == "valueE") queryValues.insert(base->name);
-    }
 }
 
-struct PseudoFuncGenerateRoutine final : public ast::WithDeclsToAdd<>,
-                                         public ast::WithSymbolTable,
-                                         public ast::WithShortCircuiting {
-    void previsit(const ast::EnumDecl* enumDecl);
-};
-
-void PseudoFuncGenerateRoutine::previsit(const ast::EnumDecl* enumDecl) {
-    visit_children = false;
-    const CodeLocation& location = enumDecl->location;
-    if (enumDecl->members.size() == 0 || !enumDecl->base) return;
-
-    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);
-        labels.emplace_back(new ast::SingleInit(
-            location, ast::ConstantExpr::from_string(location, mem->name)));
-    }
-    if (queryValues.count(enumDecl->name)) {
-        auto init = new ast::ListInit(location, std::move(inits));
-        auto values = new ast::ObjectDecl(
-            location, "values_" + enumDecl->name,
-            new ast::ArrayType(
-                enumDecl->base,
-                ast::ConstantExpr::from_int(location, enumDecl->members.size()),
-                ast::LengthFlag::FixedLen, ast::DimensionFlag::DynamicDim),
-            init, ast::Storage::Static, ast::Linkage::AutoGen);
-        symtab.addId(values);
-        values->mangleName = Mangle::mangle(values);
-        declsToAddAfter.push_back(values);
-    }
-    if (queryLabels.count(enumDecl->name)) {
-        auto label_strings = new ast::ListInit(location, std::move(labels));
-        auto label_arr = new ast::ObjectDecl(
-            location, "labels_" + enumDecl->name,
-            new ast::ArrayType(
-                new ast::PointerType(new ast::BasicType{ast::BasicType::Char}),
-                ast::ConstantExpr::from_int(location, enumDecl->members.size()),
-                ast::LengthFlag::FixedLen, ast::DimensionFlag::DynamicDim),
-            label_strings, ast::Storage::Static, ast::Linkage::AutoGen);
-        symtab.addId(label_arr);
-        label_arr->mangleName = Mangle::mangle(label_arr);
-        declsToAddAfter.push_back(label_arr);
-    }
-}
-
-struct ReplacePseudoFuncCore : public ast::WithShortCircuiting,
-                               public ast::WithSymbolTable,
-                               public ast::WithConstTranslationUnit {
-    ast::Expr const* postvisit(ast::ApplicationExpr const* decl);
-};
-
-ast::Expr const* ReplacePseudoFuncCore::postvisit(
-    ast::ApplicationExpr const* expr) {
-    auto fname = ast::getFunctionName(expr);
-    auto location = expr->location;
-    if (fname == "posE" || fname == "valueE" || fname == "labelE") {
-        if (expr->args.size() != 1) {
-            SemanticError(expr,
-                          "Pseudo Enum Expression only take one parameter");
+ast::Expr const * ReplacePseudoFuncCore::postvisit( ast::ApplicationExpr const * expr) {
+    auto fname = ast::getFunctionName( expr );
+    if ( fname == "posE" ) {
+        // std::cerr << "Found App in ReplacePseudoFunc" << std::endl;
+        if ( expr->args.size() != 1 ) {
+            SemanticError( expr, "Position Expression only take one parameter" );
         }
-        ast::ptr<ast::VariableExpr> arg =
-            expr->args.front().as<const ast::VariableExpr>();
-        if (!arg) {
-            SemanticError(expr, "Unimplement Pseudo Function Cases");
+        const ast::VariableExpr * arg = expr->args.front().as<const ast::VariableExpr>();
+        if ( !arg ) {
+            SemanticError( expr, "Unimplement Pseudo Function Cases" );
         }
-        const ast::ObjectDecl* argAsVar = arg->var.as<const ast::ObjectDecl>();
+        const ast::ObjectDecl * argAsVar = arg->var.as<const ast::ObjectDecl>();
         const std::string referredName = argAsVar->name;
-        const ast::EnumInstType* argType =
-            argAsVar->type.as<const ast::EnumInstType>();
-        if (!argType) {
-            SemanticError(argAsVar,
-                          "Pseudo Enum Expression can only be used on an "
-                          "enumeration instance");
+        const ast::EnumInstType * argType = argAsVar->type.as<const ast::EnumInstType>();
+        if ( !argType ) {
+            SemanticError( argAsVar, "Position can only be used on an enumeration instance" );
         }
-        const ast::EnumDecl* base = argType->base;
-        for (size_t i = 0; i < base->members.size(); i++) {
-            if (base->members[i]->name == referredName) {
-                if (fname == "posE")
-                    return ast::ConstantExpr::from_int(expr->location, i);
-                else if (fname == "labelE")
-                    return ast::ConstantExpr::from_string(expr->location,
-                                                          referredName);
-                else
-                    return new ast::TypeExpr(expr->location, argType);
-            }
-        }
-
-        ResolvExpr::ResolveContext context{symtab, transUnit().global};
-
-        if (fname == "labelE") {
-            ast::Expr* toResolve =
-                new ast::NameExpr(expr->location, "labels_" + base->name);
-            auto result = ResolvExpr::findVoidExpression(toResolve, context);
-            if (result.get()) {
-                auto arrAsVar = result.strict_as<ast::VariableExpr>();
-                auto untyped = new ast::UntypedExpr(
-                    location, new ast::NameExpr(location, "?[?]"),
-                    {new ast::VariableExpr(*arrAsVar),
-                     ast::ConstantExpr::from_int(
-                         location,
-                         0)});  /// TODO: dummy value.
-                                /// To make it works need to change the unifier
-
-                auto typedResult =
-                    ResolvExpr::findVoidExpression(untyped, context);
-                if (result.get()) {
-                    ast::ptr<ast::ApplicationExpr> ret =
-                        typedResult.strict_as<ast::ApplicationExpr>();
-                    return new ast::ApplicationExpr(*ret);
-                }
-            }
-        }
-        
-        if (fname == "valueE") {
-            ast::Expr* toResolve =
-                new ast::NameExpr(expr->location, "values_" + base->name);
-            auto result = ResolvExpr::findVoidExpression(toResolve, context);
-            if (result.get()) {
-                auto arrAsVar = result.strict_as<ast::VariableExpr>();
-                auto untyped = new ast::UntypedExpr(
-                    location, new ast::NameExpr(location, "?[?]"),
-                    {new ast::VariableExpr(*arrAsVar),
-                     ast::ConstantExpr::from_int(
-                         location,
-                         0)});  /// TODO: dummy value.
-                                /// To make it works need to change the unifier
-
-                auto typedResult =
-                    ResolvExpr::findVoidExpression(untyped, context);
-                if (result.get()) {
-                    ast::ptr<ast::ApplicationExpr> ret =
-                        typedResult.strict_as<ast::ApplicationExpr>();
-                    return new ast::ApplicationExpr(*ret);
-                }
+        const ast::EnumDecl * base = argType->base;
+        for ( size_t i = 0; i < base->members.size(); i++ ) {
+            if ( base->members[i]->name == referredName ) {
+                return ast::ConstantExpr::from_int( expr->location, i );
             }
         }
@@ -190 +42 @@
 }
 
-}  // namespace
 
-void replacePseudoFunc(ast::TranslationUnit& translationUnit) {
-    ast::Pass<FindGenEnumArray>::run(translationUnit);
-    ast::Pass<PseudoFuncGenerateRoutine>::run(translationUnit);
-    ast::Pass<ReplacePseudoFuncCore>::run(translationUnit);
+
+void replacePseudoFunc( ast::TranslationUnit & translationUnit ) {
+    ast::Pass<ReplacePseudoFuncCore>::run( translationUnit );
 }
-}  // namespace Validate
+
+}

src/main.cc

@@ -82 +82 @@
 #include "Validate/ReturnCheck.hpp"         // for checkReturnStatements
 #include "Validate/VerifyCtorDtorAssign.hpp" // for verifyCtorDtorAssign
-#include "Validate/ReplacePseudoFunc.hpp"   // for replacePseudoFunc
+#include "Validate/ReplacePseudoFunc.hpp"
 #include "Virtual/ExpandCasts.h"            // for expandCasts
 #include "Virtual/VirtualDtor.hpp"          // for implementVirtDtors