Index: src/AST/Convert.cpp
===================================================================
--- src/AST/Convert.cpp	(revision 3c79ea90a8fd40d78d65b7465383c83051a807e0)
+++ src/AST/Convert.cpp	(revision 4c530a517ad27e21191fa09816161ecc4ca7a818)
@@ -10,6 +10,6 @@
 // Created On       : Thu May 09 15::37::05 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed Mar 16 15:01:00 2022
-// Update Count     : 42
+// Last Modified On : Wed Apr 20 13:58:00 2022
+// Update Count     : 43
 //
 
@@ -562,21 +562,27 @@
 		for ( auto clause : node->clauses ) {
 			stmt->clauses.push_back({{
-					get<Expression>().accept1( clause.target.func ),
-					get<Expression>().acceptL( clause.target.args ),
+					get<Expression>().accept1( clause->target_func ),
+					get<Expression>().acceptL( clause->target_args ),
 				},
-				get<Statement>().accept1( clause.stmt ),
-				get<Expression>().accept1( clause.cond ),
+				get<Statement>().accept1( clause->stmt ),
+				get<Expression>().accept1( clause->cond ),
 			});
 		}
 		stmt->timeout = {
-			get<Expression>().accept1( node->timeout.time ),
-			get<Statement>().accept1( node->timeout.stmt ),
-			get<Expression>().accept1( node->timeout.cond ),
+			get<Expression>().accept1( node->timeout_time ),
+			get<Statement>().accept1( node->timeout_stmt ),
+			get<Expression>().accept1( node->timeout_cond ),
 		};
 		stmt->orelse = {
-			get<Statement>().accept1( node->orElse.stmt ),
-			get<Expression>().accept1( node->orElse.cond ),
+			get<Statement>().accept1( node->else_stmt ),
+			get<Expression>().accept1( node->else_cond ),
 		};
 		return stmtPostamble( stmt, node );
+	}
+
+	const ast::WaitForClause * visit( const ast::WaitForClause * node ) override final {
+		// There is no old-AST WaitForClause, so this should never be called.
+		assert( !node );
+		return nullptr;
 	}
 
@@ -2096,22 +2102,18 @@
 		stmt->clauses.reserve( old->clauses.size() );
 		for (size_t i = 0 ; i < old->clauses.size() ; ++i) {
-			stmt->clauses.push_back({
-				ast::WaitForStmt::Target{
-					GET_ACCEPT_1(clauses[i].target.function, Expr),
-					GET_ACCEPT_V(clauses[i].target.arguments, Expr)
-				},
-				GET_ACCEPT_1(clauses[i].statement, Stmt),
-				GET_ACCEPT_1(clauses[i].condition, Expr)
-			});
-		}
-		stmt->timeout = {
-			GET_ACCEPT_1(timeout.time, Expr),
-			GET_ACCEPT_1(timeout.statement, Stmt),
-			GET_ACCEPT_1(timeout.condition, Expr),
-		};
-		stmt->orElse = {
-			GET_ACCEPT_1(orelse.statement, Stmt),
-			GET_ACCEPT_1(orelse.condition, Expr),
-		};
+			auto clause = new ast::WaitForClause( old->location );
+
+			clause->target_func = GET_ACCEPT_1(clauses[i].target.function, Expr);
+			clause->target_args = GET_ACCEPT_V(clauses[i].target.arguments, Expr);
+			clause->stmt = GET_ACCEPT_1(clauses[i].statement, Stmt);
+			clause->cond = GET_ACCEPT_1(clauses[i].condition, Expr);
+
+			stmt->clauses.push_back( clause );
+		}
+		stmt->timeout_time = GET_ACCEPT_1(timeout.time, Expr);
+		stmt->timeout_stmt = GET_ACCEPT_1(timeout.statement, Stmt);
+		stmt->timeout_cond = GET_ACCEPT_1(timeout.condition, Expr);
+		stmt->else_stmt = GET_ACCEPT_1(orelse.statement, Stmt);
+		stmt->else_cond = GET_ACCEPT_1(orelse.condition, Expr);
 
 		this->node = stmt;
@@ -2775,8 +2777,8 @@
 	}
 
-	virtual void visit( const EnumInstType * old ) override final { // Here is visiting the EnumInst Decl not the usage.
+	virtual void visit( const EnumInstType * old ) override final {
 		ast::EnumInstType * ty; 
 		if ( old->baseEnum ) {
-			ty = new ast::EnumInstType{ // Probably here: missing the specification of the base
+			ty = new ast::EnumInstType{
 				GET_ACCEPT_1( baseEnum, EnumDecl ),
 				cv( old ),
Index: src/AST/Fwd.hpp
===================================================================
--- src/AST/Fwd.hpp	(revision 3c79ea90a8fd40d78d65b7465383c83051a807e0)
+++ src/AST/Fwd.hpp	(revision 4c530a517ad27e21191fa09816161ecc4ca7a818)
@@ -56,4 +56,5 @@
 class SuspendStmt;
 class WaitForStmt;
+class WaitForClause;
 class WithStmt;
 class DeclStmt;
Index: src/AST/Node.cpp
===================================================================
--- src/AST/Node.cpp	(revision 3c79ea90a8fd40d78d65b7465383c83051a807e0)
+++ src/AST/Node.cpp	(revision 4c530a517ad27e21191fa09816161ecc4ca7a818)
@@ -176,4 +176,6 @@
 template class ast::ptr_base< ast::WaitForStmt, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::WaitForStmt, ast::Node::ref_type::strong >;
+template class ast::ptr_base< ast::WaitForClause, ast::Node::ref_type::weak >;
+template class ast::ptr_base< ast::WaitForClause, ast::Node::ref_type::strong >;
 template class ast::ptr_base< ast::WithStmt, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::WithStmt, ast::Node::ref_type::strong >;
Index: src/AST/Pass.hpp
===================================================================
--- src/AST/Pass.hpp	(revision 3c79ea90a8fd40d78d65b7465383c83051a807e0)
+++ src/AST/Pass.hpp	(revision 4c530a517ad27e21191fa09816161ecc4ca7a818)
@@ -158,4 +158,5 @@
 	const ast::Stmt *             visit( const ast::SuspendStmt          * ) override final;
 	const ast::Stmt *             visit( const ast::WaitForStmt          * ) override final;
+	const ast::WaitForClause *    visit( const ast::WaitForClause        * ) override final;
 	const ast::Decl *             visit( const ast::WithStmt             * ) override final;
 	const ast::NullStmt *         visit( const ast::NullStmt             * ) override final;
Index: src/AST/Pass.impl.hpp
===================================================================
--- src/AST/Pass.impl.hpp	(revision 3c79ea90a8fd40d78d65b7465383c83051a807e0)
+++ src/AST/Pass.impl.hpp	(revision 4c530a517ad27e21191fa09816161ecc4ca7a818)
@@ -1010,81 +1010,31 @@
 const ast::Stmt * ast::Pass< core_t >::visit( const ast::WaitForStmt * node ) {
 	VISIT_START( node );
-		// for( auto & clause : node->clauses ) {
-		// 	maybeAccept_impl( clause.target.function, *this );
-		// 	maybeAccept_impl( clause.target.arguments, *this );
-
-		// 	maybeAccept_impl( clause.statement, *this );
-		// 	maybeAccept_impl( clause.condition, *this );
-		// }
-
-	if ( __visit_children() ) {
-		std::vector<WaitForStmt::Clause> new_clauses;
-		new_clauses.reserve( node->clauses.size() );
-		bool mutated = false;
-		for( const auto & clause : node->clauses ) {
-
-			const Expr * func = clause.target.func ? clause.target.func->accept(*this) : nullptr;
-			if(func != clause.target.func) mutated = true;
-			else func = nullptr;
-
-			std::vector<ptr<Expr>> new_args;
-			new_args.reserve(clause.target.args.size());
-			for( const auto & arg : clause.target.args ) {
-				auto a = arg->accept(*this);
-				if( a != arg ) {
-					mutated = true;
-					new_args.push_back( a );
-				} else
-					new_args.push_back( nullptr );
-			}
-
-			const Stmt * stmt = clause.stmt ? clause.stmt->accept(*this) : nullptr;
-			if(stmt != clause.stmt) mutated = true;
-			else stmt = nullptr;
-
-			const Expr * cond = clause.cond ? clause.cond->accept(*this) : nullptr;
-			if(cond != clause.cond) mutated = true;
-			else cond = nullptr;
-
-			new_clauses.push_back( WaitForStmt::Clause{ {func, std::move(new_args) }, stmt, cond } );
-		}
-
-		if(mutated) {
-			auto n = __pass::mutate<core_t>(node);
-			for(size_t i = 0; i < new_clauses.size(); i++) {
-				if(new_clauses.at(i).target.func != nullptr) swap(n->clauses.at(i).target.func, new_clauses.at(i).target.func);
-
-				for(size_t j = 0; j < new_clauses.at(i).target.args.size(); j++) {
-					if(new_clauses.at(i).target.args.at(j) != nullptr) swap(n->clauses.at(i).target.args.at(j), new_clauses.at(i).target.args.at(j));
-				}
-
-				if(new_clauses.at(i).stmt != nullptr) swap(n->clauses.at(i).stmt, new_clauses.at(i).stmt);
-				if(new_clauses.at(i).cond != nullptr) swap(n->clauses.at(i).cond, new_clauses.at(i).cond);
-			}
-			node = n;
-		}
-	}
-
-	#define maybe_accept(field) \
-		if(node->field) { \
-			auto nval = call_accept( node->field ); \
-			if(nval.differs ) { \
-				auto nparent = __pass::mutate<core_t>(node); \
-				nparent->field = nval.value; \
-				node = nparent; \
-			} \
-		}
-
-	if ( __visit_children() ) {
-		maybe_accept( timeout.time );
-		maybe_accept( timeout.stmt );
-		maybe_accept( timeout.cond );
-		maybe_accept( orElse.stmt  );
-		maybe_accept( orElse.cond  );
-	}
-
-	#undef maybe_accept
+
+	if ( __visit_children() ) {
+		maybe_accept( node, &WaitForStmt::clauses );
+		maybe_accept( node, &WaitForStmt::timeout_time );
+		maybe_accept( node, &WaitForStmt::timeout_stmt );
+		maybe_accept( node, &WaitForStmt::timeout_cond );
+		maybe_accept( node, &WaitForStmt::else_stmt );
+		maybe_accept( node, &WaitForStmt::else_cond );
+	}
 
 	VISIT_END( Stmt, node );
+}
+
+//--------------------------------------------------------------------------
+// WaitForClause
+template< typename core_t >
+const ast::WaitForClause * ast::Pass< core_t >::visit( const ast::WaitForClause * node ) {
+	VISIT_START( node );
+
+	if ( __visit_children() ) {
+		maybe_accept( node, &WaitForClause::target_func );
+		maybe_accept( node, &WaitForClause::target_args );
+		maybe_accept( node, &WaitForClause::stmt );
+		maybe_accept( node, &WaitForClause::cond );
+	}
+
+	VISIT_END( WaitForClause, node );
 }
 
Index: src/AST/Print.cpp
===================================================================
--- src/AST/Print.cpp	(revision 3c79ea90a8fd40d78d65b7465383c83051a807e0)
+++ src/AST/Print.cpp	(revision 4c530a517ad27e21191fa09816161ecc4ca7a818)
@@ -760,50 +760,55 @@
 		indent += 2;
 		for( const auto & clause : node->clauses ) {
-			os << indent-1 << "target function: ";
-			safe_print( clause.target.func );
-
-			if ( ! clause.target.args.empty() ) {
-				os << endl << indent-1 << "... with arguments:" << endl;
-				for( const ast::Expr * arg : clause.target.args ) {
-					arg->accept( *this );
-				}
+			clause->accept( *this );
+		}
+
+		if ( node->timeout_time ) {
+			os << indent-1 << "timeout of:" << endl;
+			node->timeout_time->accept( *this );
+
+			if ( node->timeout_stmt ) {
+				os << indent-1 << "... with statment:" << endl;
+				node->timeout_stmt->accept( *this );
 			}
 
-			if ( clause.stmt ) {
-				os << indent-1 << "... with statment:" << endl;
-				clause.stmt->accept( *this );
+			if ( node->timeout_cond ) {
+				os << indent-1 << "... with condition:" << endl;
+				node->timeout_cond->accept( *this );
 			}
-
-			if ( clause.cond ) {
+		}
+
+		if ( node->else_stmt ) {
+			os << indent-1 << "else:" << endl;
+			node->else_stmt->accept( *this );
+
+			if ( node->else_cond ) {
 				os << indent-1 << "... with condition:" << endl;
-				clause.cond->accept( *this );
+				node->else_cond->accept( *this );
 			}
 		}
 
-		if ( node->timeout.time ) {
-			os << indent-1 << "timeout of:" << endl;
-			node->timeout.time->accept( *this );
-
-			if ( node->timeout.stmt ) {
-				os << indent-1 << "... with statment:" << endl;
-				node->timeout.stmt->accept( *this );
+		return node;
+	}
+
+	virtual const ast::WaitForClause * visit( const ast::WaitForClause * node ) override final {
+		os << indent-1 << "target function: ";
+		safe_print( node->target_func );
+
+		if ( !node->target_args.empty() ) {
+			os << endl << indent-1 << "... with arguments:" << endl;
+			for( const ast::Expr * arg : node->target_args ) {
+				arg->accept( *this );
 			}
-
-			if ( node->timeout.cond ) {
-				os << indent-1 << "... with condition:" << endl;
-				node->timeout.cond->accept( *this );
-			}
-		}
-
-		if ( node->orElse.stmt ) {
-			os << indent-1 << "else:" << endl;
-			node->orElse.stmt->accept( *this );
-
-			if ( node->orElse.cond ) {
-				os << indent-1 << "... with condition:" << endl;
-				node->orElse.cond->accept( *this );
-			}
-		}
-		indent -= 2;
+		}
+
+		if ( node->stmt ) {
+			os << indent-1 << "... with statment:" << endl;
+			node->stmt->accept( *this );
+		}
+
+		if ( node->cond ) {
+			os << indent-1 << "... with condition:" << endl;
+			node->cond->accept( *this );
+		}
 
 		return node;
Index: src/AST/Stmt.hpp
===================================================================
--- src/AST/Stmt.hpp	(revision 3c79ea90a8fd40d78d65b7465383c83051a807e0)
+++ src/AST/Stmt.hpp	(revision 4c530a517ad27e21191fa09816161ecc4ca7a818)
@@ -10,6 +10,6 @@
 // Created On       : Wed May  8 13:00:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Mon Mar 28  9:50:00 2022
-// Update Count     : 35
+// Last Modified On : Wed Apr 20 14:34:00 2022
+// Update Count     : 36
 //
 
@@ -378,29 +378,10 @@
 class WaitForStmt final : public Stmt {
   public:
-	struct Target {
-		ptr<Expr> func;
-		std::vector<ptr<Expr>> args;
-	};
-
-	struct Clause {
-		Target target;
-		ptr<Stmt> stmt;
-		ptr<Expr> cond;
-	};
-
-	struct Timeout {
-		ptr<Expr> time;
-		ptr<Stmt> stmt;
-		ptr<Expr> cond;
-	};
-
-	struct OrElse {
-		ptr<Stmt> stmt;
-		ptr<Expr> cond;
-	};
-
-	std::vector<Clause> clauses;
-	Timeout timeout;
-	OrElse orElse;
+	std::vector<ptr<WaitForClause>> clauses;
+	ptr<Expr> timeout_time;
+	ptr<Stmt> timeout_stmt;
+	ptr<Expr> timeout_cond;
+	ptr<Stmt> else_stmt;
+	ptr<Expr> else_cond;
 
 	WaitForStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
@@ -411,4 +392,20 @@
 	WaitForStmt * clone() const override { return new WaitForStmt{ *this }; }
 	MUTATE_FRIEND
+};
+
+class WaitForClause final : public StmtClause {
+  public:
+    ptr<Expr> target_func;
+    std::vector<ptr<Expr>> target_args;
+    ptr<Stmt> stmt;
+    ptr<Expr> cond;
+
+    WaitForClause( const CodeLocation & loc )
+		: StmtClause( loc ) {}
+
+	const WaitForClause * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
+    WaitForClause * clone() const override { return new WaitForClause{ *this }; }
+    MUTATE_FRIEND
 };
 
Index: src/AST/Visitor.hpp
===================================================================
--- src/AST/Visitor.hpp	(revision 3c79ea90a8fd40d78d65b7465383c83051a807e0)
+++ src/AST/Visitor.hpp	(revision 4c530a517ad27e21191fa09816161ecc4ca7a818)
@@ -50,4 +50,5 @@
     virtual const ast::Stmt *             visit( const ast::SuspendStmt          * ) = 0;
     virtual const ast::Stmt *             visit( const ast::WaitForStmt          * ) = 0;
+    virtual const ast::WaitForClause *    visit( const ast::WaitForClause        * ) = 0;
     virtual const ast::Decl *             visit( const ast::WithStmt             * ) = 0;
     virtual const ast::NullStmt *         visit( const ast::NullStmt             * ) = 0;
Index: src/Common/CodeLocationTools.cpp
===================================================================
--- src/Common/CodeLocationTools.cpp	(revision 3c79ea90a8fd40d78d65b7465383c83051a807e0)
+++ src/Common/CodeLocationTools.cpp	(revision 4c530a517ad27e21191fa09816161ecc4ca7a818)
@@ -121,4 +121,5 @@
     macro(SuspendStmt, Stmt) \
     macro(WaitForStmt, Stmt) \
+    macro(WaitForClause, WaitForClause) \
     macro(WithStmt, Decl) \
     macro(NullStmt, NullStmt) \
Index: src/Parser/DeclarationNode.cc
===================================================================
--- src/Parser/DeclarationNode.cc	(revision 3c79ea90a8fd40d78d65b7465383c83051a807e0)
+++ src/Parser/DeclarationNode.cc	(revision 4c530a517ad27e21191fa09816161ecc4ca7a818)
@@ -253,5 +253,5 @@
 } // DeclarationNode::newAggregate
 
-DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body, bool typed) {
+DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body) {
 	DeclarationNode * newnode = new DeclarationNode;
 	newnode->type = new TypeData( TypeData::Enum );
@@ -272,9 +272,23 @@
 } // DeclarationNode::newName
 
-DeclarationNode * DeclarationNode::newEnumConstant( const string * name, ExpressionNode * constant ) { // Marker
+DeclarationNode * DeclarationNode::newEnumConstant( const string * name, ExpressionNode * constant ) {
 	DeclarationNode * newnode = newName( name );
 	newnode->enumeratorValue.reset( constant );
 	return newnode;
 } // DeclarationNode::newEnumConstant
+
+DeclarationNode * DeclarationNode::newEnumValueGeneric( const string * name, InitializerNode * init ) {
+	if ( init ) { // list init {} or a singleInit
+		if ( init->get_expression() ) { // singleInit
+			return newEnumConstant( name, init->get_expression() );
+		} else { // TODO: listInit
+			DeclarationNode * newnode = newName( name );
+			newnode->initializer = init;
+			return newnode;
+		} // if
+	} else {
+		return newName( name ); // Not explicitly inited enum value;
+	} // if
+} // DeclarationNode::newEnumGeneric
 
 DeclarationNode * DeclarationNode::newFromTypedef( const string * name ) {
Index: src/Parser/InitializerNode.cc
===================================================================
--- src/Parser/InitializerNode.cc	(revision 3c79ea90a8fd40d78d65b7465383c83051a807e0)
+++ src/Parser/InitializerNode.cc	(revision 4c530a517ad27e21191fa09816161ecc4ca7a818)
@@ -101,4 +101,5 @@
 	} else {
 		if ( get_expression() ) {
+			assertf( get_expression()->expr, "The expression of initializer must have value" );
 			return new SingleInit( maybeBuild< Expression >( get_expression() ), maybeConstructed );
 		} // if
Index: src/Parser/ParseNode.h
===================================================================
--- src/Parser/ParseNode.h	(revision 3c79ea90a8fd40d78d65b7465383c83051a807e0)
+++ src/Parser/ParseNode.h	(revision 4c530a517ad27e21191fa09816161ecc4ca7a818)
@@ -235,6 +235,7 @@
 	static DeclarationNode * newFunction( const std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body );
 	static DeclarationNode * newAggregate( AggregateDecl::Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
-	static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, bool typed );
+	static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body );
 	static DeclarationNode * newEnumConstant( const std::string * name, ExpressionNode * constant );
+	static DeclarationNode * newEnumValueGeneric( const std::string * name, InitializerNode * init );
 	static DeclarationNode * newName( const std::string * );
 	static DeclarationNode * newFromTypeGen( const std::string *, ExpressionNode * params );
Index: src/Parser/parser.yy
===================================================================
--- src/Parser/parser.yy	(revision 3c79ea90a8fd40d78d65b7465383c83051a807e0)
+++ src/Parser/parser.yy	(revision 4c530a517ad27e21191fa09816161ecc4ca7a818)
@@ -380,5 +380,5 @@
 
 %type<decl> enumerator_list enum_type enum_type_nobody
-%type<en> enumerator_value_opt
+%type<in> enumerator_value_opt
 
 %type<decl> external_definition external_definition_list external_definition_list_opt
@@ -2305,20 +2305,18 @@
 enum_type: // static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, bool typed );												// enum
 	ENUM attribute_list_opt '{' enumerator_list comma_opt '}'
-		{ $$ = DeclarationNode::newEnum( nullptr, $4, true, false )->addQualifiers( $2 ); }
+		{ $$ = DeclarationNode::newEnum( nullptr, $4, true )->addQualifiers( $2 ); }
 	| ENUM attribute_list_opt identifier
 		{ typedefTable.makeTypedef( *$3 ); }
 	  '{' enumerator_list comma_opt '}'
-		{ $$ = DeclarationNode::newEnum( $3, $6, true, false )->addQualifiers( $2 ); }
+		{ $$ = DeclarationNode::newEnum( $3, $6, true )->addQualifiers( $2 ); }
 	| ENUM attribute_list_opt typedef_name				// unqualified type name
 	  '{' enumerator_list comma_opt '}'
-		{ $$ = DeclarationNode::newEnum( $3->name, $5, true, false )->addQualifiers( $2 ); }
+		{ $$ = DeclarationNode::newEnum( $3->name, $5, true )->addQualifiers( $2 ); }
 	| ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt '{' enumerator_list comma_opt '}'
 	 	{
 			if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) 
 			{ SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
-			// SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr;
-
-			$$ = DeclarationNode::newEnum( nullptr, $7, true, true ) ->addQualifiers( $5 )  -> addEnumBase( $3 );
-			// $$ = DeclarationNode::newEnum( nullptr, $7, true, true ) ->addQualifiers( $5 );
+
+			$$ = DeclarationNode::newEnum( nullptr, $7, true ) ->addQualifiers( $5 )  -> addEnumBase( $3 );
 		}
 	| ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt // Question: why attributes/qualifier after identifier
@@ -2329,6 +2327,5 @@
 	  '{' enumerator_list comma_opt '}'
 		{
-			$$ = DeclarationNode::newEnum( $6, $10, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 ) -> addEnumBase( $3 );
-			// $$ = DeclarationNode::newEnum( $6, $10, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 );
+			$$ = DeclarationNode::newEnum( $6, $10, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 ) -> addEnumBase( $3 );
 		}
 	| ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt typedef_name attribute_list_opt '{' enumerator_list comma_opt '}'
@@ -2336,6 +2333,5 @@
 			if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
 			typedefTable.makeTypedef( *$6->name );
-			$$ = DeclarationNode::newEnum( $6->name, $9, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 ) -> addEnumBase( $3 );
-			// $$ = DeclarationNode::newEnum( $6->name, $9, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 );
+			$$ = DeclarationNode::newEnum( $6->name, $9, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 ) -> addEnumBase( $3 );
 		}
 	| enum_type_nobody
@@ -2344,18 +2340,18 @@
 enum_type_nobody:										// enum - {...}
 	ENUM attribute_list_opt identifier
-		{ typedefTable.makeTypedef( *$3 ); $$ = DeclarationNode::newEnum( $3, 0, false, false )->addQualifiers( $2 ); }
+		{ typedefTable.makeTypedef( *$3 ); $$ = DeclarationNode::newEnum( $3, 0, false )->addQualifiers( $2 ); }
 	| ENUM attribute_list_opt type_name					// qualified type name
-		{ typedefTable.makeTypedef( *$3->type->symbolic.name );	$$ = DeclarationNode::newEnum( $3->type->symbolic.name, 0, false, false )->addQualifiers( $2 ); }
+		{ typedefTable.makeTypedef( *$3->type->symbolic.name );	$$ = DeclarationNode::newEnum( $3->type->symbolic.name, 0, false )->addQualifiers( $2 ); }
 	;
 
 enumerator_list:
 	identifier_or_type_name enumerator_value_opt
-		{ $$ = DeclarationNode::newEnumConstant( $1, $2 ); }
+		{ $$ = DeclarationNode::newEnumValueGeneric( $1, $2 ); }
 	| INLINE type_name
-		{ $$ = DeclarationNode::newEnumConstant( new string("inline"), nullptr ); }
+		{ $$ = DeclarationNode::newEnumValueGeneric( new string("inline"), nullptr ); }
 	| enumerator_list ',' identifier_or_type_name enumerator_value_opt
-		{ $$ = $1->appendList( DeclarationNode::newEnumConstant( $3, $4 ) ); }
+		{ $$ = $1->appendList( DeclarationNode::newEnumValueGeneric( $3, $4 ) ); }
 	| enumerator_list ',' INLINE type_name enumerator_value_opt
-		{ $$ = $1->appendList( DeclarationNode::newEnumConstant( new string("inline"), nullptr ) ); }
+		{ $$ = $1->appendList( DeclarationNode::newEnumValueGeneric( new string("inline"), nullptr ) ); }
 	;
 
@@ -2366,5 +2362,5 @@
 	// 	{ $$ = $2; }
 	| simple_assignment_operator initializer
-		{ $$ = $2->get_expression(); }					// FIX ME: enum only deals with constant_expression
+		{ $$ = $1 == OperKinds::Assign ? $2 : $2->set_maybeConstructed( false ); }
 	;
 
Index: src/ResolvExpr/Resolver.cc
===================================================================
--- src/ResolvExpr/Resolver.cc	(revision 3c79ea90a8fd40d78d65b7465383c83051a807e0)
+++ src/ResolvExpr/Resolver.cc	(revision 4c530a517ad27e21191fa09816161ecc4ca7a818)
@@ -10,6 +10,6 @@
 // Created On       : Sun May 17 12:17:01 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Mar 18 10:41:00 2022
-// Update Count     : 247
+// Last Modified On : Wed Apr 20 10:41:00 2022
+// Update Count     : 248
 //
 
@@ -1738,5 +1738,5 @@
 		// Resolve all clauses first
 		for ( unsigned i = 0; i < stmt->clauses.size(); ++i ) {
-			const ast::WaitForStmt::Clause & clause = stmt->clauses[i];
+			const ast::WaitForClause & clause = *stmt->clauses[i];
 
 			ast::TypeEnvironment env;
@@ -1744,15 +1744,15 @@
 
 			// Find all candidates for a function in canonical form
-			funcFinder.find( clause.target.func, ResolvMode::withAdjustment() );
+			funcFinder.find( clause.target_func, ResolvMode::withAdjustment() );
 
 			if ( funcFinder.candidates.empty() ) {
 				stringstream ss;
 				ss << "Use of undeclared indentifier '";
-				ss << clause.target.func.strict_as< ast::NameExpr >()->name;
+				ss << clause.target_func.strict_as< ast::NameExpr >()->name;
 				ss << "' in call to waitfor";
 				SemanticError( stmt->location, ss.str() );
 			}
 
-			if ( clause.target.args.empty() ) {
+			if ( clause.target_args.empty() ) {
 				SemanticError( stmt->location,
 					"Waitfor clause must have at least one mutex parameter");
@@ -1761,5 +1761,5 @@
 			// Find all alternatives for all arguments in canonical form
 			std::vector< CandidateFinder > argFinders =
-				funcFinder.findSubExprs( clause.target.args );
+				funcFinder.findSubExprs( clause.target_args );
 
 			// List all combinations of arguments
@@ -1934,9 +1934,9 @@
 
 			// build new clause
-			ast::WaitForStmt::Clause clause2;
-
-			clause2.target.func = funcCandidates.front()->expr;
-
-			clause2.target.args.reserve( clause.target.args.size() );
+			auto clause2 = new ast::WaitForClause( clause.location );
+
+			clause2->target_func = funcCandidates.front()->expr;
+
+			clause2->target_args.reserve( clause.target_args.size() );
 			const ast::StructDecl * decl_monitor = symtab.lookupStruct( "monitor$" );
 			for ( auto arg : argsCandidates.front() ) {
@@ -1955,43 +1955,42 @@
 				);
 
-				clause2.target.args.emplace_back( findSingleExpression( init, context ) );
+				clause2->target_args.emplace_back( findSingleExpression( init, context ) );
 			}
 
 			// Resolve the conditions as if it were an IfStmt, statements normally
-			clause2.cond = findSingleExpression( clause.cond, context );
-			clause2.stmt = clause.stmt->accept( *visitor );
+			clause2->cond = findSingleExpression( clause.cond, context );
+			clause2->stmt = clause.stmt->accept( *visitor );
 
 			// set results into stmt
 			auto n = mutate( stmt );
-			n->clauses[i] = std::move( clause2 );
+			n->clauses[i] = clause2;
 			stmt = n;
 		}
 
-		if ( stmt->timeout.stmt ) {
+		if ( stmt->timeout_stmt ) {
 			// resolve the timeout as a size_t, the conditions like IfStmt, and stmts normally
-			ast::WaitForStmt::Timeout timeout2;
-
 			ast::ptr< ast::Type > target =
 				new ast::BasicType{ ast::BasicType::LongLongUnsignedInt };
-			timeout2.time = findSingleExpression( stmt->timeout.time, target, context );
-			timeout2.cond = findSingleExpression( stmt->timeout.cond, context );
-			timeout2.stmt = stmt->timeout.stmt->accept( *visitor );
+			auto timeout_time = findSingleExpression( stmt->timeout_time, target, context );
+			auto timeout_cond = findSingleExpression( stmt->timeout_cond, context );
+			auto timeout_stmt = stmt->timeout_stmt->accept( *visitor );
 
 			// set results into stmt
 			auto n = mutate( stmt );
-			n->timeout = std::move( timeout2 );
+			n->timeout_time = std::move( timeout_time );
+			n->timeout_cond = std::move( timeout_cond );
+			n->timeout_stmt = std::move( timeout_stmt );
 			stmt = n;
 		}
 
-		if ( stmt->orElse.stmt ) {
+		if ( stmt->else_stmt ) {
 			// resolve the condition like IfStmt, stmts normally
-			ast::WaitForStmt::OrElse orElse2;
-
-			orElse2.cond = findSingleExpression( stmt->orElse.cond, context );
-			orElse2.stmt = stmt->orElse.stmt->accept( *visitor );
+			auto else_cond = findSingleExpression( stmt->else_cond, context );
+			auto else_stmt = stmt->else_stmt->accept( *visitor );
 
 			// set results into stmt
 			auto n = mutate( stmt );
-			n->orElse = std::move( orElse2 );
+			n->else_cond = std::move( else_cond );
+			n->else_stmt = std::move( else_stmt );
 			stmt = n;
 		}
Index: src/SynTree/Visitor.h
===================================================================
--- src/SynTree/Visitor.h	(revision 3c79ea90a8fd40d78d65b7465383c83051a807e0)
+++ src/SynTree/Visitor.h	(revision 4c530a517ad27e21191fa09816161ecc4ca7a818)
@@ -35,5 +35,5 @@
 	virtual void visit( UnionDecl * node ) { visit( const_cast<const UnionDecl *>(node) ); }
 	virtual void visit( const UnionDecl * aggregateDecl ) = 0;
-	virtual void visit( EnumDecl * node ) { visit( const_cast<const EnumDecl *>(node) ); } // Marker 1
+	virtual void visit( EnumDecl * node ) { visit( const_cast<const EnumDecl *>(node) ); }
 	virtual void visit( const EnumDecl * aggregateDecl ) = 0;
 	virtual void visit( TraitDecl * node ) { visit( const_cast<const TraitDecl *>(node) ); }
@@ -190,5 +190,5 @@
 	virtual void visit( UnionInstType * node ) { visit( const_cast<const UnionInstType *>(node) ); }
 	virtual void visit( const UnionInstType * aggregateUseType ) = 0;
-	virtual void visit( EnumInstType * node ) { visit( const_cast<const EnumInstType *>(node) ); } // Marker 2
+	virtual void visit( EnumInstType * node ) { visit( const_cast<const EnumInstType *>(node) ); }
 	virtual void visit( const EnumInstType * aggregateUseType ) = 0;
 	virtual void visit( TraitInstType * node ) { visit( const_cast<const TraitInstType *>(node) ); }