Changes in src/ResolvExpr/Resolver.cc [a4ca48c:1dcd9554]

File:

• src/ResolvExpr/Resolver.cc (modified) (24 diffs)

src/ResolvExpr/Resolver.cc

@@ -21 +21 @@
 #include "Alternative.h"                 // for Alternative, AltList
 #include "AlternativeFinder.h"           // for AlternativeFinder, resolveIn...
-#include "Common/PassVisitor.h"          // for PassVisitor
 #include "Common/SemanticError.h"        // for SemanticError
 #include "Common/utility.h"              // for ValueGuard, group_iterate
@@ -40 +39 @@
 #include "SynTree/Visitor.h"             // for acceptAll, maybeAccept
 #include "typeops.h"                     // for extractResultType
+#include "Unify.h"                       // for unify
 
 using namespace std;
 
 namespace ResolvExpr {
-        struct Resolver final : public WithIndexer, public WithGuards, public WithVisitorRef<Resolver>, public WithShortCircuiting {
-                Resolver() {}
-                Resolver( const SymTab::Indexer & other ) {
-                        indexer = other;
-                }
-
-                void previsit( FunctionDecl *functionDecl );
-                void postvisit( FunctionDecl *functionDecl );
-                void previsit( ObjectDecl *functionDecl );
-                void previsit( TypeDecl *typeDecl );
-                void previsit( EnumDecl * enumDecl );
-
-                void previsit( ArrayType * at );
-                void previsit( PointerType * at );
-
-                void previsit( ExprStmt *exprStmt );
-                void previsit( AsmExpr *asmExpr );
-                void previsit( AsmStmt *asmStmt );
-                void previsit( IfStmt *ifStmt );
-                void previsit( WhileStmt *whileStmt );
-                void previsit( ForStmt *forStmt );
-                void previsit( SwitchStmt *switchStmt );
-                void previsit( CaseStmt *caseStmt );
-                void previsit( BranchStmt *branchStmt );
-                void previsit( ReturnStmt *returnStmt );
-                void previsit( ThrowStmt *throwStmt );
-                void previsit( CatchStmt *catchStmt );
-
-                void previsit( SingleInit *singleInit );
-                void previsit( ListInit *listInit );
-                void previsit( ConstructorInit *ctorInit );
+        class Resolver final : public SymTab::Indexer {
+          public:
+                Resolver() : SymTab::Indexer( false ) {}
+                Resolver( const SymTab:: Indexer & other ) : SymTab::Indexer( other ) {
+                        if ( const Resolver * res = dynamic_cast< const Resolver * >( &other ) ) {
+                                functionReturn = res->functionReturn;
+                                currentObject = res->currentObject;
+                                inEnumDecl = res->inEnumDecl;
+                        }
+                }
+
+                typedef SymTab::Indexer Parent;
+                using Parent::visit;
+                virtual void visit( FunctionDecl *functionDecl ) override;
+                virtual void visit( ObjectDecl *functionDecl ) override;
+                virtual void visit( TypeDecl *typeDecl ) override;
+                virtual void visit( EnumDecl * enumDecl ) override;
+
+                virtual void visit( ArrayType * at ) override;
+                virtual void visit( PointerType * at ) override;
+
+                virtual void visit( ExprStmt *exprStmt ) override;
+                virtual void visit( AsmExpr *asmExpr ) override;
+                virtual void visit( AsmStmt *asmStmt ) override;
+                virtual void visit( IfStmt *ifStmt ) override;
+                virtual void visit( WhileStmt *whileStmt ) override;
+                virtual void visit( ForStmt *forStmt ) override;
+                virtual void visit( SwitchStmt *switchStmt ) override;
+                virtual void visit( CaseStmt *caseStmt ) override;
+                virtual void visit( BranchStmt *branchStmt ) override;
+                virtual void visit( ReturnStmt *returnStmt ) override;
+                virtual void visit( ThrowStmt *throwStmt ) override;
+                virtual void visit( CatchStmt *catchStmt ) override;
+                virtual void visit( WaitForStmt *waitforStmt ) override;
+
+                virtual void visit( SingleInit *singleInit ) override;
+                virtual void visit( ListInit *listInit ) override;
+                virtual void visit( ConstructorInit *ctorInit ) override;
           private:
         typedef std::list< Initializer * >::iterator InitIterator;
@@ -91 +98 @@
 
         void resolve( std::list< Declaration * > translationUnit ) {
-                PassVisitor<Resolver> resolver;
+                Resolver resolver;
                 acceptAll( translationUnit, resolver );
         }
 
-        // used in resolveTypeof
         Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer ) {
                 TypeEnvironment env;
                 return resolveInVoidContext( expr, indexer, env );
         }
+
 
         namespace {
@@ -185 +192 @@
         }
 
-        void Resolver::previsit( ObjectDecl *objectDecl ) {
-                Type *new_type = resolveTypeof( objectDecl->get_type(), indexer );
+        void Resolver::visit( ObjectDecl *objectDecl ) {
+                Type *new_type = resolveTypeof( objectDecl->get_type(), *this );
                 objectDecl->set_type( new_type );
                 // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that class-variable
@@ -193 +200 @@
                 // each value of initContext is retained, so the type on the first analysis is preserved and used for selecting
                 // the RHS.
-                GuardValue( currentObject );
+                ValueGuard<CurrentObject> temp( currentObject );
                 currentObject = CurrentObject( objectDecl->get_type() );
                 if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) {
@@ -200 +207 @@
                         currentObject = CurrentObject( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
                 }
+                Parent::visit( objectDecl );
+                if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) {
+                        // delete newly created signed int type
+                        // delete currentObject.getType();
+                }
         }
 
@@ -206 +218 @@
                 if ( type->get_dimension() ) {
                         CastExpr *castExpr = new CastExpr( type->get_dimension(), SymTab::SizeType->clone() );
-                        Expression *newExpr = findSingleExpression( castExpr, indexer );
+                        Expression *newExpr = findSingleExpression( castExpr, *this );
                         delete type->get_dimension();
                         type->set_dimension( newExpr );
@@ -212 +224 @@
         }
 
-        void Resolver::previsit( ArrayType * at ) {
+        void Resolver::visit( ArrayType * at ) {
                 handlePtrType( at );
-        }
-
-        void Resolver::previsit( PointerType * pt ) {
+                Parent::visit( at );
+        }
+
+        void Resolver::visit( PointerType * pt ) {
                 handlePtrType( pt );
-        }
-
-        void Resolver::previsit( TypeDecl *typeDecl ) {
+                Parent::visit( pt );
+        }
+
+        void Resolver::visit( TypeDecl *typeDecl ) {
                 if ( typeDecl->get_base() ) {
-                        Type *new_type = resolveTypeof( typeDecl->get_base(), indexer );
+                        Type *new_type = resolveTypeof( typeDecl->get_base(), *this );
                         typeDecl->set_base( new_type );
                 } // if
-        }
-
-        void Resolver::previsit( FunctionDecl *functionDecl ) {
+                Parent::visit( typeDecl );
+        }
+
+        void Resolver::visit( FunctionDecl *functionDecl ) {
 #if 0
-                std::cerr << "resolver visiting functiondecl ";
-                functionDecl->print( std::cerr );
-                std::cerr << std::endl;
+                std::cout << "resolver visiting functiondecl ";
+                functionDecl->print( std::cout );
+                std::cout << std::endl;
 #endif
-                Type *new_type = resolveTypeof( functionDecl->get_type(), indexer );
+                Type *new_type = resolveTypeof( functionDecl->get_type(), *this );
                 functionDecl->set_type( new_type );
-                GuardValue( functionReturn );
+                ValueGuard< Type * > oldFunctionReturn( functionReturn );
                 functionReturn = ResolvExpr::extractResultType( functionDecl->get_functionType() );
-        }
-
-
-        void Resolver::postvisit( FunctionDecl *functionDecl ) {
+                Parent::visit( functionDecl );
+
                 // default value expressions have an environment which shouldn't be there and trips up later passes.
                 // xxx - it might be necessary to somehow keep the information from this environment, but I can't currently
@@ -254 +267 @@
         }
 
-        void Resolver::previsit( EnumDecl * ) {
+        void Resolver::visit( EnumDecl * enumDecl ) {
                 // in case we decide to allow nested enums
-                GuardValue( inEnumDecl );
+                ValueGuard< bool > oldInEnumDecl( inEnumDecl );
                 inEnumDecl = true;
-        }
-
-        void Resolver::previsit( ExprStmt *exprStmt ) {
-                visit_children = false;
+                Parent::visit( enumDecl );
+        }
+
+        void Resolver::visit( ExprStmt *exprStmt ) {
                 assertf( exprStmt->get_expr(), "ExprStmt has null Expression in resolver" );
-                Expression *newExpr = findVoidExpression( exprStmt->get_expr(), indexer );
+                Expression *newExpr = findVoidExpression( exprStmt->get_expr(), *this );
                 delete exprStmt->get_expr();
                 exprStmt->set_expr( newExpr );
         }
 
-        void Resolver::previsit( AsmExpr *asmExpr ) {
-                visit_children = false;
-                Expression *newExpr = findVoidExpression( asmExpr->get_operand(), indexer );
+        void Resolver::visit( AsmExpr *asmExpr ) {
+                Expression *newExpr = findVoidExpression( asmExpr->get_operand(), *this );
                 delete asmExpr->get_operand();
                 asmExpr->set_operand( newExpr );
                 if ( asmExpr->get_inout() ) {
-                        newExpr = findVoidExpression( asmExpr->get_inout(), indexer );
+                        newExpr = findVoidExpression( asmExpr->get_inout(), *this );
                         delete asmExpr->get_inout();
                         asmExpr->set_inout( newExpr );
@@ -280 +292 @@
         }
 
-        void Resolver::previsit( AsmStmt *asmStmt ) {
-                visit_children = false;
-                acceptAll( asmStmt->get_input(), *visitor );
-                acceptAll( asmStmt->get_output(), *visitor );
-        }
-
-        void Resolver::previsit( IfStmt *ifStmt ) {
-                Expression *newExpr = findSingleExpression( ifStmt->get_condition(), indexer );
+        void Resolver::visit( AsmStmt *asmStmt ) {
+                acceptAll( asmStmt->get_input(), *this);
+                acceptAll( asmStmt->get_output(), *this);
+        }
+
+        void Resolver::visit( IfStmt *ifStmt ) {
+                Expression *newExpr = findSingleExpression( ifStmt->get_condition(), *this );
                 delete ifStmt->get_condition();
                 ifStmt->set_condition( newExpr );
-        }
-
-        void Resolver::previsit( WhileStmt *whileStmt ) {
-                Expression *newExpr = findSingleExpression( whileStmt->get_condition(), indexer );
+                Parent::visit( ifStmt );
+        }
+
+        void Resolver::visit( WhileStmt *whileStmt ) {
+                Expression *newExpr = findSingleExpression( whileStmt->get_condition(), *this );
                 delete whileStmt->get_condition();
                 whileStmt->set_condition( newExpr );
-        }
-
-        void Resolver::previsit( ForStmt *forStmt ) {
+                Parent::visit( whileStmt );
+        }
+
+        void Resolver::visit( ForStmt *forStmt ) {
+                Parent::visit( forStmt );
+
                 if ( forStmt->get_condition() ) {
-                        Expression * newExpr = findSingleExpression( forStmt->get_condition(), indexer );
+                        Expression * newExpr = findSingleExpression( forStmt->get_condition(), *this );
                         delete forStmt->get_condition();
                         forStmt->set_condition( newExpr );
@@ -306 +321 @@
 
                 if ( forStmt->get_increment() ) {
-                        Expression * newExpr = findVoidExpression( forStmt->get_increment(), indexer );
+                        Expression * newExpr = findVoidExpression( forStmt->get_increment(), *this );
                         delete forStmt->get_increment();
                         forStmt->set_increment( newExpr );
@@ -312 +327 @@
         }
 
-        void Resolver::previsit( SwitchStmt *switchStmt ) {
-                GuardValue( currentObject );
+        void Resolver::visit( SwitchStmt *switchStmt ) {
+                ValueGuard< CurrentObject > oldCurrentObject( currentObject );
                 Expression *newExpr;
-                newExpr = findIntegralExpression( switchStmt->get_condition(), indexer );
+                newExpr = findIntegralExpression( switchStmt->get_condition(), *this );
                 delete switchStmt->get_condition();
                 switchStmt->set_condition( newExpr );
 
                 currentObject = CurrentObject( newExpr->get_result() );
-        }
-
-        void Resolver::previsit( CaseStmt *caseStmt ) {
+                Parent::visit( switchStmt );
+        }
+
+        void Resolver::visit( CaseStmt *caseStmt ) {
                 if ( caseStmt->get_condition() ) {
                         std::list< InitAlternative > initAlts = currentObject.getOptions();
                         assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral expression." );
                         CastExpr * castExpr = new CastExpr( caseStmt->get_condition(), initAlts.front().type->clone() );
-                        Expression * newExpr = findSingleExpression( castExpr, indexer );
+                        Expression * newExpr = findSingleExpression( castExpr, *this );
                         castExpr = strict_dynamic_cast< CastExpr * >( newExpr );
                         caseStmt->set_condition( castExpr->get_arg() );
@@ -333 +349 @@
                         delete castExpr;
                 }
-        }
-
-        void Resolver::previsit( BranchStmt *branchStmt ) {
-                visit_children = false;
+                Parent::visit( caseStmt );
+        }
+
+        void Resolver::visit( BranchStmt *branchStmt ) {
                 // must resolve the argument for a computed goto
                 if ( branchStmt->get_type() == BranchStmt::Goto ) { // check for computed goto statement
@@ -343 +359 @@
                                 PointerType pt( Type::Qualifiers(), v.clone() );
                                 CastExpr * castExpr = new CastExpr( arg, pt.clone() );
-                                Expression * newExpr = findSingleExpression( castExpr, indexer ); // find best expression
+                                Expression * newExpr = findSingleExpression( castExpr, *this ); // find best expression
                                 branchStmt->set_target( newExpr );
                         } // if
@@ -349 +365 @@
         }
 
-        void Resolver::previsit( ReturnStmt *returnStmt ) {
-                visit_children = false;
+        void Resolver::visit( ReturnStmt *returnStmt ) {
                 if ( returnStmt->get_expr() ) {
                         CastExpr *castExpr = new CastExpr( returnStmt->get_expr(), functionReturn->clone() );
-                        Expression *newExpr = findSingleExpression( castExpr, indexer );
+                        Expression *newExpr = findSingleExpression( castExpr, *this );
                         delete castExpr;
                         returnStmt->set_expr( newExpr );
@@ -359 +374 @@
         }
 
-        void Resolver::previsit( ThrowStmt *throwStmt ) {
-                visit_children = false;
+        void Resolver::visit( ThrowStmt *throwStmt ) {
                 // TODO: Replace *exception type with &exception type.
                 if ( throwStmt->get_expr() ) {
                         StructDecl * exception_decl =
-                                indexer.lookupStruct( "__cfaehm__base_exception_t" );
+                                lookupStruct( "__cfaehm__base_exception_t" );
                         assert( exception_decl );
                         Expression * wrapped = new CastExpr(
@@ -376 +390 @@
                                         )
                                 );
-                        Expression * newExpr = findSingleExpression( wrapped, indexer );
+                        Expression * newExpr = findSingleExpression( wrapped, *this );
                         throwStmt->set_expr( newExpr );
                 }
         }
 
-        void Resolver::previsit( CatchStmt *catchStmt ) {
+        void Resolver::visit( CatchStmt *catchStmt ) {
+                // inline Indexer::visit so that the exception variable is still in-scope for
+                // findSingleExpression() below
+                Parent::enterScope();
+                Visitor::visit( catchStmt );
+
                 if ( catchStmt->get_cond() ) {
                         Expression * wrapped = new CastExpr(
@@ -387 +406 @@
                                 new BasicType( noQualifiers, BasicType::Bool )
                                 );
-                        catchStmt->set_cond( findSingleExpression( wrapped, indexer ) );
+                        catchStmt->set_cond( findSingleExpression( wrapped, *this ) );
+                }
+
+                Parent::leaveScope();
+        }
+
+        inline void resolveAsIf( Expression *& expr, Resolver & resolver ) {
+                if( !expr ) return;
+                Expression * newExpr = findSingleExpression( expr, resolver );
+                delete expr;
+                expr = newExpr;
+        }
+
+        inline void resolveAsType( Expression *& expr, Type * type, Resolver & resolver ) {
+                if( !expr ) return;
+                Expression * newExpr = findSingleExpression( new CastExpr( expr, type ), resolver );
+                delete expr;
+                expr = newExpr;
+        }
+
+        template< typename iterator_t >
+        inline bool advance_to_mutex( iterator_t & it, const iterator_t & end ) {
+                while( it != end && !(*it)->get_type()->get_mutex() ) {
+                        it++;
+                }
+
+                return it != end;
+        }
+
+        void Resolver::visit( WaitForStmt * stmt ) {
+
+                // Resolve all clauses first
+                for( auto& clause : stmt->clauses ) {
+
+                        TypeEnvironment env;
+                        AlternativeFinder funcFinder( *this, env );
+
+                        // Find all alternatives for a function in canonical form
+                        funcFinder.findWithAdjustment( clause.target.function );
+
+                        if ( funcFinder.get_alternatives().empty() ) {
+                                stringstream ss;
+                                ss << "Use of undeclared indentifier '";
+                                ss << strict_dynamic_cast<NameExpr*>( clause.target.function )->name;
+                                ss << "' in call to waitfor";
+                                throw SemanticError( ss.str() );
+                        }
+
+                        // Find all alternatives for all arguments in canonical form
+                        std::list< AlternativeFinder > argAlternatives;
+                        funcFinder.findSubExprs( clause.target.arguments.begin(), clause.target.arguments.end(), back_inserter( argAlternatives ) );
+
+                        // List all combinations of arguments
+                        std::list< AltList > possibilities;
+                        combos( argAlternatives.begin(), argAlternatives.end(), back_inserter( possibilities ) );
+
+                        AltList                func_candidates;
+                        std::vector< AltList > args_candidates;
+
+                        // For every possible function :
+                        //      try matching the arguments to the parameters
+                        //      not the other way around because we have more arguments than parameters
+                        SemanticError errors;
+                        for ( Alternative & func : funcFinder.get_alternatives() ) {
+                                try {
+                                        PointerType * pointer = dynamic_cast< PointerType* >( func.expr->get_result()->stripReferences() );
+                                        if( !pointer ) {
+                                                throw SemanticError( "candidate not viable: not a pointer type\n", func.expr->get_result() );
+                                        }
+
+                                        FunctionType * function = dynamic_cast< FunctionType* >( pointer->get_base() );
+                                        if( !function ) {
+                                                throw SemanticError( "candidate not viable: not a function type\n", pointer->get_base() );
+                                        }
+
+
+                                        {
+                                                auto param     = function->parameters.begin();
+                                                auto param_end = function->parameters.end();
+
+                                                if( !advance_to_mutex( param, param_end ) ) {
+                                                        throw SemanticError("candidate function not viable: no mutex parameters\n", function);
+                                                }
+                                        }
+
+                                        Alternative newFunc( func );
+                                        // Strip reference from function
+                                        referenceToRvalueConversion( newFunc.expr );
+
+                                        // For all the set of arguments we have try to match it with the parameter of the current function alternative
+                                        for ( auto & argsList : possibilities ) {
+
+                                                try {
+                                                        // Declare data structures need for resolution
+                                                        OpenVarSet openVars;
+                                                        AssertionSet resultNeed, resultHave;
+                                                        TypeEnvironment resultEnv;
+
+                                                        // Load type variables from arguemnts into one shared space
+                                                        simpleCombineEnvironments( argsList.begin(), argsList.end(), resultEnv );
+
+                                                        // Make sure we don't widen any existing bindings
+                                                        for ( auto & i : resultEnv ) {
+                                                                i.allowWidening = false;
+                                                        }
+
+                                                        // Find any unbound type variables
+                                                        resultEnv.extractOpenVars( openVars );
+
+                                                        auto param     = function->parameters.begin();
+                                                        auto param_end = function->parameters.end();
+
+                                                        // For every arguments of its set, check if it matches one of the parameter
+                                                        // The order is important
+                                                        for( auto & arg : argsList ) {
+
+                                                                // Ignore non-mutex arguments
+                                                                if( !advance_to_mutex( param, param_end ) ) {
+                                                                        // We ran out of parameters but still have arguments
+                                                                        // this function doesn't match
+                                                                        throw SemanticError("candidate function not viable: too many mutex arguments\n", function);
+                                                                }
+
+                                                                // Check if the argument matches the parameter type in the current scope
+                                                                if( ! unify( (*param)->get_type(), arg.expr->get_result(), resultEnv, resultNeed, resultHave, openVars, *this ) ) {
+                                                                        // Type doesn't match
+                                                                        stringstream ss;
+                                                                        ss << "candidate function not viable: no known convertion from '";
+                                                                        arg.expr->get_result()->print( ss );
+                                                                        ss << "' to '";
+                                                                        (*param)->get_type()->print( ss );
+                                                                        ss << "'\n";
+                                                                        throw SemanticError(ss.str(), function);
+                                                                }
+
+                                                                param++;
+                                                        }
+
+                                                        // All arguments match !
+
+                                                        // Check if parameters are missing
+                                                        if( advance_to_mutex( param, param_end ) ) {
+                                                                // We ran out of arguments but still have parameters left
+                                                                // this function doesn't match
+                                                                throw SemanticError("candidate function not viable: too few mutex arguments\n", function);
+                                                        }
+
+                                                        // All parameters match !
+
+                                                        // Finish the expressions to tie in the proper environments
+                                                        finishExpr( newFunc.expr, resultEnv );
+                                                        for( Alternative & alt : argsList ) {
+                                                                finishExpr( alt.expr, resultEnv );
+                                                        }
+
+                                                        // This is a match store it and save it for later
+                                                        func_candidates.push_back( newFunc );
+                                                        args_candidates.push_back( argsList );
+
+                                                }
+                                                catch( SemanticError &e ) {
+                                                        errors.append( e );
+                                                }
+                                        }
+                                }
+                                catch( SemanticError &e ) {
+                                        errors.append( e );
+                                }
+                        }
+
+                        // Make sure we got the right number of arguments
+                        if( func_candidates.empty() )    { SemanticError top( "No alternatives for function in call to waitfor"  ); top.append( errors ); throw top; }
+                        if( args_candidates.empty() )    { SemanticError top( "No alternatives for arguments in call to waitfor" ); top.append( errors ); throw top; }
+                        if( func_candidates.size() > 1 ) { SemanticError top( "Ambiguous function in call to waitfor"            ); top.append( errors ); throw top; }
+                        if( args_candidates.size() > 1 ) { SemanticError top( "Ambiguous arguments in call to waitfor"           ); top.append( errors ); throw top; }
+
+
+                        // Swap the results from the alternative with the unresolved values.
+                        // Alternatives will handle deletion on destruction
+                        std::swap( clause.target.function, func_candidates.front().expr );
+                        for( auto arg_pair : group_iterate( clause.target.arguments, args_candidates.front() ) ) {
+                                std::swap ( std::get<0>( arg_pair), std::get<1>( arg_pair).expr );
+                        }
+
+                        // Resolve the conditions as if it were an IfStmt
+                        // Resolve the statments normally
+                        resolveAsIf( clause.condition, *this );
+                        clause.statement->accept( *this );
+                }
+
+
+                if( stmt->timeout.statement ) {
+                        // Resolve the timeout as an size_t for now
+                        // Resolve the conditions as if it were an IfStmt
+                        // Resolve the statments normally
+                        resolveAsType( stmt->timeout.time, new BasicType( noQualifiers, BasicType::LongLongUnsignedInt ), *this );
+                        resolveAsIf  ( stmt->timeout.condition, *this );
+                        stmt->timeout.statement->accept( *this );
+                }
+
+                if( stmt->orelse.statement ) {
+                        // Resolve the conditions as if it were an IfStmt
+                        // Resolve the statments normally
+                        resolveAsIf( stmt->orelse.condition, *this );
+                        stmt->orelse.statement->accept( *this );
                 }
         }
@@ -400 +623 @@
         }
 
-        void Resolver::previsit( SingleInit *singleInit ) {
-                visit_children = false;
+        void Resolver::visit( SingleInit *singleInit ) {
                 // resolve initialization using the possibilities as determined by the currentObject cursor
                 UntypedInitExpr * untyped = new UntypedInitExpr( singleInit->get_value(), currentObject.getOptions() );
-                Expression * newExpr = findSingleExpression( untyped, indexer );
+                Expression * newExpr = findSingleExpression( untyped, *this );
                 InitExpr * initExpr = strict_dynamic_cast< InitExpr * >( newExpr );
 
@@ -443 +665 @@
         }
 
-        void Resolver::previsit( ListInit * listInit ) {
-                visit_children = false;
+        void Resolver::visit( ListInit * listInit ) {
                 // move cursor into brace-enclosed initializer-list
                 currentObject.enterListInit();
@@ -455 +676 @@
                         Initializer * init = std::get<1>(p);
                         newDesignations.push_back( currentObject.findNext( des ) );
-                        init->accept( *visitor );
+                        init->accept( *this );
                 }
                 // set the set of 'resolved' designations and leave the brace-enclosed initializer-list
@@ -484 +705 @@
                 delete ctorInit->get_dtor();
                 ctorInit->set_dtor( NULL );
-                maybeAccept( ctorInit->get_init(), *visitor );
+                maybeAccept( ctorInit->get_init(), *this );
         }
 
@@ -490 +711 @@
         void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer ) {
                 assert( ctorInit );
-                PassVisitor<Resolver> resolver( indexer );
+                Resolver resolver( indexer );
                 ctorInit->accept( resolver );
         }
@@ -496 +717 @@
         void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer ) {
                 assert( stmtExpr );
-                PassVisitor<Resolver> resolver( indexer );
+                Resolver resolver( indexer );
                 stmtExpr->accept( resolver );
         }
 
-        void Resolver::previsit( ConstructorInit *ctorInit ) {
-                visit_children = false;
+        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
-                maybeAccept( ctorInit->get_ctor(), *visitor );
-                maybeAccept( ctorInit->get_dtor(), *visitor );
+                maybeAccept( ctorInit->get_ctor(), *this );
+                maybeAccept( ctorInit->get_dtor(), *this );
 
                 // found a constructor - can get rid of C-style initializer