Index: src/ResolvExpr/Resolver.cc
===================================================================
--- src/ResolvExpr/Resolver.cc	(revision 722617d490808c780a86a748504d8dec075c2103)
+++ src/ResolvExpr/Resolver.cc	(revision d5556a3ceec1d963a2e9c0fccbfe2ff51b6eb263)
@@ -36,6 +36,14 @@
 	  public:
 		Resolver() : SymTab::Indexer( false ) {}
-
-		using SymTab::Indexer::visit;
+		Resolver( const SymTab:: Indexer & other ) : SymTab::Indexer( other ) {
+			if ( const Resolver * res = dynamic_cast< const Resolver * >( &other ) ) {
+				functionReturn = res->functionReturn;
+				initContext = res->initContext;
+				inEnumDecl = res->inEnumDecl;
+			}
+		}
+
+		typedef SymTab::Indexer Parent;
+		using Parent::visit;
 		virtual void visit( FunctionDecl *functionDecl ) override;
 		virtual void visit( ObjectDecl *functionDecl ) override;
@@ -192,5 +200,5 @@
 			initContext = new BasicType( Type::Qualifiers(), BasicType::SignedInt );
 		}
-		SymTab::Indexer::visit( objectDecl );
+		Parent::visit( objectDecl );
 		if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) {
 			// delete newly created signed int type
@@ -212,10 +220,10 @@
 	void Resolver::visit( ArrayType * at ) {
 		handlePtrType( at );
-		Visitor::visit( at );
+		Parent::visit( at );
 	}
 
 	void Resolver::visit( PointerType * pt ) {
 		handlePtrType( pt );
-		Visitor::visit( pt );
+		Parent::visit( pt );
 	}
 
@@ -225,5 +233,5 @@
 			typeDecl->set_base( new_type );
 		} // if
-		SymTab::Indexer::visit( typeDecl );
+		Parent::visit( typeDecl );
 	}
 
@@ -238,21 +246,19 @@
 		ValueGuard< Type * > oldFunctionReturn( functionReturn );
 		functionReturn = ResolvExpr::extractResultType( functionDecl->get_functionType() );
-		SymTab::Indexer::visit( functionDecl );
+		Parent::visit( functionDecl );
 	}
 
 	void Resolver::visit( EnumDecl * enumDecl ) {
 		// in case we decide to allow nested enums
-		bool oldInEnumDecl = inEnumDecl;
+		ValueGuard< bool > oldInEnumDecl( inEnumDecl );
 		inEnumDecl = true;
-		SymTab::Indexer::visit( enumDecl );
-		inEnumDecl = oldInEnumDecl;
+		Parent::visit( enumDecl );
 	}
 
 	void Resolver::visit( ExprStmt *exprStmt ) {
-		if ( exprStmt->get_expr() ) {
-			Expression *newExpr = findVoidExpression( exprStmt->get_expr(), *this );
-			delete exprStmt->get_expr();
-			exprStmt->set_expr( newExpr );
-		} // if
+		assertf( exprStmt->get_expr(), "ExprStmt has null Expression in resolver" );
+		Expression *newExpr = findVoidExpression( exprStmt->get_expr(), *this );
+		delete exprStmt->get_expr();
+		exprStmt->set_expr( newExpr );
 	}
 
@@ -277,5 +283,5 @@
 		delete ifStmt->get_condition();
 		ifStmt->set_condition( newExpr );
-		Visitor::visit( ifStmt );
+		Parent::visit( ifStmt );
 	}
 
@@ -284,9 +290,9 @@
 		delete whileStmt->get_condition();
 		whileStmt->set_condition( newExpr );
-		Visitor::visit( whileStmt );
+		Parent::visit( whileStmt );
 	}
 
 	void Resolver::visit( ForStmt *forStmt ) {
-		SymTab::Indexer::visit( forStmt );
+		Parent::visit( forStmt );
 
 		if ( forStmt->get_condition() ) {
@@ -318,5 +324,5 @@
 
 	void Resolver::visit( CaseStmt *caseStmt ) {
-		Visitor::visit( caseStmt );
+		Parent::visit( caseStmt );
 	}
 
@@ -482,11 +488,11 @@
 			} else {
 				// missing implementation type -- might be an unknown type variable, so try proceeding with the current init context
-				Visitor::visit( listInit );
+				Parent::visit( listInit );
 			}
 		} else {
 			assert( dynamic_cast< BasicType * >( initContext ) || dynamic_cast< PointerType * >( initContext )
-			        || dynamic_cast< ZeroType * >( initContext ) || dynamic_cast< OneType * >( initContext ) );
+			        || dynamic_cast< ZeroType * >( initContext ) || dynamic_cast< OneType * >( initContext ) || dynamic_cast < EnumInstType * > ( initContext ) );
 			// basic types are handled here
-			Visitor::visit( listInit );
+			Parent::visit( listInit );
 		}
 
@@ -554,4 +560,17 @@
 	}
 
+	// needs to be callable from outside the resolver, so this is a standalone function
+	void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer ) {
+		assert( ctorInit );
+		Resolver resolver( indexer );
+		ctorInit->accept( resolver );
+	}
+
+	void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer ) {
+		assert( stmtExpr );
+		Resolver resolver( indexer );
+		stmtExpr->accept( resolver );
+	}
+
 	void Resolver::visit( ConstructorInit *ctorInit ) {
 		// xxx - fallback init has been removed => remove fallbackInit function and remove complexity from FixInit and remove C-init from ConstructorInit
Index: src/ResolvExpr/Resolver.h
===================================================================
--- src/ResolvExpr/Resolver.h	(revision 722617d490808c780a86a748504d8dec075c2103)
+++ src/ResolvExpr/Resolver.h	(revision d5556a3ceec1d963a2e9c0fccbfe2ff51b6eb263)
@@ -25,4 +25,6 @@
 	Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer );
 	Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer );
+	void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer );
+	void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer );
 } // namespace ResolvExpr